6、操作符的重载

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);
}
(1);
}

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

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

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

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