• C++中几乎可以重载全部的运算符，而且只能重载C++中已经有的。不能重载的运算符：“. ”、“.*”、“::”、“？.”；
  • 重载之后运算符的优先级和结合性都不会改变；
  • 运算符重载是针对新类型的实际需要，对原有运算符进行适当的改造；
  • 例如：使用复数类的对象可以用“+”运算符实现加法，是时钟类对象可以用“++”运算符实现时间增加1秒。

1. 运算符重载为成员函数

1.1 双目运算符重载为类的成员函数

重载为类成员的运算符函数定义形式：

函数类型  operator 运算符（形参）
{
   ...
}
参数个数=原操作数个数-1  （后置++,--除外）

双目运算符重载规则：

  • 如果要实现重载B为类成员函数，使之能够实现表达式oprd1 B
    oprd2,其中oprd1为A类对象，则B应被重载为A类的成员函数，形参类型应该为oprd2所属的类型。
  • 经重载后，表达式oprd1 B oprd2 相当于oprd1.operator B(oprd2)

例：复数类加减法运算符重载为成员函数：

/*
//要求：将+、-重载为复数类的成员函数
//规则：实部和虚部分别相加减
//操作数：两个操作数都是复数类的对象
*/
 
#include<iostream>
using namespace std;
 
class Complex{
public:
  Complex(double r = 0.0, double i = 0.0)
  {
    real = r;
    image = i;
  }
  //运算符+重载成员函数
  Complex operator +(const Complex &c2) const;
  //运算符+重载成员函数
  Complex operator -(const Complex &c2) const;
  void display() const;    //输出复数
private:
  double real;
  double image;
};
 
Complex Complex::operator+(const Complex &c2) const
{
  //创建一个临时无名对象作为返回值
  return Complex(real + c2.real, image + c2.image);
}
 
Complex Complex::operator-(const Complex &c2) const
{
  //创建一个临时无名对象作为返回值
  return Complex(real - c2.real, image - c2.image);
}
 
void Complex::display() const
{
  cout << "(" << real << "," << image << ")" << endl;
}
 
int main()
{
  Complex c1(5, 4), c2(2, 10), c3;
  cout << "c1 = ";
  c1.display();
  cout << "c2 = ";
  c2.display();
  c3 = c1 - c2;
  cout << "c3 = c1 - c2 = ";
  c3.display();
  c3 = c1 + c2;
  cout << "c3 = c1 + c2 = ";
  c3.display();
 
  system("pause");
  return 0;
}

1.2 单目运算符重载为成员函数

前置单目运算符重载规则：

  • 如果要重载U为类成员函数，使之能够实现表达式U oprd，其中oprd为A类对象，则U应被重载为A类的成员函数，无形参；
  • 经重载后，表达式U oprd相当于oprd.operator U()；

后置单目运算符++和--重载规则：

  • 如果要重载++或者--为类成员函数，使之能够实现表达式oprd++或者oprd--，其中oprd为A类对象，则++或--应被重载为A类的成员函数，且具有一个int类型形参；
  • 经重载后，表达式oprd++相当于oprd.operator ++(0)

例：重载前置++和后置++为时钟类成员函数

  • 前置单目运算符，重载函数没有形参
  • 后置++运算符，重载函数需要一个int形参
  • 操作数是时钟类的对象
  • 实现时间增加1秒钟
#include<iostream>
using namespace std;
 
class Clock{
public:
  Clock(int hour = 0, int minute = 0, int second = 0);
  void showTime() const;
  //前置单目运算符重载
  Clock & operator ++();
  //后置单目运算符重载
  Clock operator ++(int);
private:
  int hour, minute, second;
};
 
Clock::Clock(int hour, int minute, int second)
{
  if (0 <= hour&&hour < 24 && 0 <= minute&&minute < 60 && 0 <= second&&second < 60)
  {
    this->hour = hour;
    this->minute = minute;
    this->second = second;
  }
  else
    cout << "Time error!" << endl;
}
 
void Clock::showTime() const
{
  cout << hour << ":" << minute << ":" << second << endl;
}
 
Clock &Clock::operator++()
{
  second++;
  if (second >= 60)
  {
    second -= 60;
    minute++;
    if (minute >= 60)
    {
      minute -= 60;
      hour = (hour + 1) % 24;
    }
  }
  return *this;
}
 
Clock Clock::operator++(int)
{
  //注意形参表中的整型参数
  Clock old = *this;
  ++(*this);   //调用前置"++"运算符
  return old;
}
 
int main()
{
  Clock myClock(23, 59, 59);
  cout << "First time output:";
  myClock.showTime();
  cout << "Show myClock++: ";
  (myClock++).showTime();
  cout << "Show ++myClock: ";
  (++myClock).showTime();
 
  system("pause");
  return 0;
}

2. 运算符重载为非成员函数

运算符要重载为非成员函数的规则：

  • 函数的形参代表依自左向右次序排列的各操作数。
  • 重载为非成员函数时，参数个数=原操作数个数（后置++，--除外），至少应该有一个自定义类型的参数。
  • 后置单目运算符++和--的重载函数，形参列表重要增加一个int，但不必写形参名。
  • 如果在运算符的重载函数中需要操作某类对象的私有成员，可以将此函数声明为该类的友元。

运算符重载为非成员函数的规则

  • 双目运算符B重载后，表达式 oprd1 B oprd2 等同于operator B(oprd1,oprd2)
  • 前置单目运算符B重载后，表达式B oprd等同于operator B(oprd)
  • 后置单目运算符++和--重载后，表达式oprd B等同于operator B(oprd,0)

例：重载Complex的加减法和“<<”运算符为非成员函数

（1）将+、-（双目）重载为非成员函数，并将其声明为复数类的友元，两个操作数都是复数类的常引用。

（2）将<<（双目）重载为非成员函数，并将其声明为复数类的友元，它的左操作数是std::ostream引用，右操作数为复数类的常引用，返回std::ostream引用，用以支持下面形式的输出：

cout<<a<<b;

该输出调用的是：

operator<<(operator <<(cout,a),b);

#include<iostream>
using namespace std;
 
class Complex
{
public:
  Complex(double r = 0.0, double i = 0.0)
  {
    real = r;
    image = i;
  }
  friend Complex operator+(const Complex &c1, const Complex &c2);
  friend Complex operator-(const Complex &c1, const Complex &c2);
  friend ostream & operator<<(ostream &out, const Complex &c);
private:
  double real;
  double image;
};
Complex operator+(const Complex &c1, const Complex &c2)
{
  return Complex(c1.real + c2.real, c1.image + c2.image);
}
Complex operator-(const Complex &c1, const Complex &c2)
{
  return Complex(c1.real - c2.real, c1.image - c2.image);
}
ostream & operator<<(ostream &out, const Complex &c)
{
  out << "(" << c.real << "," << c.image << ")";
  return out;
}
 
int main()
{
  Complex c1(5, 4), c2(2, 10), c3;
  cout << "c1 = " << c1 << endl;
  cout << "c2 = " << c2 << endl;
  c3 = c1 - c2;
  cout << "c3 = c1 - c2 = " << c3 << endl;
  c3 = c1 + c2;
  cout << "c3 = c1 + c2 = " << c3 << endl;
  system("pause");
  return 0;
}

C++ 运算符重载_成员函数