• 重载操作符能使得一个自定义类型可以像基本类型一样支持加减乘除等多种操作

引例

引入struct/class可以允许用户自己定义数据类型，但是自定义类型相比基本类型还是有些不足。

自定义类型不能进行加减乘除

//用fraction表示分数
class Fraction
{
public:
    Fraction():num(1),den(2)
    {
        
    }
    Fraction(int n,int d):num(n),den(d)
    {
        
    }
    int num;//分子
    int den;//分母
};

Fraction fa(2,3);//表示2/3
Fraction fb;     //表示1/2
//Fraction fc = fa+fb;  错误！相加没有意义

算数操作符

包括+、-、*、/、%

• 类操作符：操作符函数是类的成员函数

  class Fraction
  {
  public:
      //重载加号操作符
      Fraction operator + (const Fraction& other)  //operator + 是固定不变的，这里为两个分数相加
      {
          Fraction result;
          result.den = den*other.den; //分母相乘
          result.num = num*other.den + other.num*den;  //分子交叉相乘
          return result;
      }
      int num;
      int den;
  };
  

• 全局操作符：需要把操作符函数声明为类的朋友

  class Fraction
  {
      friend Fraction operator + (const Fraction& a,const Fraction& b);
  public:
      int num;
      int den;
  };
  
  Fraction operator + (const Fraction& a,const Fraction& b)
  {
      Fraction result;
      result.den = a.den*b.den; //分母相乘
        result.num = a.num*b.den + b.num*a.den;  //分子交叉相乘
        return result;
  }
  

分数与整数相加

class Fraction
{
public:
    //Fraction+int
    Fraction operator + (int n)
    {
        Fraction result;
        result.num = num + den*n;  //分母不变，分子变化
        return result;
    }
    int num;
    int den;
};

加法的互换性

上述类操作符写法只支持了Fraction+int，但互换int+Fraction就不支持了，为此应该考虑使用全局操作符来实现

friend Fraction operator + (int a,const Fraction& b)

赋值操作符=

适用类型：①需要深拷贝时，②需要不同的数据类型来赋值时，例如fa=4

赋以不同的类型

注意返回值是this*

class Fraction
{
public:
    //Fraction = Fraction
    Fraction& operator = (const Fraction& other)
    {
        this->num = other.num;
        this->den = other.den;
        return *this;
    }
    //Fraction = int
    Fraction& operator = (int n)
    {
        this->num = n;
        this->den = 1;
        return *this;
    }
};

需要深拷贝时

p277

相关问题

1. 等号的传导性

   返回值必须为return *this

2. 等号的自反性

   要提前判断是否为赋值给自己

   if(this == &other)return *this //避免赋值给自己
   

关系操作符==

和算数运算符写法差不多

class Fraction
{
public:
    bool operator == (const Fraction& other)
    {
        if(num*other.den == den*other.num)
        {
            return true;
        }
        return false;
    }
    ...
};

class Text
{
public:
    bool operator == (const char* str)
    {
        if(strcmp(m_buf,str)==0)
        {
            return true;
        }
    }
    return false;
    ...
};

类型转换操作符（）

Fraction fa(2,3);
double value = (double)fa;//错误！但可以通过重载操作符实现

class Fraction
{
public:
    operator double()   //类型转换操作符比较怪异，不能写像上面其他类型的一样写double operator ()，而应该这么写
    {
        return (double)num/den;
    }
    ...
};

输入输出操作符>>、<<

定义类Logger

Logger lg;
lg << 1;
lg << 1 << "," << 2.0 << ".";   //输出1，2.0.

实现方式

class Logger
{
public:
    Logger& operator << (int value)
    {
        printf("%d",value);
        return *this;
    }
    Logger& operator << (double value)
    {
        ...
    }
    Logger& operator << (const char* value)
    {
        ...
    }
    ...
}