运算符重载

当自定义类型需要进行运算的时候必须讲运算符进行重载。运算符重载使得编译器给所有的类起了一个通用的运算符名称即operator和运算符组合的形式，这样不同类在重载运算符的时候就有一个通用的名字了。

加号运算符重载

类和基本内置类型相加的实现：

这种情况可以使用全局函数重载和成员函数重载

class Person {
public: 
    Person operator+(int num) {
        Person temp;
        temp.a_ = this->a_ + num;
        temp.b_ = this->b_ + num;
        return temp;
    }
    int a_;
    int b_;
};
void test01() {
    Person p1;
    p1.a_ = 10;
    p1.b_ = 10;

    Person p3 = p1 + 10;
    cout << p3.a_ << endl;
}

输出结果是20

左移运算符的重载：

这个时候只能使用全局函数重载，因为我们想要cout在输出对象的前面，总的来说成员函数重载和成员函数的重载的不同之处在于，成员函数重载你不能控制它的顺序比如cout你必须在对象的左侧，而全局函数的重载可以控制顺序，即第一个参数在第二个参数的左侧。

class Person {
    friend std::ostream& operator<<(std::ostream& cout, Person& p);
public:
    Person(int a, int b) :a_(a), b_(b) {

    }
private:
    int a_;
    int b_;
};
std::ostream& operator<<(std::ostream& cout, Person& p) {
    cout << p.a_ << endl;
    return cout;
}
void test01() {
    Person p(10,20);
    cout << p << endl;
}

当函数返回自定义对象时，想要打印这个函数的返回值，重载第二个参数必须用const

举个不恰当的例子：

struct student
{
    int age ;
    string name;
};
std::ostream& operator<<(std::ostream& cout, const student& st) {
    cout << st.age << endl;
    cout << st.name << endl;
    return cout;
}
student fun()
{
    student st;
    st.age = 10;
    st.name = "张三";
    return st;
}

int main()
{
    cout << fun() << endl;
    system("Pause");
    return 0;
}

如果不加const:

这是因为fun()返回的student是个右值，但是重载的<<，第二个参数是个左值引用，fun()无法绑定到左值引用，改成 const student&就可以绑定到右值了。

前置和后置递增运算符（递减也一样的）

    Myinteger& operator++() {
        ++num_;
        return *this;
    }//前置
    Myinteger operator++(int) {
        Myinteger ret = *this;
        ++num_;
        return ret;
    }//后置

下面进行几点说明：

• 后置运算符为什么不返回引用，因为ret是局部对象，不能返回局部对象的引用
• 从这个地方可以看出来为什么前置是左值，而后置是右值；因为前置返回的是一个引用，引用是左值。而后置在函数执行return语句的时候函数会创建一个临时量，这个临时变量会接收ret的值，因为是临时量所以它是右值。从内置类型的角度来看左值和右值：

这里面后置报错的原因就是因为a加加之后是一个右值而右值不可以修改，而前置加加后是一个左值，左值可以更改。

函数调用运算符

class Myprint {
public:
    void operator()(string test) {
        cout << test << endl;
    }
    
};
class Myadd {
public:
    int operator()(int num1, int num2) {
        return num1 + num2;
    }
};
void test01() {
    Myprint myprint;
    myprint("hello world"); //由于使用起来非常像一个函数调用因此称为一个仿函数
}
void test02() {
    Myadd myadd;
    int ret = myadd(100, 100);
    cout << "ret=" << ret << endl;
    //匿名函数对象,执行过当前行就被释放
    cout << Myadd()(100, 100) << endl;
}

int main(){
    //仿函数特别灵活，没有固定的写法
    test01();
    test02();
    system("pause");
    return 0;
}