C++语法学习笔记十三：重载运算符-拷贝赋值运算符-析构函数

实例代码：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Time2{
	int aa;
	int bb;
};


class Time {

private:
	void initMillTime(int mls) {
		Millisecond = mls;
	}

	int Millisecond; //毫秒
public:
	int Hour; //小时
	int Minute;//分钟
	//int Second;//秒钟
	Time2 t2;
	//int Second = 0;//秒钟  类内初始化
	int Second = { 0 };//秒钟  类内初始化
	mutable int testVal;

	char* p;

	//构造函数
	Time(int temphour, int tmpmin, int tmpsec){
		Hour = temphour;
		Minute = tmpmin;
		Second = tmpsec;
		initMillTime(0);

		cout << "调用了构造函数Time(int temphour, int tmpmin, int tmpsec)" << endl;
	}

	Time(int temphour, int tmpmin){
		Hour = temphour;
		Minute = tmpmin;
		Second = 59;
		initMillTime(50);

		p = new char[100];
		cout << "调用了构造函数Time()" << endl;
	}

	Time(){
	
	} //不加参数了

	//拷贝构造函数
	Time(const Time &tmptime, int a = 60){
		std::cout << "调用了 Time::Time(Time &tmptime, int a) 拷贝构造函数" << std::endl;
	}

	// 重载的赋值运算符
	Time & operator=(const Time& tmpobj){ 	

		Hour = tmpobj.Hour;
		Minute = tmpobj.Minute;
		Second = tmpobj.Second;

		std::cout << "调用了Time &Time::operator=(const Time&) 赋值运算符重载" << std::endl;
		return *this;	
	}

	//析构函数（释放函数）
	Time::~Time(){
		delete[] p;
		std::cout << "调用了Time::~Time()析构函数" << std::endl;
	}

	void addHour(int tmphour) {
		Hour += tmphour;
	}

	void addHour1(int tmphour) const{
		//Hour += tmphour; //报错  这地方不能修改成员变量的值
	}

	void fixVal() const {
		testVal = 10;
	}

	//把对象自己给返回回去了
	Time& add_hour(int tmphour) {
		Hour += tmphour;
		return *this;	//把对象自己给返回去了
	}
};



int main() {
	// 一：重载运算符
	// ==, >, >= , < , <=, != , ++, --, +=, -=, +, -, cout, cin << 和 >> ,= 赋值运算符。
	int a = 4, b = 5;
	if (a == b){
		// ...
	}
	Time myTime;
	Time myTime2;

	//if (myTime == myTime2){
	//
	//}

	//两个对象真的不能进行== 比较吗？，是可以比较的，我们需要 “重载 == 运算符”
	// 说白了，我们要写一个成员函数，这个成员函数名 “operator==”，这个成员函数体里边 我们就要写一些比较逻辑。

	if (myTime.Hour == myTime2.Hour){
		return true;
	}

	//正式总结一下：
	//重载运算符，本质上是一个函数。整个函数的正式名字 ：operator 关键字接运算符。
	//既然重载运算符本质上是一个函数，那么会有返回类型和参数列表。
	//有一些运算符，如果我们不自己写 该运算符的重载，那么系统会自动给我们生成一个。比如赋值运算符的重载。

	//Time myTime;
	//Time myTime2;
	//myTime2 = myTime;


	//二、拷贝赋值运算符
	Time myTime11;   // 调用了Time::Time()构造函数
	Time myTime22 = myTime;  // 调用了Time::Time(Time &tmptime, int a) 拷贝构造函数
	Time myTime5 = { myTime };  // 调用了Time::Time(Time &tmptime, int a) 拷贝构造函数

	Time myTime6;   // 调用了Time::Time()构造函数
	myTime6 = myTime5; //这个是赋值运算符，既没调用构造函数，也没嗲用拷贝构造函数。
				// 系统会调用一个拷贝赋值运算符。
	// 我们可以自己重载赋值运算符，如果我们自己不重载，编译器也会为我们生成一个（编译器格外喜欢赋值运算符）。
	// 编译器生成的赋值运算符重载比较粗糙。一般就是将非static成员赋值给赋值运算符左侧的对象的对应成员中去。
	// 如果你这个成员是个类对象的话，可能还会调用这个类的拷贝赋值运算符。
	// 为了精确控制Time类的赋值动作，我们往往会自己来重载赋值运算符。

	//重载赋值运算符：有返回类型和参数列表，这里的参数就表示运算符的运算对象，比如myTime5就是运算对象。
	//myTime6 就是this 对象。myTime5就是 operator=里边的参数。


	//三、析构函数: 相对于构造函数，对象在销毁的时候，会自动调用析构函数。
	//如果我们自己不写自己的析构函数，编译器也会生成一个默认的析构函数。默认析构函数的函数体为空{}，表示默认的析构
	//函数没干什么有意义的事。

	//构造函数里new ,delete.
	//析构函数也是类的成员函数，它的名字是由“~” 接类名构成，没有返回值，不接受任何参数，不能被重载，所以一个给定的
	//类，只有唯一一个析构函数。

	///a)函数重载：就是系统允许函数的名字相同，但是这些同名函数的参数个数或者参数类型不同，系统允许这些同名函数同时存在，
	//当我们调用这些函数的时候，系统根据调用这个函数时我们所提供的参数类型，参数个数，就能区别出来你到底想调用哪个函数。

	//b)构造函数的成员初始化：干了两个事，函数体之前和函数体之中。

	//c). 析构函数的成员销毁: 干了两个事，函数体，函数体之后
	//成员变量的初始化和销毁时机问题：先定义的先初始化，销毁时先定义的后销毁。

	//d). new 对象和delete对象。 new对象的时候，系统调用了Time类的构造函数。
	Time *pmytime5 = new Time; //调用不带参数的构造函数。
	Time *pmytime6 = new Time(); //调用不带参数的构造函数。
	//但是，大家务必要注意，我们new出来的对象，必须要自己释放，否则就会造成内存泄漏。
	//在程序停止运行之前的某个时刻，你一定要用delete 把对象占用的内存释放掉。
	delete pmytime5;
	delete pmytime6;

	// 你什么时候delete ,系统就会在什么时候去调用类Time 的析构函数。




	system("pause");
	return 0;
}