C++ 面向对象编程4 运算符重载

原理和机制

  C++的运算符默认只支持基本类型，但是C++提供了实现类类型使用运算符的语法也就是运算符的重载。运算符的重载本质上是通过函数来实现，将类类型的运算过程写成一个特殊的函数，当对应类型遇到该运算时自动调用该函数。实现运算符的重载既可以通过成员函数，也可以使用全局函数来实现，其主要功能是进行对象与对象之间的操作，其操作逻辑也需要符合基本类型的逻辑，不然容易产生误会。

一般双目运算符的重载

1.成员函数重载(加法为例)

    返回值类型 operator+(第二个对象){.....}  

  当在程序中碰到了 “第一个对象+第一个对象”，就会调用上面的函数，注意第一个对象的类型必须是所在运算符的重载函数的类型，第二个对象类型也必须与函数的参数类型相对应，不然不能够重载，接下来的各种运算符重载也是如此，不在一一赘述。
实验程序：分数加法运算

#include <iostream>

using namespace std;

class Fraction{
public:
    explicit Fraction(int x = 0, int y = 1):x(x), y(y){}; //explicit 不允许隐式转换
    
    void print()
    {
        cout<<this->x<<"/"<<this->y<<endl;
    }

    Fraction operator+(const Fraction &fb)
    {
        return Fraction(this->x*fb.y+fb.x*this->y,this->y*fb.y); 
    }

private:
    int x;/*分子*/
    int y;/*分母*/
};

int main()
{
    Fraction fa(1, 2);
    Fraction fb(1, 3);

    Fraction fc = fa + fb;
    fc.print();

    return 0;
}

输出结果：5/6

2.全局函数重载

    返回值类型 operator+(第一操作数,第二操作数){......}

  与成员函数重载不同全局函数重载需要传递两个参数，只需要与函数的参数类型向对应，当在程序中碰到了“第一个对象+第一个对象”，就会调用上面的函数。需要注意的是，如果类外函数无法发文类内的成员，可以使用以下方法解决：
  1).将成员改为公有；
  2).使用友元；
  3).为成员提供访问的接口。
实验程序：

#include <iostream>

using namespace std;

class Fraction{
public:
    explicit Fraction(int x = 0, int y = 1):x(x), y(y){}; //explicit 不允许隐式转换
    
    void print()
    {
        cout<<this->x<<"/"<<this->y<<endl;
    }

friend Fraction operator+(const Fraction &fa, const Fraction &fb);

private:
    int x;
    int y;
};

Fraction operator+(const Fraction &fa, const Fraction &fb)
{
    return Fraction(fa.x*fb.y+fb.x*fa.y/*分子*/,fa.y*fb.y/*分母*/);
}

int main()
{
    Fraction fa(1, 2);
    Fraction fb(1, 3);

    Fraction fc = fa + fb;
    fc.print();

    return 0;
}

输出结果：5/6
  编译器对类类型运算的处理(加法为例)：
    1).当编译器遇到fa+fb,先去Fraction类中寻找一个成员函数operator+(const Fraction &),如果有，就调用该函数来计算fa+fb;
    2).如果没有，就去全局函数中寻找operator+(const Fraction &,const Fraction &),如果有，就调用该函数来计算fa+fb;
    3).如果没有，编译器报错。

3.类类型和基本类型之间的运算

Fraction+整数 ------- 可以用成员/全局来重载
整数+Fraction ------- 只能用全局函数来重载

双目运算符的重载

1.输入运算符的重载(cin<<)

1).先去cin对象的类型istream中找一个成员函数：operator>>(a的引用类型)
2).如果找不到，就去找一个全局函数：operator>>(istream &is,a的引用类型)
3).如果再找不到就报错

//istream是C++自定义的类，内部不能修改。所以开发者只能将cin>>重载为全局函数，
//并且将该函数声明为a对应类的友元

2.输出运算符的重载(cout<<)

1).先去cout对象的类型ostream中找一个成员函数：operator<<(a的常引用类型)
2).如果找不到，就去找一个全局函数：operator<<(ostream &os,a的常引用类型)
3).如果再找不到就报错

//ostream是C++自定义的类，内部不能修改。所以开发者只能将cout<<重载为全局函数
//并且将该函数声明为a对应类的友元

3.单目运算符的重载

  假设编译器对单目运算符(#)的处理

#对象 ------ 去成员函数中找一个operator#()一个函数
             如果没有，就去全局函数中找operator#(对象)
             也没有就报错
对象# ------ 去成员函数中找一个operator#(int)一个函数
             如果没有，就去全局函数中找operator#(对象,int)
             也没有就报错   

实验程序

#include <iostream>
#include <cstring>

using namespace std;

class A{
public:
    explicit A(int num1, int num2 , const char* str1)
    {
        this->num1 = num1;
        this->num2 = num2;
        if(str1 != NULL)
        {
            this->str1 = new char[strlen(str1) + 1];
            strcpy(this->str1, str1);
        }
    }
    ~A()
    {
        if(this->str1 != NULL)
            delete[] this->str1;
    }
    void operator=(A& a)
    {
        this->num1 = a.num1;
        this->num2 = a.num2;
        if(a.str1 != NULL)
        {
            if(this->str1 != NULL)
            {
                delete[] this->str1;      
            }
            this->str1 = new char[strlen(a.str1) + 1];
            strcpy(this->str1, a.str1);          
        }
    }
    A& operator++()
    {
        this->num1++;
        this->num2++;
        return *this;
    }
    A operator++(int)
    {
        A tmp(this->num1, this->num2, "xxx");
        this->num1++;
        this->num2++;
        return tmp;
    }

friend ostream&  operator<<(ostream& _cout, const A& a);
friend istream&  operator>>(istream& _cin,  A& a);
private:
    int num1;
    int num2;
    char* str1;
};

ostream& operator<<(ostream& _cout,const A& a)
{
    return _cout<<a.str1<<":"<<"num1:"<<a.num1<<" num2:"<<a.num2<<endl;
}

istream& operator>>(istream& _cin,  A& a)
{
   return _cin>>a.num1>>a.num2;
}

int main()
{
    //创建两个对象进行初始化
    A a1(0, 0, "xxx");
    A a2(0, 0, "xxx");
    //输入运算符的重载
    cin>>a1;
    //赋值运算符的重载
    a2 = a1;
    //输出运算符的重载
    cout<<a1<<a2;
    //自加运算符重载
    cout<<a2++;
    cout<<++a1;
}

输出结果：

特殊运算符的重载

1.数组对象

  当对象遇到[]运算符时，在成员函数中找一个operator[](int ...)函数，如果没有就报错。

2.强转和函数对象

1）强转重载
  当编译器遇到 (类型)对象 语法时，就会去对象对应类中寻找一个 operator 类型() 的成员函数，找不到报错；
2）函数对象
  当编译器遇到 对象(实参) 语法时，就会去对象对应类中寻找一个 operator()(参数) 的成员函数，找不到报错。

#include <iostream>
#include <cstring>

using namespace std;

class myarray{
public:
    myarray(int size=10):size(size)
    {
        this->pdata = new int[size];
        memset(this->pdata, 0, size*sizeof(int));
    }
    ~myarray()
    {
        delete[] this->pdata;
    }
    //重写拷贝构造
    myarray(const myarray &arr)
    {
        this->size = arr.size;
        //申请空间
        this->pdata = new int[this->size];
        //将内容拷贝过来
        for(int i=0;i<arr.size;i++){
            this->pdata[i] = arr.pdata[i];
        }
    }
    myarray& operator=(const myarray& arr)
    {
        //防止自赋值
        if(this==&arr)
            return *this;

        //先释放旧空间
        delete[] this->pdata;
        this->size = arr.size;
        this->pdata = new int[this->size];
        for(int i=0; i<arr.size; i++)
        {
            this->pdata[i] = arr.pdata[i];
        }
        return *this;
    }
    //重载[]运算    
    int& operator[](int n)
    {
        if(n>=0 && (n < this->size))
            return this->pdata[n];
    }
    //重载（强转）：求首元素的值    
    operator int()
    {
        return this->pdata[0];
    }
    //重载():函数对象，用来求数组的和
    int operator()(const myarray& arr)
    {
        int sum = 0;
        for(int i = 0; i<arr.size; i++)
            sum +=arr.pdata[i];
        return sum;
    }
friend  ostream& operator<<(ostream& os, const myarray& arr);
        
private:
    int *pdata;
    int size;
};

ostream& operator<<(ostream& os, const myarray& arr)
{
    for(int i=0; i<arr.size-1; i++)
        os<<arr.pdata[i]<<",";

    return os<<arr.pdata[arr.size-1];
}

int main()
{
    myarray arr1(15);
    myarray arr2;

    arr2 = arr1;

    cout<<arr1<<endl;
    arr1[5] = 99;
    cout<<arr1[5]<<endl;
    cout<<arr1<<endl;
    cout<<arr2<<endl;

    arr2[0] = 100;
    arr2[1] = 1;
    arr2[2] = 2;
    arr2[3] = 3;
    arr2[4] = 4;
    arr2[5] = 5;
    arr2[6] = 6;

    cout<<(int)arr2<<endl;
    cout<<arr2<<endl;
    cout<<arr1(arr2)<<endl;

    return 0;
}

3.指针对象

  当编译器遇到 对象-> 语法时，就会去对象对应类中寻找一个 operator->() 的成员函数，找不到报错;
  当编译器遇到 对象 语法时，就会去对象对应类中寻 operator() 的成员函数，找不到报错，使用指针对象通常是为了管理其他对象的指针。

#include <iostream>

using namespace std;

class A{
public:
    A(){cout<<"A()"<<endl;}
    ~A(){cout<<"~A()"<<endl;}
    void show()
    {
        cout<<"show"<<endl;
    }
};

class myauto_ptr{
public:
    myauto_ptr(A *p=NULL):a_ptr(p)
    {
        cout<<"myauto_ptr()"<<endl;
    }
    ~myauto_ptr()
    {
        cout<<"~myauto_ptr()"<<endl;
        delete a_ptr;
    }
    A *operator->()
    {
        return this->a_ptr;//返回A类对象的地址，需要用->进行访问
    }
    A& operator*()
    {
        return *this->a_ptr; //返回A类对象本身，放回的值可以用.进行访问
    }
private:
    //要管理的指针
    A *a_ptr;
};

int main()
{
    A *a1 = new A;
    myauto_ptr p1(a1);
    p1->show();
    (*p1).show();
}