运算符重载

不能重载的运算符有 .  和 .* 和 ?: 和 ::  和 sizeof

友元函数和成员函数的使用场合：一般情况下，建议一元运算符使用成员函数，二元运算符使用友元函数

1、运算符的操作需要修改类对象的状态，则使用成员函数。如需要做左值操作数的运算符（如 =，+=，++）

2、运算时，有数和对象的混合运算时，必须使用友元

3、二元运算符中，第一个操作数为非对象时，必须使用友元函数。如输入输出运算符 << 和 >>

4、当一个重载运算符是成员函数时，this 绑定到左侧运算对象。成员运算符函数的显式形参比运算对象的数量少一个

5、可以直接调用一个重载的运算符函数，如 operator+(data1, data2), data1.operator(data2)

6、当运算符作用于内置类型对象时，我们无法改变运算符的含义

具体规则如下：

运算符	建议使用
所有一元运算符	成员函数
＝ ( ) [ ]  ->	必须是成员函数
+= -= /= *= ^= &= != %= >>= <<= , 似乎带等号的都在这里了.	成员函数
所有其它二元运算符, 例如: –,+,*,/	友元函数
<< >>	必须是友元函数

 参数和返回值：

     当参数不会被改变，一般按 const 引用来传递(若是使用成员函数重载，函数也为 const).对于返回数值的决定:

     1) 如果返回值可能出现在 = 号左边, 则只能作为左值, 返回非 const 引用。

     2) 如果返回值只能出现在 = 号右边, 则只需作为右值, 返回 const 型引用或者 const 型值。

     3) 如果返回值既可能出现在 = 号左边或者右边, 则其返回值须作为左值, 返回非 const 引用。

以上内容摘自：blog.csdn.net/insistgogo/article/details/6626952

重载 -> 运算符：

#include <iostream>
using namespace std;

class strptr{
// friend std::string* operator->(const strptr&);

private:
    std::string *ptr;

public:
    strptr(string *s) : ptr(s) {}
    strptr() = default;
    std::string* operator->(){//注意这里返回的是一个指针,而非对象本身
        return ptr;
    }
};

// std::string* operator->(const strptr &it){
//     return it.ptr;
// }

int main(void){
    string s = "hello";
    strptr str(&s);
    cout << str->size() << endl;
    return 0;
}

我们可以发现 -> 运算符只能作为成员函数重载，如果作为友元函数重载的话会报错：

str->size() 等价于 ptr.operator->()->size(); 等价于 ptr->size();

这是由 C++ 标准规定的，对于 ptr->mem 根据 ptr 类型的不同，操作符 -> 的解释也不同：

当 ptr 的类型是内置指针类型时，等价于 (*ptr).mem；

当 ptr 的类型是类时，等价于ptr.operator->()->mem；//从这里也可以看出 -> 重载必须是成员函数

你会发现这是一个递归的解释，对于 ptr->mem 会递归成：

(*(ptr.operator->().operator->().….operator->())).mem

重载 +/- 运算符:

#include <iostream>
using namespace std;

class gel{
friend const gel operator+(const gel&, const gel&);
// friend gel operator-(const gel&, const gel&);

private:
    int x;

public:
    gel(int a) : x(a){}
    gel() = default;
    ~gel(){}
    
    // const gel operator+(const gel &b) const{
    //     gel c = *this;
    //     c.x += b.x;
    //     return c;
    // }
    
    const gel operator-(const gel &b) const{//返回的是右值,所以可以返回const值
        gel c = *this;
        c.x -= b.x;
        return c;//c是一个局部对象,不能返回引用
    }
    

    void print(ostream &os) const{
        os << x << endl;
    }
};

const gel operator+(const gel &a, const gel &b){
    gel c = a;//为了不改变*this,即加数本身
    c.x += b.x;
    return c;
}

// gel operator-(const gel &a, const gel &b){
//     gel c = a;
//     c.x -= b.x;
//     return c;
// }

int main(void){
    gel a(1), b(2);
    gel c = a + b;//正确,调用友元函数
    c.print(cout);//3

    a = c - b;//正确,调用成员函数
    a.print(cout);//1

    c = a + 1;//正确,先执行转换构造函数将1转换成gel类类型,再执行加法
    c.print(cout);//2

    c = 1 + a;//正确,先执行转换构造函数将1转换成gel类类型,再执行加法
    c.print(cout);//2

    a = c - 1;//正确,先执行转换构造函数将1转换成gel类类型,再执行减法
    a.print(cout);//1

    // a = 3 - c;//错误,-是gel类成员函数重载,其第一个操作数必须是gel类对象
    return 0;
}

注意：

重载 +/- 函数作为成员函数时不能有两个显示的形参，因为 +/- 是二元运算符，而 this 也算是一个形参，如果再传两个形参进去的话就有三个形参了

重载成类的成员函数的话在使用重载后的运算符时需要满足其第一个操作数为类的对象，因此在混合运算时应该将其重载为友元函数

重载 *// 运算符：

与 +/- 运算符的重载基本一样：

#include <iostream>
using namespace std;

class gel{
friend const gel operator/(const gel&, const gel&);

private:
    int x;

public:
    gel(int a) : x(a){}
    gel(void) : gel(0){}
    ~gel(){}

    const gel operator*(const gel &b) const{
        gel c = *this;//最好不要改变两个乘数本身
        c.x *= b.x;
        return c;
    }

    ostream& print(ostream &os){
        os << this->x << endl;
    }
};

const gel operator/(const gel &a, const gel &b){
    gel c = a;
    c.x /= b.x;
    return c;
}

int main(void){
    gel a(1), b(2);
    gel c = a * b;//正确,执行成员函数
    c.print(cout);//2

    c = b / a;//正确,执行友元函数
    c.print(cout);//2

    c = a * 3;//正确,先通过转换构造函数将3转换成gel类对象,再进行*运算
    c.print(cout);//3

    // c = 3 * a;//错误,成员函数重载的第一个操作数必须是类的对象

    c = 3 / a;//正确,先通过转换构造函数将3转换成gel类对象,再进行/运算
    c.print(cout);//3

    c = b / 1;//正确,先通过转换构造函数将1转换成gel类对象,再进行/运算
    c.print(cout);//2
    return 0;
}

注意：

重载 *// 函数作为成员函数时不能有两个显示的形参，因为 *// 是二元运算符，而 this 也算是一个形参，如果再传两个形参进去的话就有三个形参了

重载成类的成员函数的话在使用重载后的运算符时需要满足其第一个操作数为类的对象，因此在混合运算时应该将其重载为友元函数

重载 ++/-- 运算符：

#include <iostream>
using namespace std;

class gel{
friend void print(ostream&, const gel&);
friend gel& operator--(gel&);
friend const gel operator--(gel&, int);

private:
    int x;

public:
    gel(int a) : x(a){};
    gel() = default;
    ~gel(){}

    gel& operator++(){
        ++x;
        return *this;
    }
    const gel operator++(int){//这里不能返回引用
        const gel cmp = *this;
        ++x;
        return cmp;
    }
    // gel& operator--(){
    //     --x;
    //     return *this;
    // }
    // const gel operator--(int){//不能返回引用
    //    const gel cmp = *this;
    //     --x;
    //     return cmp;
    // }
    
};

gel& operator--(gel &it){
    --it.x;
    return it;
}

const gel operator--(gel &it, int){//不能返回引用
    const gel cmp = it;
    --it.x;
    return cmp;
}

void print(ostream &os, const gel &it){
    os << it.x << std::endl;
}

int main(void){
    gel a(10);
    print(cout, ++a);//11
    print(cout, a++);//11
    print(cout, a);//12
    print(cout, --a);//11
    print(cout, a--);//11
    print(cout, a);//10
    return 0;
}

注意：

需要用一个占位符(虚参数)区分前后缀运算
后置时不要返回引用,不然会返回一个局部对象引用

重载 [] 运算符：

#include <iostream>
using namespace std;

class gel{
// friend int& operator[](const int&, const gel&);

private:
    int x[5];

public:
    gel(){
        for(int i = 0; i < 5; i++){
            x[i] = i;
        }
    }
    ~gel(){}

    int& operator[](const int &y){//[]重载必须是一个非静态成员函数
        static int t = 0;
        if(y < 5 && y >= 0) return x[y];
        else {
            cout << "out of arange!" << endl;
            return t;
        }
    }
    
};

// int& operator[](const int &y, const gel &it){
//     static int t = 0;
//     if(y < 5 && y >= 0) return x[y];
//     else {
//         cout << "out of arange!" << endl;
//         return t;
//     }
// }

int main(void){
    gel a;
    for(int i = 0; i < 10; i++){
        cout << a[i] << " ";
    }
    cout << endl;
    a[0] = 10;//重载返回的是左值
    cout << a[0] << endl;//10
    return 0;
}

我们可以发现 [] 只能作为成员函数重载，如果重载为友元函数的话会报错：

注意：

从上面的代码我们可以发现 [] 重载必须是一个非静态成员函数
但是上面的代码任然有一个 bug：我们对 [] 的重载是非 const 的，不能被 const 对象调用
我们可以通过基于 const 的重载来解决这个问题：

#include <iostream>
using namespace std;

class gel{
private:
    int x[5];

public:
    gel(){
        for(int i = 0; i < 5; i++){
            x[i] = i;
        }
    }
    ~gel(){}

    int& operator[](const int &y){
        static int tmp = do_operator(y);
        return tmp;
    }

    const int& operator[](const int &y) const{//这里返回值是const值,是右值
        static const int tmp = do_operator(y);
        return tmp;
    }


private:
    const int& do_operator(const int &y) const{
        static int t = 0;
        if(y < 5 && y >= 0) return x[y];
        else {
            cout << "out of arange!" << endl;
            return t;
        }
    }
    
};

int main(void){
    gel a;
    for(int i = 0; i < 10; i++){
        cout << a[i] << " ";
    }
    cout << endl;
    a[0] = 10;//对非const对象重载返回的是左值
    cout << a[0] << endl;

    const gel b;
    for(int i = 0; i < 10; i++){
        cout << b[i] << " ";
    }
    cout << endl;
    return 0;
}

重载 () 运算符：

#include <iostream>
using namespace std;

class gel{
// friend const int operator()(const gel&, const gel&);

private:
    int x;

public:
    gel(int a) : x(a){}
    gel() : gel(0){}
    ~gel(){}

    const int operator()(const gel &it) const{
        return (x + it.x);
    }
};

// const int operator()(const gel &a, const gel &b){
//     return a.x + b.x;
// }

int main(void){
    gel a(1), b(2);
    cout << a(b) << endl;//3
    return 0;
}

我们可以发现 () 只能作为非静态成员函数重载，如果重载为友元函数的话会报错：

重载运算符 () 的目的：对象 () 类似于函数名 (x)，更加符合习惯

语法：

        重载方式：只能使用成员函数重载

        重载后还可以继续重载

        函数名：operator( )(参数表)

        参数表：参数随意，具体根据实际情况而定。

        函数调用：显式调用：Obj(x)

                          隐式调用：obj.operator( )(x)  

        返回类型：

               1、返回成员的实际类型随意，具体由程序员根据函数体定义

               2、因为返回值只能做右值，只读，应该使用返回值为const类型

重载 >>/<<运算符：

#include <iostream>
using namespace std;

class gel{
friend ostream& operator<<(ostream&, const gel&);
friend istream& operator>>(istream&, gel&);

private:
    int x, y;

public:
    gel(int a, int b) : x(a), y(b){}
    gel(int a) : gel(a, 0){}
    gel() : gel(0, 0){}
    ~gel(){}
};

ostream& operator<<(ostream &os, const gel &it){
    os << it.x << " " << it.y;
    return os;
}

istream& operator>>(istream &is, gel &it){
    is >> it.x >> it.y;
    return is; 
}

int main(void){
    gel a(1, 2);
    cin >> a;
    cout << a << endl;
}

注意：

在重载输出输入运算符的时候，只能采用全局函数的方式(因为我们不能在 ostream 和 istream 类中编写成员函数)，这里才是友元函数真正的应用场景。
成员函数要求是有对象调用，则第一个参数必须是类的对象，但是 << 和 >> 第一个参数是流的对象引用。故不能使用成员函数：

#include <iostream>
using namespace std;

class gel{
// friend ostream& operator<<(const gel&, ostream&);
friend ostream& operator<<(ostream&, const gel&);

private:
    int x, y;

public:
    gel(int a, int b) : x(a), y(b){}
    gel(int a) : gel(a, 0){}
    gel(void) : gel(0, 0){}
    ~gel(){}
};

// ostream& operator<<(const gel &it, ostream &os){
//     os << it.x << " " << it.y;
//     return os;
// }

ostream& operator<<(ostream &os, const gel &it){
    os << it.x << " " << it.y;
    return os;
}

int main(void){
    gel a(1, 2);
    cout << a << endl;
    return 0;
}

通过这个例子可以发现 << 运算符的第一个参数必须是流的对象引用

我们可以发现不加 cout << a << endl; 着个语句的话这个代码是正确的，再结合前面的东西,我们可以得出这个语句错误的原因：
将 << 重载成 gel 类的成员函数，其第一个参数必须是 gel 类的对象，即要求 << 是右结合的 (a 在 << 右边嘛)，而 << 本身是要求左结合的。此处矛盾所以是错误的
那么我们可以尝试着将 cout << a << endl; 改成既满足 << 是左结合的，又满足 << 的第一个参数是 a：

#include <iostream>
using namespace std;

class gel{
private:
    int x, y;

public:
    gel(int a, int b) : x(a), y(b){}
    gel(int a) : gel(a, 0){}
    gel(void) : gel(0, 0){}
    ~gel(){}
    
    ostream& operator<<(ostream &os){
        os << this->x << " " << this->y;
        return os;
    }
};

int main(void){
    gel a(1, 2);
    // cout << a << endl;
    //我们可以发现不加这个语句的话这个代码是正确的,再结合前面的东西,我们可以得出这个语句错误的原因：
    //将<<重载成gel类的成员函数,其第一个参数必须是gel类的对象,即要求<<是右结合的(a在<<右边嘛),而<<本身是要求左结合的.此处矛盾所以是错误的
    //那么我们可以尝试着将cout << a << endl;改成既满足<<是左结合的,又满足<<的第一个参数是a
    a.operator << (cout) << endl;//此处cout必须加括号,将opetator<<当成一个a类的成员函数,后面接着的当然是参数列表啦,cout是实参.又因为其返回的是一个cout流,所以后面可以接其它输出内容
    return 0;
}

当然通常我们没必要把代码写成这样~

重载 = 运算符：

#include <iostream>
#include <string>
#include <stdio.h>
#include <string.h>
using namespace std;

class str{
// friend str& operator=(const str&, const str&);

private:
    int id;
    char *name;

public:
    str(int id_, const char *name_) : id(id_){
        name = new char[strlen(name_) + 1];
        strcpy(name, name_);
    }
    str(int id_) : str(id_, ""){}
    str(const char *name_) : str(0, name_){}
    ~str(){ delete name; }
    
    ostream& print(ostream &os) const{
        os << id << " " << name << endl;
    }

    str& operator=(const str &it){//返回左值,如果不返回str&的话将不能用连等
        if(this != &it){//如果目标字符串的地址不同的话执行拷贝操作
            if(name != NULL) delete name;
            id = it.id;
            name = new char[strlen(it.name) + 1];
            strcpy(name, it.name);
        }
        return *this;
    }
};

// str& operator=(const str &a, const str &b){
//     if(&a != &b){
//         if(a.name != NULL) delete a.name;
//         a.id = b.id;
//         a.name = new char[strlen(b.name) + 1];
//         strcpy(a.name, b.name);
//     }
//     return *this;
// }

int main(void){
    str a(1, "hello world"), b(2, "jj fu jj");
    a.print(cout);//1 hello world
    a = b;
    a.print(cout);//2 jj fu jj

    a = "ajsdfkls";//先通过转换构造函数将"ajsdfkls"转换成str对象,然后再执行赋值操作
    a.print(cout);//0 ajsdfkls
    return 0;
}

我们可以发现 = 只能作为成员函数重载，如果重载为友元函数的话会报错：

注意：

我们最好将返回类型写成 str&，不然将不能用连等~

要避免自赋值，即地址相同的两个对象相互赋值：

1.为了效率。显然，自己给自己赋值完全是毫无意义的无用功，特别地，对于基类数据成员间的赋值，还会调用基类的赋值运算符重载函数，开销是很大的。如果我们一旦判定是自赋值，就立即 return *this，会避免对其它函数的调用。

2.如果类的数据成员中含有指针，自赋值有时会导致灾难性的后果。对于指针间的赋值（注意这里指的是指针所指内容间的赋值，这里假设用 _p 给 p 赋值），先要将 p 所指向的空间 delete 掉（为什么要这么做呢？因为指针 p 所指的空间通常是 new 来的，如果在为 p 重新分配空间前没有将p原来的空间 delete 掉，会造成内存泄露），然后再为 p 重新分配空间，将 _p 所指的内容拷贝到 p 所指的空间。如果是自赋值，那么 p 和 _p 是同一指针，在赋值操作前对 p 的 delete 操作，将导致 p 所指的数据同时被销毁。那么重新赋值时，拿什么来赋？

所以，对于赋值运算符重载函数，一定要先检查是否是自赋值，如果是，直接return *this。

这部分内容参考：https://www.cnblogs.com/zpcdbky/p/5027481.html