c++学习笔记（八）：运算符重载的推演

为什么要有运算符重载

先看一个例子：

public:
	
	Complex(int a, int b)
	{
		this->a = a;
		this->b = b;
	}
public:
	int a;
	int b;
};
void Test1()
{
	{
		int a = 0, b = 0;
		int c = a + b;
		//对于基础类型，编译已经知道如何进行加减
	}
	Complex c1(1, 2), c2(3, 4);
	

	Complex c3 = c1 + c2;


	system("pause");
}

程序执行时会出错。

原因 Complex是用户自定义类型。。编译器根本不知道如何进行加减。

编译器给你提供了一种机制，让用户自己去完成，自定义类型的加减操作。

这个机制就是运算符重载机制

当然我们也可以写一个全局函数来完成相加运算：

//通过全局函数完成对象加
Complex add(Complex &c1, Complex &c2)
{
	Complex c3(c1.a + c2.a, c1.b+c2.b);
	return c3;
}

void Test2()
{
	{
		int a = 0, b = 0;
		int c = a + b;
		//对于基础类型，编译已经知道如何进行加减
	}
	Complex c1(1, 2), c2(3, 4);
	Complex c3 = add(c1, c2);

	system("pause");
}

注意：此时的成员变量都是pubic。

给全局函数换个名字：

Complex operator+(Complex &c1, Complex &c2)
{
	Complex c3(c1.a + c2.a, c1.b+c2.b);
	return c3;
}

void Test3()
{
	{
		int a = 0, b = 0;
		int c = a + b;
		//对于基础类型，编译已经知道如何进行加减
	}
	Complex c1(1, 2), c2(3, 4);
	
	Complex c3 = operator+(c1, c2);

	system("pause");
}

程序可以仍然没有出错，调用是把函数名字换成加号看看：

void Test4()
{
	{
		int a = 0, b = 0;
		int c = a + b;
		//对于基础类型，编译已经知道如何进行加减
	}
	Complex c1(1, 2), c2(3, 4);
	Complex c3 = c1 + c2;
	system("pause");
}

程序仍然可以运行没有错误。

可是平时操作的类成员一般都是私有成员（private修饰的），怎么让类外全局变量访问呢？

刚刚学到的友元函数闪亮登场了，哈哈哈。。。

class Complex
{
public:
	friend Complex operator+(Complex &c1, Complex &c2);
	Complex(int a, int b)
	{
		this->a = a;
		this->b = b;
	}
	void printCom()
	{
		cout<<a<<" + "<<b<<"i "<<endl;
	}

private:
	int a;
	int b;
};


Complex operator+(Complex &c1, Complex &c2)
{
	Complex c3(c1.a + c2.a, c1.b+c2.b);
	return c3;
}
void main()
{
	{
		int a = 0, b = 0;
		int c = a + b;
		//对于基础类型，编译已经知道如何进行加减
	}
	Complex c1(1, 2), c2(3, 4);
	Complex c3 = c1 + c2;
	c3.printCom();
	system("pause");
}

哈哈，运算符重载的基本演化先到这里吧。。