【C++基础篇】学习C++就看这篇---＞类和对象之拷贝构造和运算符重载

Time t1(11, 5, 59);
Time t2(11, 5, 59);

	Time t1(11, 5, 59);
	Time t2(t1);//背景：拷贝构造所要解决的问题就是如果我想实例化一个与t1一样参数的对象
                //不必像t1那样将每个参数再重新弄一遍
				//只需把t1作为参数传给t1即可

class Time
{
public:
	Time(int hour = 0, int minute = 0, int second = 1)//全缺省参数
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}
	Time(Time& t)
	{			 
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

int main()
{
	Time t1(11, 5, 59);
	Time t2(t1);
	return 0;
}

	Time(Time t)//但是如果此处的拷贝构造参数写成Time t，就会出现错误，事实上这个错误就是无限递归构造的错误
	{			//因为t1作为参数传给t，本质上就又是一次拷贝构造，它等价于Time t = t1，也即是Time t(t1)，再往下又是拷贝构造，循环往复
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
	}

void func(Time t)
{
}

Time(Time& t)
	{			 
		_hour = t._hour;
		_minute = t._minute;
		t._second = _second;//这里就会产生这样的问题，如果一不小心写反了，
                            //就会产生赋值错误的情况，所以我们一般加const来进行修饰
	}

Time(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		t._second = _second;//这样就会自动报错，从而编译不过去，所以以后一般是这样写，除非是要更改t1的情况
	}

class Stack {
public:
	Stack(int n = 10)
	{
		_a = (int*)malloc(sizeof(int) * n);
		_size = 0;
		_capacity = n;
	}
	~Stack()
	{
		free(_a);
		_a = nullptr;
		_size = 0;
		_capacity = 0;
	}
private:
	int* _a;
	int _size;
	int _capacity;
};
int main()
{
	Stack t1;
	Stack t2(t1);
	return 0;
}

class Time
{
public:
	Time(int hour = 0, int minute = 0, int second = 1)//全缺省参数
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}
	Time(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
	}
	void Print()
	{
		cout << _hour << ":" << _minute << ":" << _second << endl;
	}

	int _hour;
	int _minute;
	int _second;
};
bool operator==(const Time& t, const Time& d)//但是这样调用存在访问限定符无法使用，因此我们一般将运算符重载函数写成成员函数，这样即使你是私有的我依然可以访问你
{
	return t._hour == d._hour && t._minute == d._minute
		&& t._second == d._second;//这样定义在外面虽说可以调用这个函数，但是访问的却都是类里面的私有变量，访问不了
									//只有当私有变量转换成公有的之后，才能不报错
}
int main()
{
	Time t1(11, 5, 59);
	Time t2(t1);
	//如果我们想比较t1与t2时间是否相等，在C语言中肯定是不可能用 == 来比较的，一般 == 比较只能比较内置类型，int double char等等
	//但是C++改变了这个困境，所以运算符重载所要解决的问题就是，我也想像内置类型那样那么容易就比较大小等等
	cout << (t1 == t2) << endl;//事实上这里编译器执行的时候自动等价为：cout << (operator==(t1, t2)) << endl
    cout << (operator==(t1, t2)) << endl;//与上述本质是一样的，没有任何区别
	return 0;
}

class Time
{
public:
	Time(int hour = 0, int minute = 0, int second = 1)//全缺省参数
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}
	Time(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
	}
	bool operator==(const Time& d)//写在成员函数，就需要注意参数里面有一个隐藏的参数this指针，即等价为bool operator==(const Time* this, const Time& d)
	{							  //所以左操作数就不需要另作为参数进行传递，因为已经以this指针的形式进行传递了
		return _hour == d._hour && _minute == d._minute
			&& _second == d._second;
	}
	void Print()
	{
		cout << _hour << ":" << _minute << ":" << _second << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
int main()
{
	Time t1(11, 5, 59);
	Time t2(t1);
	cout << (t1 == t2) << endl;//这里编译器处理等价于cout << (t1.operator==(t2)) << endl，当然参数里还有一个&t1，但是我们不能写，只是隐含的
	cout << (t1.operator==(t2)) << endl;//与上述语句本质一样，无任何区别
	return 0;
}

Date& operator++()
{
	*this += 1;
	return *this;
}
	
Date operator++(int)//后置++独有的格式参数独写一个int
{
	Date temp(*this);
	temp += 1;
	return temp;
}

	void operator=(const Time& d)
	{	
		_hour = d._hour;
		_minute = d._minute;
		_second = d._second;
	}

	void operator=(const Time& d)
	{	
		if (!(*this == d))
		{
			_hour = d._hour;
			_minute = d._minute;
			_second = d._second;
		}
	}

	Time& operator=(const Time& d)
	{	
		if (!(*this == d))
		{
			_hour = d._hour;
			_minute = d._minute;
			_second = d._second;
		}
		return *this;
	}

	Time& operator=(const Time& d)
	{	
		if (!(*this == d))
		{
			_hour = d._hour;
			_minute = d._minute;
			_second = d._second;
		}
		return *this;
	}

Time t3 = t1;