C++_赋值运算符重载

Time.h

#include<iostream>
class Tmpclass
{
public:
	Tmpclass()
	{
		std::cout<<"调用了Tmpclass的构造函数"<<std::endl;
	}

	Tmpclass(Tmpclass &tmpclass)
	{
		std::cout<<"调用了TTmpclass类的拷贝构造函数"<<std::endl;
	}
};



class Time
{
 private:
	 //成员函数
	 void initTime(int tmphour,int tmpmin,int tmpsec);
	 void initMillTime(int mls);

 public:
	 Time();
	 explicit Time(int tmphour);
	 Time(int tmphour,int tmpmin);
	 explicit Time(int tmphour,int tmpmin, int tmpsec);	 

	 //拷贝构造函数
	Time(const Time &tmptime,int a=56);

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

	int Hour;
	int Minute;	
	int Second;

	Tmpclass c1;

};

Time.cpp

#include "Time.h"
#include <iostream>

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

Time::Time()
{
	std::cout<<"调用了Time::Time()构造函数"<<std::endl;
}

//赋值运算符重载
Time& Time::operator=(const Time& tmpobj)
{
	this->Hour=tmpobj.Hour;
	this->Minute=tmpobj.Minute;
	this->Second=tmpobj.Second;
	std::cout<<"调用了 Time& Time::operator=(const Time& tmpobj)赋值运算符重载"<<std::endl;
	return *this; 
}

project.cpp

#include <iostream>
#include "Time.h"

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

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

void func(Time tmpTime)
{
	return;
}

Time func()
{
	Time time;
	return time;
}

int main()
{
	Time myTime;
	myTime.Hour=9;
	myTime.Minute=30;
	Time myTime2;
	myTime2=myTime; //这个是赋值运算符，既没有调用构造函数，也没有调用拷贝构造函数
	//系统会调用一个拷贝赋值运算符
	//我们可以自己重载赋值运算符，如果我们自己不重载，编译器也会为我们生成一个（编译器格外喜欢赋值运算符）
	//编译器生成的赋值运算符重载比较粗糙，一般就是将非static成员赋值给赋值运算符左侧的对象的对应成员中去。
	//如果这个成员是个类对象的话，可能还会调用这个类的拷贝赋值运算符
	//为了精确控制Time类的赋值操作，我们往往会自己来重载赋值运算符
	//重载赋值运算符：有返回类型和参数列表，这里的参数就表示运算符的运算对象。比如这里的myTime就是运算对象
	//myTime2就是*this对象，myTime就是operator=里边的参数
	std::cout<<"myTime2.Hour= "<<myTime2.Hour<<"   myTime2.Minute= "<<myTime2.Minute<<std::endl;
	system("pause");
	return 0;
}

运行结果：

析构函数
//析构函数：对象在销毁的时候，会自动调用析构函数。
//如果我们自己不写自己的析构函数，编译器也会生成一个默认的析构函数。默认析构函数的函数体为空{}，表示默认的析构函数其实没有干什么
//构造函数里new delete
//析构函数也是类的成员函数，它的名字是由 ~类名 构成，没有返回值，不接受任何参数，不能被重载，所以一个给定的类，只有一个唯一的析构函数

//构造函数的成员初始化：干了两件事，函数体之前和函数体之中
//析构函数的成员销毁：干了两个事，函数体，函数体之后
//成员变量的初始化和销毁时机问题：先定义的先初始化，销毁时先定义的后销毁

int main()
{
	
	Time *myTime3=new Time();  
	//new 出来的东西，必须要自己释放，否则会造成内存泄漏
	//在程序停止运行之前的某个时刻，你一定要用delete把对象占用的内存释放
	delete myTime3;
	//你什么时候delete, 系统就会在什么时候去调用类Time的析构函数
	system("pause");
	return 0;
}