2021-09-05，多态，继承，虚函数，虚析构，深拷贝，浅拷贝，运算符重载，引用的综合应用

在这里插入代码片


#include"ReLoad.h"
//对于多态和运算符重载的练习
//多态的好处是可以将功能分割，不在基类中对模块功能进行修改，在派生类中对模块功能进行修改，方便代码的扩充。

#include<string>
class MyClass//基类，部分运算符继承后使用多态方式实现
{
public:

	int m_NumFirst;
	int m_NumSecond;
	int *m_Age;
	virtual MyClass operator+(MyClass * first)
	{
		return *this;
	}
	friend ostream& operator<<(ostream &cout, MyClass &First);//这里返回引用可以满足链式编程的思想
	//我们都知道，成员函数，需要类的对象去调用，
    //而我们的调用对象却是cout这个ostream类的对象，
   //所以，当然会爆出各种奇奇怪怪的错误。

	//可以声明为友元函数，这样就不会报错
	//友元函数不能被继承，如果需要调用，需要转化为父类，再调用父类的函数，这样多态就没有意义了,所以就不要将左移或者右移函数写为类成员函数。
	//
	virtual MyClass& operator++()//返回引用，对对象本身做返回，这样满足链式编程思想
	{
		return *this;
	}
	virtual MyClass operator++(int)//后置递增运算符
	{
		return *this;
	}

	virtual MyClass & operator=(MyClass & First)//注意，赋值运算符因为基类中有需要在堆区开辟的数据，因而需要使用深拷贝
	{
		return *this;
	}


	  //仿函数，重载函数调用运算符
	void operator()(string test)
	{
		cout <<test<< endl;
	}
	MyClass();
	virtual~MyClass();//等号运输算符派生类中有在堆区申请的内存，因而基类指向子类对象后在删除基类时如果基类析构函数不声明为虚函数，派生类所申请的堆空间将不会被释放。

private:

};

MyClass::~MyClass()
{
	cout << "MyClass析构" << endl;
	if (m_Age!=NULL)
	{
		delete m_Age;

		m_Age = NULL;
	}
}


MyClass::MyClass()
{
	this->m_NumFirst = 1;

	this->m_NumSecond = 1;

}
 ostream& operator<<(ostream &cout, MyClass &First)//这里返回引用可以满足链式编程的思想,友元函数
{
	cout << First.m_NumFirst << First.m_NumSecond<<*First.m_Age<<endl;
	return cout;
}
class MYAdd:public MyClass//加法运算符类继承
{
public:
	MYAdd();

	//MYAdd operator+(MYAdd *FirstClass);
	MyClass operator+(MyClass * FirstClass);
private:

};

MYAdd::MYAdd()
{


}
//加号
MyClass MYAdd::operator+(MyClass * FirstClass)
{
	MyClass Temp;

	Temp.m_NumFirst = this->m_NumFirst + FirstClass->m_NumFirst;
	Temp.m_NumSecond = this->m_NumFirst + FirstClass->m_NumFirst;

	return Temp;
}



//递增运算符
class MYAddAdd:public MyClass
{
public:
	MyClass& operator++();//前置递增运算符
	MyClass operator++(int);//后置递增运算符
};
MyClass& MYAddAdd::operator++()//前置递增运算符
{
	m_NumFirst++;
	m_NumSecond++;
	return *this;
}

MyClass MYAddAdd::operator++(int)//后置递增运算符，后置递增运算符返回的是创建的局部对象，所以不能使用引用
{
	
	MyClass Temp = *this;
	m_NumFirst = 2;
	m_NumFirst++;
	m_NumSecond++;

	return *this;
}


class MYEqual:public MyClass
{
public:
	MYEqual();
	~MYEqual();
	MyClass & operator=(MyClass & First);
private:

};

MYEqual::MYEqual()
{
}

MYEqual::~MYEqual()
{
	cout << "MYEqual析构" << endl;
	if (this->m_Age!=NULL)
	{
		delete this->m_Age;
		this->m_Age = NULL;
	}
}

MyClass & MYEqual::operator=(MyClass & First)
{
	
		this->m_Age = new int(*First.m_Age);
		this->m_NumFirst = First.m_NumFirst;
		this->m_NumSecond = First.m_NumSecond;

		return *this;
}


int main()
{

	MyClass *First = new MYAdd;
	First = new MYAdd;

	MyClass *Second = new MYAdd;
	Second = new MYAdd;

	MyClass Temp;
	Temp("hello word");//仿函数
	//Temp.m_Age = new int(18);
	///*Temp = First->operator+(Second);*/
	//Temp = new MYAddAdd;
	//Temp->operator++(0);
	//*Temp.m_Age = 11;

//	MyClass *Temp1 = new MYEqual;
	//Temp1->operator=(Temp);

	//cout << *Temp1 << endl;
//	delete Temp1;//delete后基类指针释放但是子类指针并没有释放，所以要把基类的虚函数声明为Virtual
	system("pause");
//	Sleep(2000);
}