C++重载运算符operator

重载运算符用operator关键字，后面跟上要操作的运算符，比如operator++(重载前自加)，要把operator++看成是一个整体，它就是函数的名字，前面的返回类型和后面的形参表和普通函数一样。

1、重载前自加

class MyClass
{
public:
	MyClass(){n = 0;}
	void operator++()//operator++是一个整体，看做函数的名字，函数的返回值是void
	{
		++n;
	}
	int get()const{return n;}
private:
	int n;
};
int main()
{
	MyClass M;
	++M;//前自加
	cout<<M.get()<<endl;//--1
	return 0;
}

2、将自加后的对象赋给另一个对象

class MyClass
{
public:
	MyClass(){n = 0;}
	MyClass(const MyClass &m)
	{
		n = m.n;
	}
	//前自加
	const MyClass &operator++()
	{
		//自加之后返回这个对象
		++n;
		return *this;
	}
	int get()const{return n;}
private:
	int n;
};
int main()
{
	MyClass M;
	//把自加后的M赋值给mc
	MyClass mc = ++M;//++M相当于M.operator++()
	cout<<mc.get()<<endl;//--1
	return 0;
}

3、重载后自加

前自加是先将对象的成员+1之后再返回对象，后自己是先返回对象，再将对象的成员+1

前自减和后自减同前后自加一样

class MyClass
{
public:
	MyClass(){n = 0;}
	MyClass(const MyClass &m)
	{
		n = m.n;
	}

	//后自加
	//int是一个无效参数，不用理会，但是必须有且必须为int类型，在这里只是作为一个标识，表明重载的是后自加
	const MyClass operator++(int)
	{
		//先记住对象调用后自加之前的状态
		MyClass m(*this);
		++n;//或++*this
		return m;
	}

	int get()const{return n;}
private:
	int n;
};
int main()
{
	MyClass M;
	MyClass C = M++;
	cout<<C.get()<<endl;//--0
	return 0;
}

4、重载+-运算符

class MyClass
{
public:
	MyClass(){n = 0;}
	MyClass(int i){n = i;}
	MyClass(const MyClass &m)
	{
		n = m.n;
	}

	//重载+号运算符
	MyClass operator+(const MyClass &t)
	{
		//n是+号左边对象成员
		//t是+号右边对象
		return MyClass(n + t.n);
	}

	//重载-号运算符
	MyClass operator-(const MyClass &t)
	{
		return MyClass(n - t.n);
	}

private:
	int n;
};
int main()
{
	MyClass m1(1),m2(2);
	MyClass m3 = m1 + m2;//m1.operator+(m2);
	MyClass m4 = m3 - m1;//m3.operator-(m1);
	return 0;
}

5、重载=赋值运算符

由于默认复制构造函数是浅层复制，所以当成员变量中含有指针的时候，如果还是利用浅层复制，比如a=b，此时对象a和对象b中的指针成员拥有相同的内存地址，删除任意一个对象都会造成另一个对象中的指针成员成为野指针，最终导致程序崩溃，所以重载=运算符的时候，需要显式的定义自己的复制构造函数，相应的构造函数和析构函数也要做对应的修改。

class MyClass
{
public:
	MyClass()
	{
		p = new int; *p=1;
	}
	MyClass(int i)
	{
		p = new int; *p=i;
	}
	MyClass(const MyClass &m)
	{
		p = new int; *p = *(m.p);
	}
	~MyClass()
	{
		if(p)
		{
			delete p;
			p = NULL;
		}
	}

	const MyClass &operator=(const MyClass &m)//m是=号右边的对象
	{
		//自己给自己赋值的情况
		if (this == &m)
		{
			return *this;
		}
		else
		{
			//把=号右边对象成员的值赋给左边对象成员
			*p = *(m.p);
			return *this;
		}
	}
private:
	int *p;
};
int main()
{
	MyClass *p = new MyClass(100);
	MyClass m(200);
	m = *p;//相当于m.operator=(*p);
	delete p;
	p = NULL;
	return 0;
}