• c++的类和对象（中）：默认成员函数与运算符重载（重难点！！）

    前言 

    Hello, 小伙伴们，我们今天继续c++的学习，我们上期有介绍到c++的部分特性，以及一些区别于c语言的地方，今天我们将继续深入了解c++的类和对象，探索c++的奥秘。

    好，废话不多说，开始我们今天的学习。 

    1.类默认成员函数

    默认成员函数就是用户没有显示实现，编译器会自动生成的函数称为默认成员函数。一个类，我们不写的情况下，编译器会默认生成6个默认函数，需要注意的是这六个函数中重要的是前4个，最后两个取地址重载不重要，我们稍微了解一下就好。其次，c++11以后还会增加两个默认的函数，移动构造和移动赋值，这个我们后面再讲解。默认成员函数十分的重要，也比较复杂，我们要从两个方面去学习：

    第一：我们不写默认函数时， 编译器默认的函数行为是什么，是否能满足我们的要求。

    第二：编译器默认生成的函数不满足我们的要求时，我们要自己去实现符合要求的函数。

     

    1.1构造函数 

    构造函数就是特别的成员函数，需要注意的是，构造函数虽然名为构造，但是构造函数的主要任务不是开辟空间创建对象（我们之前使用的局部对象是栈帧创建时，就开辟好的），而对象的实例化时初始化对象。构造函数的本质就是要替代我们之前在实现Stack 和 Queue类中的Init函数功能，构造函数自动调用的特点就完美的替代了Init函数。

    构造函数的特点：

    1.函数名与类名相同。会自动生成一个无参数的默认构造函数，一旦用户显示定义，编译器就不会再生成默认的

    2.无返回值（返回值啥的都不需要给，也不需要void， 也不需要纠结， c++的一定就是如此）。
    3.对象实例化时西永会    和全缺省函数也是默认构造函数，总结一下就是不传实参就可

    自动调用构造函数。

    4.构造函数可以重载。

    5.如果类中没有显示定义的构造函数，则c++编译器

    构造函数。

     6.无参的构造函数、全缺省构造函数、我们不写构造函数时编译器自己默认生成的构造函数，都叫做默认构造函数。但着三个函数有且只有一个存在于一个类中，不能同时存在。无参构造函数和全缺省函数虽然构成函数重载，但是调用时产生歧义。要注意的是很多的同学会认为默认构造函数是编译器默认生成的，但实际上无参构造函数

    以调用的构造函数就叫默认构造。

    7.我们不写，编译器默认生成的构造，对内置类型的成员变量初始化没有要求，也就是说是否初始化是不确定的，看编译器。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员便变量没有默认构造函数，那么就会报错，我们要初始化这个变量，需要用初始化列表才能解决，初始化列表我们到了后面会详细介绍！！

    说明： c++把类型分为内置类型（基本类型）和自定义类型。内置类型就是语言原生数据类型，如：int/char/double/指针等类型，自定义类型就是我们使用class和struct等关键字自己定义的类型。

    我们来看看下面的代码实例：

    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. 	public :
    6. 	// 1.⽆参构造函数
    7. 	Date()
    8. 	{
    9. 		_year = 1;
    10. 		_month = 1;
    11. 		_day = 1;
    12. 	} 
    13. 	// 2.带参构造函数
    14. 		Date(int year, int month, int day)
    15. 	{
    16. 		_year = year;
    17. 		_month = month;
    18. 		_day = day;
    19. 	} 
    20. 		// 3.全缺省构造函数
    21. 		/*Date(int year = 1, int month = 1, int day = 1)
    22. 		{
    23. 		_year = year;
    24. 		_month = month;
    25. 		_day = day;
    26. 		}*/
    27. 		void Print()
    28. 	{
    29. 		cout << _year << "/" << _month << "/" << _day << endl;
    30. 	}
    31. private:
    32. 	int _year;
    33. 	int _month;
    34. 	int _day;
    35. };
    36. int main()
    37. {
    38. 	// 如果留下三个构造中的第⼆个带参构造，第⼀个和第三个注释掉
    39. 	// 编译报错：error C2512: “Date”: 没有合适的默认构造函数可⽤
    40. 	Date d1; // 调⽤默认构造函数
    41. 	Date d2(2025, 1, 1); // 调⽤带参的构造函数
    42. 	// 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法
    43. 	// 区分这⾥是函数声明还是实例化对象
    44. 	// warning C4930: “Date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?)
    45. 	Date d3();
    46. 	d1.Print();
    47. 	d2.Print();
    48. 	return 0;
    49. }

    1.2析构函数

    析构函数与构造函数的功能相反，析构函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的，函数结束栈帧销毁，他释放了，我们就不需要管，c++规定对象在销毁前会自动调用析构函数，完成对象中资源的清理释放工作。析构函数的功能类好比我们之前的Stack 实现的Destroy功能，反而Date没有Destroy，其实就是没有资源的释放（没有动态的申请内存空间），所以严格上说Date是不需要析构函数的！！

    析构函数的特点

    • 析构函数名就是类名前面加上字符~。
    • 无参数返回值。（这里和构造函数十分的相似，也不需要加 void）.
    • 一个类只能有一个析构函数。若没有显示定义，系统就会自动生成默认的析构函数。
    • 对象的生命周期结束时，系统会自动调用析构函数。
    • 跟构造函数类似，我们不写编译器就会自动生成析构函数对内置类型成员不做处理，自定义类型成员就会调用他的析构函数。
    • 还需要注意的是我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说，自定义类型成员无论在什么样的情况下都会自动调用自己的析构函数！！
    • 如果类中没有申请资源，析构函数就可以不写，直接使用编译器生产的默认函数，如Date；如果默认生成的析构函数就够用，我们就不需要再显示其结构， 比如：MyQueue；但是有资源的申请时，一定要自己写析构函数，否则会造成资源泄露，如：Stack。
    • 一个局部域的多个对象，c++规定后定义的先析构。

    我们来看下面的用例：

    1. #include
    2. using namespace std;
    3. typedef int STDataType;
    4. class Stack
    5. {
    6. 	public :
    7. 	Stack(int n = 4)
    8. 	{
    9. 		_a = (STDataType*)malloc(sizeof(STDataType) * n);
    10. 		if (nullptr == _a)
    11. 		{
    12. 			perror("malloc申请空间失败");
    13. 			return;
    14. 		} 
    15. 		_capacity = n;
    16. 		_top = 0;
    17. 	} 
    18. 	~Stack()
    19. 	{
    20. 		cout << "~Stack()" << endl;
    21. 		free(_a);
    22. 		_a = nullptr;
    23. 		_top = _capacity = 0;
    24. 	}
    25. private:
    26. 	STDataType* _a;
    27. 	size_t _capacity;
    28. 	size_t _top;
    29. };
    30. // 两个Stack实现队列
    31. class MyQueue
    32. {
    33. 	public :
    34. 	//编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源
    35. 	// 显⽰写析构，也会⾃动调⽤Stack的析构
    36. /*~MyQueue()
    37. {}*/
    38. private:
    39. 	Stack pushst;
    40. 	Stack popst;
    41. };
    42. int main()
    43. {
    44. 	Stack st;
    45. 	MyQueue mq;
    46. 	return 0;
    47. }

     看一下用c++实现栈的结构，再对比一下我们自己之前用C语言实现的栈结构，我们可以明显的观察到c++相较于C语言明显的优势。

    我们发现有了析构函数和构造函数确实方便了很多，也不会在担心忘记写Init函数和Destroy函数了，我们写代时也方便了不少!!

    1.3拷贝构造函数

    如果一个构造函数的第一个参数是自身类类型的引用，且任何额外的参数都是默认值，则此构造函数也叫拷贝构造函数，也就是说拷贝构造是一个特殊的构造函数。

    拷贝构造的特点：

    • 拷贝构造函数是构造函数的一个重载。
    • 拷贝构造函数的第一个函数必须是类类型对象的引用，使用传值方式编译器直接报错，因为语法逻辑上会引起无穷递归调用、拷贝构造函数也可以有多个参数，但是第一个参数必须是类类型对象的应用， 后面的参数必须有缺省值。
    • c++规定的自定义类型对象进行拷贝行为，必须调用靠别构造函数，所以这里自定义类型传值传参和传值返回都会调用拷贝调用完成。
    • 若显示未定义拷贝构造，编译器会生成自动的拷贝构造函数，自动生成的拷贝构造对内置类型成员变量完成值拷贝/浅拷贝（一个字节一个字节的拷贝），对自定义类型成员变量会调用它的拷贝构造。
    • 像Date这样的类成员变量全是内置类型且没有指向那个资源，编译器自动生成的拷贝构造就可以完成值的拷贝，所以不需要我们显示拷贝构造。但是像Stack这样的类，虽然也是内置类型，但是_a指向的资源，编译器自动生成拷贝构造就不符合我们现在的要求了，所以需要我们自己来实现深拷贝（对指向的资源也进行拷贝）。像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的拷贝构造。这里有一个小技巧，如果一个类显示实现了析构并释放资源那么他就需要显示拷贝构造，否则就不需要。
    • 传值返回会产生一个临时对象调用拷贝构造，传值引用返回，返回的是返回对象的别名（引用），没有产生拷贝。但是如果返回对象是一个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回就有问题，这时的引用相当于一个野引用，类似一个野指针一样。传引用返回可以减少拷贝，但是一定要确保返回对象，在当前函数结束后还在，才能用引用返回。

    我们来看下面的例子：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. using namespace std;
    4. class Date
    5. {
    6. 	public :
    7. 	Date(int year = 1, int month = 1, int day = 1)
    8. 	{
    9. 		_year = year;
    10. 		_month = month;
    11. 		_day = day;
    12. 	} 
    13. 	// 编译报错：error C2652 : “Date”: ⾮法的复制构造函数: 第⼀个参数不应是“Date”
    14. 		//Date(Date d)
    15. 		Date(const Date & d)
    16. 		{
    17. 			_year = d._year;
    18. 			_month = d._month;
    19. 			_day = d._day;
    20. 		} 
    21. 		Date(Date * d)
    22. 		{
    23. 			_year = d->_year;
    24. 			_month = d->_month;
    25. 			_day = d->_day;
    26. 		}
    27. 		void Print();
    28. 		
    29. private:
    30. 	int _year;
    31. 	int _month;
    32. 	int _day;
    33. };
    34. void Date:: Print()
    35. {
    36. 	cout << _year << "-" << _month << "-" << _day << endl;
    37. }
    38. void Func1(Date d)
    39. {
    40. 	cout << &d << endl;
    41. 	d.Print();
    42. } 
    43. // Date Func2()
    44. Date & Func2()
    45. {
    46. 	Date tmp(2024, 7, 5);
    47. 	tmp.Print();
    48. 	return tmp;
    49. } 
    50. int main()
    51. {
    52. 	Date d1(2024, 7, 5);
    53. 	// C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥传值传参要调⽤拷⻉构造
    54. 		// 所以这⾥的d1传值传参给d要调⽤拷⻉构造完成拷⻉，传引⽤传参可以较少这⾥的拷⻉
    55. 	Func1(d1);
    56. 	cout << &d1 << endl;
    57. 	// 这⾥可以完成拷⻉，但是不是拷⻉构造，只是⼀个普通的构造
    58. 	Date d2(&d1);
    59. 	d1.Print();
    60. 	d2.Print();
    61. 	//这样写才是拷⻉构造，通过同类型的对象初始化构造，⽽不是指针
    62. 	Date d3(d1);
    63. 	d2.Print();
    64. 	// 也可以这样写，这⾥也是拷⻉构造
    65. 	Date d4 = d1;
    66. 	d2.Print();
    67. 	// Func2返回了⼀个局部对象tmp的引⽤作为返回值
    68. 	// Func2函数结束，tmp对象就销毁了，相当于了⼀个野引⽤
    69. 	Date ret = Func2();
    70. 	ret.Print();
    71. 	return 0;
    72. }

     2.赋值运算符的重载

    2.1运算符的重载

    1. 当运算符被用于类类型的对象时，c++语言允许我们通过对运算符重载的形式指定其新的含义。c++规定类类型对象使用运算符时，必须转换调用对应运算符的重载，若没有对饮的运算符重载，则会编译报错。
    2.  运算符重载是具有特殊名字的函数，他的名字是有operaor和后面的要定义的运算符共同构成的。和其他函数一样，它具有其返回类型和参数列表以及函数体。
    3. 重载运算符的参数个数和该运算对象的数量一致。一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。
    4. 如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐士指针---this指针，因此运算符重载作为成员函数时，参数比运算对象少一个。
    5. 运算符重载后，其优先性和结核性与对应的内置类型运算符保持一致。
    6. 不能通过连接语法中没有的符号来创建新的操作符，比如：operator@。
    7. .*   ::  sizeof  ?:     .  注意前面的操作符不能重载。
    8. 重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义！！
    9. 一个类需要重载那些运算符，是看运动算符在重载后承载了什么样的意义。
    10. 重载++运算符时，有前置++,和后置++，而运算重载函数都是通过operator++来实现的，没有办法很好的来区分，c++规定，，后置的++重载时增加一个int形参，跟前置++构成函数重载，方便区分。
    11. 重载<<和>>时，需要重载为全局函数，因为重载成员函数时，this指针默认会抢占形参的第一个位置，第一个形参位置是左侧运算对象，调用时变成了<

    比如，我们来看下面的代码：

    1. #include
    2. using namespace std;
    3. // 编译报错：“operator +”必须⾄少有⼀个类类型的形参
    4. int operator+(int x, int y)
    5. {
    6. 	return x - y;
    7. }
    8. class A
    9. {
    10. public :
    11. void func()
    12. {
    13. cout << "A::func()" << endl;
    14. }
    15. };
    16. typedef void(A::* PF)(); //成员函数指针类型
    17. int main()
    18. {
    19. 	// C++规定成员函数要加&才能取到函数指针
    20. 	PF pf = &A::func;
    21. 	A obj;//定义ob类对象temp
    22. 	// 对象调⽤成员函数指针时，使⽤.*运算符
    23. 	(obj.*pf)();
    24. 	return 0;
    25. }

    3.日期类的实现

    接下来我们实现一个日期类应用的底层逻辑，结合上面的知识，我们来试着实现一下把 ：

    首先我们还是要创建三个文件：

    接下来我们展示代码：

    Date.h

     

    1. #pragma once
    2. #include
    3. #include
    4. using namespace std;
    5. class Date
    6. {
    7. public:
    8. 	Date(int year  = 2023, int month = 8, int day = 10);
    9. 	//~Date();
    10. 	void Print();
    11. 	bool operator<(const Date& d);
    12. 	bool operator>(const Date& d);
    13. 	bool operator<=(const Date& d);
    14. 	bool operator>=(const Date& d);
    15. 	bool operator==(const Date& d);
    16. 	bool operator!=(const Date& d);
    17. 	Date& operator+=(int x);
    18. 	Date& operator+(int x);
    19. 	Date& operator-=(int x);
    20. 	Date& operator-(int x);
    21.  
    22. 	//++d
    23. 	Date& operator++();
    24. 	//d++
    25. 	Date operator++(int);
    26. 	//两个日期相减隔开的天数
    27. 	int operator-(const Date& d);
    28. 	int GetMonthDay(int month, int year)
    29. 	{
    30. 		assert(month > 0 && month <= 12);
    31. 		static int monthday[13] = { -1, 31,28,31,30,31,30,31,31,30,31,30,31 };//高频率的调用，使用静态函数就会提高效率,放在了静态区
    32. 		if (month == 2 && (year % 4 == 0 && year % 100 != 0 || year % 400 == 0))
    33. 			return 29;
    34. 		return monthday[month];
    35. 	}
    36. private:
    37. 	int _year;
    38. 	int _month;
    39. 	int _day;
    40. };
    41.

     Date.cpp

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include"Date.h"
    3. Date::Date(int year, int month, int day)
    4. {
    5. 	_year = year;
    6. 	_month = month;
    7. 	_day = day;
    8. }
    9. void Date:: Print()
    10. {
    11. 	cout << _year << "/" << _month << "/" << _day << endl;
    12. }
    13. bool Date::operator<(const Date& d)
    14. {
    15. 	if (_year < d._year)
    16. 		return true;
    17. 	else if (_year == d._year &&_month < d._month)
    18. 		return true;
    19. 	else if (_year == d._year && _month == d._month&&_day < d._day)
    20. 		return true;
    21. 	return false;
    22. }
    23. bool Date::operator>(const Date& d)
    24. {
    25. 	return !(*this <= d);
    26. }
    27. bool Date::operator<=(const Date& d)
    28. {
    29. 	return *this < d || *this == d;
    30. }
    31. bool Date::operator>=(const Date& d)
    32. {
    33. 	return *this > d || *this == d;
    34. }
    35. bool Date::operator==(const Date& d)
    36. {
    37. 	return _year == d._year && _month == d._month
    38. 		&& _day == d._day;
    39. }
    40. bool Date::operator!=(const Date& d)
    41. {
    42. 	return !(*this == d);
    43. }
    44. Date& Date::operator+=(int x)
    45. {
    46. 	if (x < 0)
    47. 	{
    48. 		return *this -=  -x;
    49. 	}
    50. 	_day += x;
    51. 	while (_day > GetMonthDay( _month,_year))
    52. 	{
    53. 		_day -= GetMonthDay(_month, _year);
    54. 		_month++;
    55. 		if (_month > 12)
    56. 		{
    57. 			_year++;
    58. 			_month = 1;
    59. 		}
    60.  
    61. 	}
    62. 	return *this;
    63. }
    64. Date& Date::operator+(int x)
    65. {
    66. 	Date tmp = *this;
    67. 	tmp += x;
    68. 	return tmp;
    69. }
    70. Date& Date::operator -= (int x)
    71. {
    72. 	if (x < 0)
    73. 	{
    74. 		return(*this) += -x;
    75. 	}
    76. 	_day -= x;
    77. 	while (_day <= 0)
    78. 	{
    79. 		_day += GetMonthDay(_month, _year);
    80. 		_month--;
    81. 		if (_month == 0)
    82. 		{
    83. 			_year--;
    84. 			_month = 12;
    85. 		}
    86. 	}
    87. 	return *this;
    88. }
    89. Date& Date::operator-(int x)
    90. {
    91. 	Date tmp = *this;
    92. 	tmp -= x;
    93. 	return tmp;
    94. }
    95.  
    96. //++d
    97. Date& Date::operator++()
    98. {
    99. 	*this += 1;
    100. 	return *this;
    101. }
    102. //d++
    103. Date Date::operator++(int)
    104. {
    105. 	Date tmp = *this;
    106. 	*this += 1;
    107. 	return tmp;
    108. }
    109. //使用逐一++的方法来判断相差的天数
    110. int Date::operator-(const Date& d)
    111. {
    112. 	Date big = *this;
    113. 	Date small = d;
    114. 	int flag = 1;
    115. 	if (*this < d)
    116. 	{
    117. 		big = d;
    118. 		small = *this;
    119. 		flag = -1;
    120. 	}
    121. 	int count = 0;
    122. 	while (big != small)
    123. 	{
    124. 		small++;
    125. 		count++;
    126. 	}
    127. 	return count * flag;
    128. }

    Test.cpp

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include"Date.h"
    4. int main()
    5. {
    6. 	Date d1(2023, 4, 5);
    7. 	Date d2 = d1 + 100;
    8. 	d2.Print();
    9. 	d1.Print();
    10. //	d1 += 100;
    11. 	d1.Print();
    12. 	d1 -= 5;
    13. 	d1.Print();
    14. 	(d1 += (-100)).Print();
    15. 	(d1 -= (-100)).Print();
    16.  
    17. 	//cout << (d3 ? "true" : "false") << endl;
    18. 	cout << endl;
    19. 	d1.Print();
    20. 	d2.Print();
    21. 	cout << d1 - d2 << endl;
    22.  
    23. 	return 0;
    24. }

    好，今天的学习就到这里，我们下期再见！！

  • 相关阅读:
    Keras深度学习实战——基于Inception v3实现性别分类
    RichView Text Box Items 文本框
    迅镭激光万瓦切割设备中标全球轨交装备龙头中国中车
    【Java框架 一】Mybatis
    产品经理-战略-战略的含义和层级
    主动信息收集
    TCP IP网络编程(三) 地址族与数据序列
    JVM的概念、内存区域
    【无标题】
    反向 Debug 了解一下？揭秘 Java DEBUG 的基本原理
  • 原文地址：https://blog.csdn.net/2302_79964175/article/details/141070857