【C++初阶：类和对象(中篇)】构造函数 | 析构函数 | 拷贝构造函数 | 赋值运算符重载

【写在前面】

这篇文章是类和对象的核心知识

一、类的6个默认成员函数

class Date {};

如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面 6 个默认成员函数。

注意，这里其实严格上有 8 个默认成员函数，其余 2 个是 C++11 的，后面再学，其次 C++98 这里有 2 个是不太重要的，提一下即可。

二、构造函数

💦 概念

❗ 场景 ❕

class Stack
{
public:
	void Init()
	{
		_a = nullptr;
		_top = _capacity = 0;	
	}
	void Push(int x);
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack s1;
	s1.Push(3);
	
	return 0;
}

📝 说明

C 语言中，可能会忘记调用 Init 函数，然后一顿错误操作。这时 C++ 就能做到对象定义出来就初始化 —— 构造函数。

可以认为构造函数的出现就是为了替代 Init。

❗ 利用构造函数替代 Init ❕

class Stack
{
public:
	Stack()//1.函数名和类名相同//2.无返回值
	{
		_a = nullptr;
		_top = _capacity = 0;	
	}
	Stack(int capacity)
	{
		_a = malloc(sizeof(int)*capacity);
		if(_a == nullptr)
		{
			cout << "malloc fail" << endl;
			exit(-1);	
		}
		_top = 0;
		_capacity = capacity;
	}
	void Push(int x);
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack s1;//3.对象实例化时编译器自动调用对应的构造函数
	Stack s2(10);//4.构造函数可以重载
	s1.Push(3);
	
	return 0;
}

📝 说明

构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

💦 特性

构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

其特征如下：

1️⃣ 函数名与类名相同。

2️⃣ 无返回值。

3️⃣ 对象实例化时编译器自动调用对应的构造函数。

4️⃣ 构造函数可以重载。

 

接下来我们就来理解几个概念用 ❓ ❔　包含

---

❓ 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成 ❔

class A
{
public:
	A()
	{
		_a1 = 0;
		_a2 = 1;
		cout << "A()" << endl;
	}
private:
	int _a1;
	int _a2;
};
class Date
{
public:
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;	
	}
private:
	//内置类型/基本类型：int、char、指针 ...　———— 不会初始化
	int _year;
	int _month;
	int _day;
	//自定义类型：struct/class　———— 调用它的无参构造函数初始化
	A _a;
};
int main()
{
	Date d1;//对象实例化时自动调用构造函数
	d1.Print();//再调用Print函数
	
	return 0;
}

📝 说明：
　
不是说我们不写构造函数，编译器会自动生成一个无参的默认构造函数 ❓

这也是早期 C++ 设计留下的一个缺陷，有些编译器会把这初始化为 0，1，1

C++ 把我们的变量分成内置类型 (int、char、指针 …) 和自定义类型 (struct/class)

我们不写构造函数，编译器默认生成构造函数，但是编译器做了一个偏心的处理

1、内置类型不会初始化
2、自定义类型它会调用它的无参构造函数初始化

其实这块内容算是 C++ 在早期设计时的语法缺陷，这种偏心的处理导致语法反而复杂了，后面也发现了这个问题，但是为时已晚不能修改，因为 C++ 要向前兼容。好多书上也没有讲清楚，这也是很多人说 C++ 难学的地方。

关于编译器生成的默认构造函数，很多童鞋会有疑惑：在我们不实现构造函数的情况下，编译器会生成默认构造函数，但看起来默认构造函数又没什么用 ❓

这里说看起来没什么用主要体现在 d1 调用了编译器生成的默认构造函数，但是 _year、_month、_day 依然是随机值。

C++ 把类型分成内置类型 (基本类型) 和自定义类型，这里只是说它不会处理内置类型，而自定义类型它会去调用它的无参构造函数

到了 C++11 时 C++ 针对这里的情况做了补充 ❓

C++11 时，语法委员会针对这里打了一个补丁，也就是在变量声明中加上缺省值。

这个补丁雀实会给很多初学者造成困扰，很多人会认为它是初始化，其实它是缺省值。

class A
{
public:
	A()
	{
		cout << "A()" << endl;
	}
private:
	int _a1;
	int _a2;
};
class Date
{
public:
	Date()
	{
		_year = 2022;//只初始化_year，其它默认
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;	
	}
private:
	//C++11 缺省值
	int _year = 0;
	int _month = 1;
	int _day = 1;
	A _a;
};
int main()
{
	Date d1;
	d1.Print();
	
	return 0;
}

📝 说明

就同函数的缺省参数一样。如果构造函数里没有初始化，那么对于内置类型它会使用缺省值初始化

❓ 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数 (不传参数就可以调用的那个函数) ❔

class Date
{
public:
	Date()
	{
		_year = 0;
		_month = 1;
		_day = 1;
	}
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;//Date d1(3);ok
	return 0;
}

📝 说明

如上两个构造函数 Date 本来是可以构造函数重载的，但是他们不能同时存在 ~ Why ？❓

因为编译器调用的时候会出现歧义，一般情况下我们推荐写一个全缺省的构造函数，因为它比较好用。

这里有一个误区：有的童鞋会认为，我们不写，编译器默认生成的构造函数就叫做构造函数，这个是不对的，它还有无参的构造函数和全缺省的构造函数都是默认构造函数。

❓ 成员变量的命名风格 ❔

class Date
{
public:
	Date(int year)//不好的命名风格
	{
		year = year;	
	}
	Date(int year,int month)//好的命名风格
	{
		_year = year;
		_month = month;
	}
private:
	int year;
	int _year;
	int _month;
};
int main()
{
	Date d1(1);
	Date d2(1, 2);
	return 0;
}

📝 说明

当然这样不仅仅是规范的问题，还可能会造成运行时错误。

执行 Date d1 (1) ; 后，year 的值是 1 还是随机值 ❓

站在编译器的角度 this->year = year，所以是 1 ？？？

NO ~~，实际上在 Date 里它会采用就进原则，也可以认为是局部优先。

当 year = year 时，它会先找到形参，然后就变成了自己赋值给自己了。

当 _year = year 时，它先找局部变量，没找到，它会再外面的域搜索，找到了，编译器就会在前面加 this。

或者直接 this->year = year 但不推荐。

三、析构函数

💦 概念

前面通过构造函数的学习，我们知道一个对象时怎么来的，那一个对象又是怎么没呢的 ？？？

析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

class Date
{
public:
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;	
	}
	~Date()
	{
		cout << "~Date()" << endl;//证明我来过
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	return 0;
}

📝 说明

像 Date 这样的类是不需要析构函数的，因为它内部没有什么资源需要清理

💦 特性

析构函数是特殊的成员函数。

其特征如下：

1️⃣ 析构函数名是在类名前加上字符 ~。

2️⃣ 无参数无返回值 (不支持重载)。

3️⃣ 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。

4️⃣ 对象生命周期结束时，C++ 编译系统系统自动调用析构函数。

---

❓ 析构函数有什么意义 ❔

析构函数具体有什么意义要看具体是什么类，哪些类的析构函数是有意义的呢 ❓

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		if(_a == nullptr)
		{
			cout << "malloc fail" << endl;
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		free(_a);
		_a = nullptr;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st;
	return 0;
}

📝 说明

在之前我们写栈时都需要写一个 Destroy 在程序结束前销毁动态开辟的内存，很多童鞋可能在使用完动态开辟的内存没有 Destroy 导致后面的一些内存泄漏的操作。而析构函数的出现就是为了解决这种场景的，对象实例化后，同构造函数一样，它不需要我们主动调用，它是在对象生命周期结束后自动调用，注意析构函数没有参数所以不能重载。

构造函数是为了替代 Init，析构函数是为了替代 Destroy。

一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数 ❓

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		if(_a == nullptr)
		{
			cout << "malloc fail" << endl;
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st;
	return 0;
}

📝 说明

与构造函数类似，我们不写，编译器默认生成的构造函数也会做偏心的处理

1、内置类型成员不处理
2、自定义类型成员会去调用它的析构函数

为什么内置类型不处理 ❓

因为它不好处理，如果这个指针是一个文件指针，那你也要去 free 吗 ？？？

那对于什么样的类可以不写析构呢或者它的价值是什么 ❓

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		if(_a == nullptr)
		{
			cout << "malloc fail" << endl;
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		free(_a);
		_a = nullptr;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
class MyQueue
{
private:
	 Stack _pushST;
	 Stack _popST;	
};
int main()
{
	MyQueue mq;
	return 0;
}

📝 说明

这是之前的一个题 —— 两个栈实现队列

现在对于 MyQueue，我们可以不写构造函数和析构函数，让编译器自动生成构造函数和析构函数也可以 Init 和 Destroy，具体如下：

1、初始化 _pushST 和 _popST

2、销毁 _pushST 和 _popST

💨 由以上就可以看出编译器默认生成的析构函数也是有价值的

四、拷贝构造函数

💦 概念

在现实生活中有双胞胎的存在，那么我们的对象也可以有。

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
	}
	//Date d3(d2);
	//Date(Date d)
	//{
	//	_year = d._year;
	//	_month = d._month;
	//	_day = d._day;
	//}
	
	//Date d3(d2);
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	
	//Date d3(d2);
	Date(const Date* p)
	{
		_year = p->_year;
		_month = p->_month;
		_day = p->_day;
	}	
	void Print()
	{
		cout << _year << "/"<< _month << "/" << _day <<	endl;	
	} 
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(2022, 1, 1);
	d1.Print();
	d2.Print();
	//拷贝复制一个d2对象
	Date d3(d2);
	d3.Print();
	//指针也可以，但不好
	Date d4(&p2);
	d4.Print();
	return 0;
}

📝 说明

error C2652：非法的复制构造函数，第一个参数不应是 “Date”。

这里会引发一个无穷递归的现象，只是语法进行了强制检查，所以它由运行时错误转向了编译时错误。

怎么解决 ❓

1、这里用引用解决了问题，因为形参是实参的别名，即 d 是 d2 的别名

   注意如果引用传参，不是做输出型参数，最好加 const

2、当然也能使用指针解决，但并没有引用好用

💦 特性

拷贝构造函数也是特殊的成员函数，其特征如下：

1️⃣ 拷贝构造函数是构造函数的一个重载形式。

2️⃣ 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。

❓ 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝 ❔

class AA
{
public:
	AA()//下面的拷贝构造也是构造，写了就不会生成，所以这里要写一个默认构造函数出来才能通过
	{}
	AA(const AA& a)	
	{
		cout << "AA(const AA& a)" << endl;
	}
};
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;

	AA _aa;
};
int main()
{
	Date d1;
	Date d2(2022, 1, 1);
	d1.Print();
	d2.Print();
	//拷贝复制一个d2对象
	Date d3(d2);
	d3.Print();

	return 0;
}

📝 说明

我们不写，编译器默认生成拷贝构造，跟构造和析构不太一样，它不会去区分内置类型和自定义类型，都会处理。

1、内置类型，字节序的浅拷贝 (一个字节一个字节的拷贝)。

   AA(const AA& a)

2、自定义类型，会去调用它的拷贝构造完成拷贝。

   2022/1/1

❓ 那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了 (内置类型和自定义类型)，是否意味着编译器自己生成的就行呢。我们还需要自己实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试 ❔

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		if(_a == nullptr)
		{
			cout << "malloc fail" << endl;
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		free(_a);
		_a = nullptr;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st1;
	Stack st2(st1);
	return 0;
}

📝 说明

经调试发现虽然已经完成了拷贝，但是程序崩了


为什么会崩 ❓

此时 st1 和 st2 指向同一块空间，那么问题来了，谁先被析构呢 —— 根据栈的特性后进先出，所以这里先被析构的是 st2。st2 被析构后再析构 st1 时程序就崩溃了，因为同一块空间不能释放两次。

编译器默认生成的拷贝构造并不能解决所有问题，像 Stack 这样的类，编译器默认生成拷贝构造完成的就是浅拷贝。解决方案就是自己实现深拷贝，对于深拷贝，因为比较复杂，所以后面要另写一篇文章。

❓ 拷贝 | 拷贝构造 ❔

int p()
{
	int ret = 0;
	return ret;	
}
Date q()
{
	Date ret;
	return ret;
}

📝 说明

我们说了，在传值返回时，它会先拷贝 (实际上是两次拷贝，但有些编译器会优化成一次)。

为什么需要拷贝 ❓

当函数调用结束，函数栈帧会被销毁，ret 是属于这个栈帧的局部变量，所以拷贝是为了解决局部变量被销毁的问题。使用引用可以解决拷贝消耗，但要注意如果出了作用域返回对象不在了就不能用引用。注意有些编译器在函数结束时不会清理栈帧，所以能返回正确返回值 (如果不是正确返回值，那么说明栈空间被清理了)，但那是非法的。

五、赋值运算符重载

💦 运算符重载

❗ 引入 ❕

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 10, 11);
	Date d2(2020, 11, 11);
	Date d3(2021, 11, 11);
	
	//d1 == d2;//err
	
	return 0;
}

📝 说明

d1 == d2 ❓

运算符默认都是给内置类型变量用的。

自定义类型的变量想用这些运算符，得自己运算符重载。

运算符重载指的是需要自己写一个函数实现这里运算符的行为。

---

C++ 为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，函数里的实现就是行为。它也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字 operator 后面接需要重载的运算符符号。

函数原型：返回值类型 operator 操作符 (参数列表)

注意：对于参数列表的个数有几个是根据操作符来确定的，比如 == 就需要两个参数；参数类型就是你要操作的对象类型；返回值类型就是运算符运算后的返回值。

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
	}
//private:
public://这里破坏封装使得可以在类外访问成员
	int _year;
	int _month;
	int _day;
};
bool operator==(const Date& x1, const Date& x2)
{
	return x1._year == x2._year
		&& x1._month == x2._month
		&& x1._day == x2._day;
}
int main()
{
	Date d1(2021, 10, 11);
	Date d2(2020, 11, 11);
	Date d3(2021, 11, 11);
	
	operator==(d1, d2);//可以这样调用，但是这样可读性很差，还不如写一个函数
	d1 == d2;//同上，如果没有重载会报错，如果重载了它会转换为 operator==(d1, d2);
	return 0;
}

📝 说明

怎么解决上述代码中利用破坏了封装，使得运算符重载的函数可以访问私有成员 ❓

  1、友，但不推荐。

  2、将函数重载写在类里，写成一个成员函数。

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
	}
	//bool operator==(const Date& x1, const Date& x2)//err
	//{
	//	return x1._year == x2._year
	//		&& x1._month == x2._month
	//		&& x1._day == x2._day;
	//}
	
	//bool operator==(Date* this, const Date& x)
	bool operator==(const Date& x)//ok
	{
		return _year == x._year
			&& _month == x._month
			&& _day == x._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 10, 11);
	Date d2(2020, 11, 11);
	Date d3(2021, 11, 11);
	
	d1.operator==(d2);
	d1 == d2;//同上，编译器会自动识别转换为d1.operator==(d2); -> d1.operator(&d1, d2);
	return 0;
}

📝 说明

当我们把函数重载写进类里时，error C2804：operator== 的参数太多了 ❓

这里的矛盾点是运算符重载函数的参数是根据运算符来确定的但是对于类里的函数成员它会有一个 this 指针。解决方法就是少写一个参数。

对于d1 == d2 ❓

编译器会自动识别转换，如果是全局函数那么它会转换成 operator==(d1, d2);；如果是成员函数那么它会转换成 d1.operator(d2);。不管是全局还是成员一般我们都是直接写 d1 == d2。

观察 d1.operator==(d2); 和 d1 == d2; 的汇编代码 ❗

我们不一定需要会写汇编，但是需要勉强看懂

❗ 照虎画猫写一个d1<d2 ❕

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
	}
	bool operator<(const Date& x)//ok
	{
		if(_year < x._year)
			return true;
		else if(_year == x._year && _month < x._month)
			return true;
		else if(_year == x._year && _month == x._month && _day < x._day)
			return true;
		else
			return false;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 10, 11);
	Date d2(2020, 11, 11);
	Date d3(2021, 11, 11);
	
	cout << d1 < d2 << endl;//err
	cout << (d1 < d2) << endl;//ok,d1.operator<(d2); -> d1.operator<(&d1, d2);
	return 0;
}

📝 说明

上面使用 cout 输出结果时，出现了问题。<< 是流插入运算符，它的优先级比较高 (从上面看比 <、= 高，比 () 低)，这里 cout 会先输出 d1，然后再 < ？？？

---

⚠ 注意

1️⃣ 不能通过连接其他符号来创建新的操作符：比如 operator@。

2️⃣ 重载操作符必须有一个类类型或者枚举类型的操作数。

3️⃣ 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义。

4️⃣ 作为类成员的重载函数时，其形参看起来比操作数数目少 1 成员函数的操作符有一个默认的形参 this，限定为第一个形参。

5️⃣ .* 、:: 、sizeof 、?: 、. ，注意以上 5 个运算符不能重载。这个经常在笔试选择题中出现，注意 * 是可以重载的，这里不能重载的是 .*。

💦 赋值运算符重载

上面我们重载了 == 这个符号，这里我们要重载的是 = 符号。

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
	}
	void operator=(const Date& x)
	{
		_year = x._year;
		_month = x._month;
		_day = x._day;	
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 10, 11);
	Date d2(2020, 11, 11);
	Date d3(2021, 11, 11);
	//赋值运算符重载
	d1 = d3;
	//拷贝构造
	Date d4(d3);
	
	Date d5 = d3;//拷贝构造还是赋值运算符重载？？？ ———— 这里是拷贝构造，因为这里是在实例化对象，并且它同 Date d5(d3);
	return 0;
}

📝 说明

可以使用拷贝构造替代赋值运算符重载 ❓

拷贝构造和赋值运算符重载的场景不一样：拷贝构造是用于一个对象准备定义时，用另一个对象来初始化它；赋值运算符重载是用于两个已经定义出来的对象间的拷贝复制。

对于上面写的赋值运算符重载写的不够好 ❓

我们说我们去重载运算符，就是控制这个运算符的行为。

1、从赋值运算符的特性来说，它要能支持连续赋值 —— d1 = d2 = d3;。

int i = 1;
int j = 2;
int k = 3;
i = j = k;//连续赋值(从右至左),注意连续赋值是有返回值的。这里最后i去接收j=k的返回值

2、d1 = d1 自己赋值给自己，可以，但是没意义，还有可能会破坏之前的拷贝。所以赋值重载中为了防止这种情况它还要控制一下条件。

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
	}
	//d2 = d3, d1 = d2
	Date& operator=(const Date& x)
	{
		if(this != &x)
		{
			_year = x._year;
			_month = x._month;
			_day = x._day;			
		}
		
		return *this;//返回d2,返回d1
	}
	
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 10, 11);
	Date d2(2020, 11, 11);
	Date d3(2021, 11, 11);

	d1 = d2 = d3;

	d1 = d1;
	return 0;
}

📝 说明

在这里我们再来思考一下，对于this指针为什么仅仅可以在类成员函数{}里使用 ❓

从上面就可以看出，因为有这样的使用场景。

再看引用价值 ❓

如果使用传值传参，它会再调用拷贝构造，再额外开一块空间。

如果使用传值返回，它不会返回 *this，而是返回一个临时对象 (它也会再调用拷贝构造)。

这时使用引用的价值就有体现了。

注意出了作用域 *this 对象不在了，只能用传值返回；但是这里的对象都是在 main 函数里定义的，所以能用引用返回。

❓ 同样如果我们不写赋值重载，编译器也会默认生成 ❔

类似于拷贝构造函数

1、内置类型成员会完成值拷贝。
2、自定义类型成员会去调用它的赋值重载。

class A
{
public:
	A& operator=(const A& a)
	{
		cout << "A& operator=(const A& a)" << endl;
		return *this;
	}
};
class Date 
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;

	A _a;
};
int main()
{
	Date d1(2021, 10, 11);
	d1.Print();
	Date d2(2020, 11, 11);
	Date d3(2021, 11, 11);
	 
	d1 = d2;
	d1.Print();
	return 0;
}

---

💨小结：

对于 6 个默认成员函数，原则：编译器默认生成的能完成我们要的功能就可以不写，不能完成就需要我们自己写。

六、日期类的实现

更深入的学习常见的运算符重载，当然还有一些需要后面的知识铺垫，比如流提取、流插入运算符。

Date.h

#pragma once
#include<iostream>
#include<assert.h>
#include<stdbool.h>
using namespace std;
class Date
{
public:
	//获取某年某月的天数
	int GetMonthDay(int year, int month)
	{
		assert(month > 0 && month < 13);
		//默认平年
		int monthDays[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
		//判断润年的二月
		if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
		{
			return 29;
		}
		return monthDays[month];
	}
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
		//判断日期是否合法
		if (_year < 0 || _month <= 0 || _month >= 13 || _day <= 0 || _day > GetMonthDay(_year, _month))
		{
			cout << _year << "/" << _month << "/" << _day << "->";
			cout << "非法日期" << endl;
		}
	}
	void Print() const
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	bool operator>(const Date& d) const
	{
		if (_year > d._year)
			return true;
		else if (_year == d._year && _month > d._month)
			return true;
		else if (_year == d._year && _month == d._month && _day > d._day)
			return true;
		else
			return false;
	}
	bool operator==(const Date& d) const
	{
		return _year == d._year && _month == d._month && _day == d._day;
	}
	bool operator>=(const Date& d) const
	{
		return *this > d || *this == d;//复用operator>、operator==
	}
	bool operator<(const Date& d) const
	{
		return !(*this >= d);//复用operator>=，再取反
	}
	bool operator<=(const Date& d) const
	{
		return !(*this > d);//复用operator>，再取反
	}
	bool operator!=(const Date& d) const
	{
		return !(*this == d);//复用operator==，再取反	
	}

	Date operator+(int day) const;	
	Date operator-(int day) const;
	Date& operator+=(int day);
	Date& operator-=(int day);
	Date& operator++();
	Date operator++(int);
	Date& operator--();
	Date operator--(int);
	int operator-(const Date& d) const;
private:
	int _year;
	int _month;
	int _day;
};

Date.cpp

#include"Date.h"

Date Date::operator+(int day) const
{
	//Date temp(*this);
	//temp._day += day;
	//while (temp._day > GetMonthDay(temp._year, temp._month))
	//{
	//	temp._day -= GetMonthDay(temp._year,temp._month);
	//	++temp._month;
	//	if (temp._month == 13)
	//	{
	//		++temp._year;
	//		temp._month = 1;
	//	}
	//}
	//return temp;

	//相同逻辑太多，直接复用operator+= (这个比较好)
	Date temp = *this;
	temp += day;
	return temp;
}
Date& Date::operator+=(int day)
{
	if (day < 0)//d1 + -100;
	{
		return *this -= -day;//+= -100到-= 100
	}
	_day += day;
	//日期不合法，需要进位
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		++_month;
		if (_month == 13)
		{
			++_year;
			_month = 1;
		}
	}
	return *this;

	//相同逻辑太多，直接复用operator+
	//*this = *this + day;
	//return *this;
}
Date Date::operator-(int day) const
{
	Date temp = (*this);
	temp -= day;
	return temp;
}
Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		return *this += -day;
	}
	_day -= day;
	while (_day < 1)
	{
		--_month;
		if (_month == 0)
		{
			--_year;
			_month = 12;
		}
		_day += GetMonthDay(_year, _month);
	}
	return *this;
}
Date& Date::operator++()
{
	*this += 1;//复用operator+=
	return *this;//返回++后的值
}
Date Date::operator++(int)
{
	Date temp = *this;
	*this += 1;//复用operator+=
	return temp;//返回++前的值
}
Date& Date::operator--()
{
	*this -= 1;//复用operator-=
	return *this;//返回--后的值
}
Date Date::operator--(int)
{
	Date temp(*this);
	*this -= 1;//复用operator-=
	return temp;//返回--前的值
}
int Date::operator-(const Date& d) const
{
	//比较大小
	Date max = *this, min = d;
	int flag = 1;
	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}

	int n = 0;
	while (min != max)
	{
		++min;//利用operator++()
		++n;
	}
	return n * flag;
}

Test.cpp

#include"Date.h"

void TestDate1()
{
	Date d1(2021, 10, 11);//ok
	Date d2(2021, 2, 29);//err
	Date d3(2020, 2, 29);//ok
	Date d4(2020, 13, 29);//err
}
void TestDate2()
{
	Date d1(2021, 10, 11);
	Date ret;

	ret = d1 + 100;
	ret.Print();

	ret = d1 += 100;
	ret.Print();
	d1.Print();

	ret = d1 + -100;
	ret.Print();
}
void TestDate3()
{
	Date d1(2021, 10, 11);
	Date ret;

	ret = d1 - 11;
	ret.Print();

	ret = d1 -= 11;
	ret.Print();
	d1.Print();

	ret = d1 - -11;
	ret.Print();
}
void TestDate4()
{
	Date d1(2021, 10, 11);
	Date ret;

	ret = ++d1;
	ret.Print();
	d1.Print();

	ret = d1++;
	ret.Print();
	d1.Print();
}
void TestDate5()
{
	Date d1(2021, 10, 11);
	Date ret;

	ret = --d1;
	ret.Print();
	d1.Print();

	ret = d1--;
	ret.Print();
	d1.Print();
}
void TestDate6()
{
	Date d1(2023, 10, 11);
	Date d2(2022, 10, 11);

	cout << d1 - d2 << endl;
	cout << d2 - d1 << endl;
}
int main()
{
	//TestDate1();//日期合法
	//TestDate2();//+、+=、+ -(负)
	//TestDate3();//-、-=、- -(负)
	//TestDate4();//++x、x++
	//TestDate5();//--x、x--
	TestDate6();//d1 - d2
	return 0;
}

📝说明

日期的不合法，构造函数有无责任 ❓

有的，构造函数不仅仅是完成初始化工作，还要判断数据是否合法。

除了上面说的 5 个运算符不能重载之外，其余的运算符有重载的意义 ❓

一个类到底要重载哪些运算符，是看你需要哪些运算符，并且要考量重载的运算符有无价值。

运算符重载 | 函数重载 ❓

虽然它们都用了重载这个词，但是它们之间没有关联。

operator+ | operator+= ❓

对于大量重复的代码我们可以利用复用来提高代码质量 (它俩必须得实现一个)。

operator+复用operator+=不需要声明 ❓

operator+ 是在 operator+= 之前，所以需要声明，但是我们的 Date.cpp 文件中的第一行，已经把 Date.h 的声明都展开了，所以这里的先后位置可随意。

Date d3 = d1 + -100 & Date d3 = d1 - -100 ❓

显然我们并未考虑到这种情况，所以这里我们还可以把复用用到极致。

运算符前置++和后置++怎么进行重载(同前置- -和后置- -) ❓

它们的共同点都是需要 ++ 的，但是它们的返回值不同：前置++ 的返回值是 ++ 以后的；后置++ 的返回值是 ++ 之前的。

这两个运算符都是单操作数，也就是只能有一个 this 指针，按正常的运算符重载规则是无法区分前置与后置的，所以编译器为了能区分这种情况，这里就做了一个特殊的处理 —— 给后置++ 增加一个 int 参数 (这个参数仅仅是为了区分，你给多少它都不会用)，这样它们就能构成函数重载。

日期 - 日期 ❓

常规思路是日减、月减、年减，补它们中间的位，但是实际上实现较难。

思路一：把某月某日映射到 365 天

思路二 (最优)：先比较两日期的大小，然后让小的++，当小的等于大的时，那么加了多少次就是它们相差的天数

比较运算符重载 ❓

常规思路是写好一个比较运算符重载之后就复制代码改符号。

利用复用的思路是实现 operator> 和 operator== 就行了。

七、const成员函数

💦 const修饰类的成员函数

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print1()//void Print(Date* this)
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	void Print2() const//void Print(const Date* this)
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 10, 13);
	//Date d2(2021, 10, 14);//ok
	//const Date d2(2021, 10, 14);//err
	d1.Print1();
	d2.Print1();//d2.Print(&d2);

	const Date d3(2021, 10, 14);//ok
	d3.Print2();//d3.Print(&d3);

	return 0;
}

📝 说明

为什么const对象不能调用Print ❓

我们之前说了在调用类成员函数时有一个隐式的参数 this 指针

💨总结

1、成员函数加 const，变成 const 成员函数是有好处的，这样 const 对象可以调用，非 const 对象也可以调用。

2、不是说所有的成员函数都要加 const ，具体要看成员函数的功能，如果成员函数是修改型 (operrato+=、Push)，那就不能加；如果是只读型 (Print、operator+)，那就最好加。

3、const 对象不可以调用非 const 成员函数 (权限放大)；非 const 对象可以调用 const 成员函数 (权限缩小)。

4、const 成员函数内不可以调用其它非 const 成员函数；非 const 成员函数内可以调用其它 const 成员函数。

八、取地址及const取地址操作符重载

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//普通对象取地址 
	/*Date* operator&()
	{
		return this;
	}*/
	//const对象取地址 
	/*const Date* operator&() const
	{
		return this;
	}*/

	Date* operator&()
	{
		return nullptr;
	}
	const Date* operator&() const
	{
		return nullptr;	
	}
	
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 10, 13);
	const Date d2(2021, 10, 14);

	cout << &d1 << endl;
	cout << &d2 << endl;
	return 0;
}

📝 说明

一般不需要写，编译器生成的就够用。

如果非要写，比如不想让别人获取对象的地址，就可以自己实现，返回 nullptr。

九、补充

class widget
{
public:
	widget() 	     
	{}
	widget(const widget& w)
	{
		cout << "widget(const widget& w)" << endl;
	}
	widget& operator=(const widget& w)
	{
		cout << "widget& operator=(const widget& w)" << endl;
		return *this;
	}
	~widget()
	{}
};
void f1(widget w)
{}
widget f2()
{
	widget W;
	return W;
}
int main()
{
  	widget w1;
	//传值传参和传值返回都会生成一个拷贝对象
	f1(w1);
	f2();
	//本来应该是两次拷贝构造，但是这种情况下编译器会优化
	widget ret = f2();
	
	//不会优化
	/*widget ret;
	ret = f2();*/
	
	return 0;
}

📝说明

❓ 传返回值拷贝构造优化问题 ❔

匿名对象 ❓

我们定义对象除了常规的方式还可以定义匿名对象，匿名对象没有名字，它的生命周期只在这一行 。

widget w;

widget(); 

比如当只想调用 Print 时就会使用匿名对象。

widget w;
w.Print();

widget().Print();

❓ 传参数也是类似的 ❔

class widget
{
public:
	widget() 	     
	{
		cout << "widget" << endl;
	}
	widget(const widget& w)
	{
		cout << "widget(const widget& w)" << endl;
	}
	~widget()
	{
		cout << "~widget()" << endl;	
	}
};
void f1(widget w)
{}
int main()
{
	//先构造，再去拷贝构造，这是正常的写法，编译器没有任何的优化
	/*widget w;
	f1(w);*/
	
	//传参匿名对象
	f1(widget());
	
	return 0;
}

📝说明

传匿名对象优化问题 ❓

本来应该是构造和拷贝构造，但是编译器做了优化。

💨总结

VS2017 中在传值传参和传值传返回值的过程中，只要是在一个表达式调用的连续步骤中：拷贝构造、拷贝构造，两次会被优化成一次； 构造、拷贝构造，会被编译器优化合并成构造。

❓ 以下代码共调用多少次拷贝构造函数 ❔

Widget f(Widget u)
{
	Widget v(u);
	Widget w = v;
	return w;
}
main()
{
	Widget x;
	Widget y = f(f(x));
}

📝 说明

所以总共拷贝构造了 7 次。