操作符的重载

1.基本

输入和输出

cout << "hello" << endl << "world";

输出：
hello world

可见，输出，endl 是换行的作用

	int x;
	cout << "input the num what you want:";
	cin >> x;
	cout << "the num  you input is:";
	cout << x;

从键盘输入一个数值，赋值给 x，然后将数值再打印到屏幕。

上面的 << >> 左移和右移，居然实现了输入输出的例子，所以说左移和右移的运算符是被重载的，在不同的上下文，操作符有不同的功能；

C++操作符的重载：operator + 运算符

struct Complex
{
	int a;
	int b;
};


// 操作符的重载
Complex operator+ (Complex &c1, Complex &c2)
{
	Complex k;
	k.a = c1.a + c2.a;
	k.b = c1.b + c2.b;
	return k;
}

int main()
{
	Complex a1 = { 1, 2 };
	Complex a2 = { 3, 4 };
	Complex a3 = operator+(a1, a2);
// 也可以直接：Complex a3 = a1 + a2;

	cout << "a3.a=" << a3.a << endl;
	cout << "a3.b=" << a3.b << endl;

	while (1);
}

操作符的重载实现了复数的加法运算，必须记得操作的重载的关键字：operator，

问题： 操作符的重载能不能在类里面实现？答案是可以的：

class Complex
{
	int a;  // 默认的是私有的
	int b;
public:
	Complex(int a = 0, int b = 0) 
	{
		this->a = a;
		this->b = b;
	}
	int getA()
	{
		return a;
	}
	int getB()
	{
		return b;
	}

	~Complex()
	{

	}

	// 指定朋友，友元函数
	friend Complex operator+ (Complex &c1, Complex &c2);
};


// 操作符的重载
Complex operator+ (Complex &c1, Complex &c2)
{
	Complex k;
	// 这样可以通过对象访问到private成员
	//k.a = c1.getA() + c2.getA();
	//k.b = c1.getB() + c2.getB();
	k.a = c1.a + c2.a; // 通过对象直接访问
	k.b = c1.b + c2.b;
	return k;
}

int main()
{
	Complex a1(1, 2);
	Complex a2(3, 4);

	Complex a3 = a1 + a2;

	cout << "a3.a = " << a3.getA() << endl;
	cout << "a3.b = " << a3.getB() << endl;
	while (1);
}

private成员，是不可以通过对象访问到private成员变量的，但是加上 friend关键字之后，就上上面的代码，指定了一个友元的函数，那么这个函数就可以通过对象访问private成员了，

ostream& operator<< (ostream& out, Complex &c)
{ // 这个地方看不懂
	out << c.a << " and " << c.b << endl;

	return out;
}

int main()
{
	Complex a1(1, 2);
	Complex a2(3, 4);

	Complex a3 = a1 + a2;

	cout << a3 << endl;

	while (1);
}

操作符重载在类内实现：

class Complex
{
	int a;  // 默认的是私有的
	int b;
public:
	Complex(int a = 0, int b = 0) 
	{
		this->a = a;
		this->b = b;
	}
	int getA()
	{
		return a;
	}
	int getB()
	{
		return b;
	}

	~Complex()
	{

	}

	// 这里第一个对象有传入 this 指针，所以只需要一个就可以了，
	Complex operator+ (Complex &c2);
};

Complex Complex :: operator + (Complex &c2)
{
	Complex k;
	k.a = this->a + c2.a;
	k.b = this->b + c2.b;
	return k;
}

int main()
{
	Complex a1(1, 2);
	Complex a2(3, 4);

	Complex a3 = a1 + a2;

	cout << a3.getA() << endl;
	cout << a3.getB() << endl;
	while (1);
}

这里需要注意，操作符的重载是可以在类的内部实现的，这里需要注意的是，传入的参数的个数，我们这里只需要传入第二个参数，原因是因为编译器会把第一个对象的地址传入 this 指针，所以传入一个就对了，传入两个，反而会出错，

在类的内部实现操作符的重载的好处：

（1）比全局的操作符重载函数少了一个参数嘛，因为传到 this 指针了

（2）不需要使用 friend 关键字

来自为知笔记(Wiz)