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");
}

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

顶

0

踩