运算符重载

2020-12-23

C++运算符重载的实质：

运算符重载的实质就是函数重载或函数多态。运算符重载是一种形式的C++多态。运算符相当于一种函数。运算符重载的形式是：

<返回类型> operator<运算符>（<参数列表>）
{
 函数操作
}

运算符重载的规则：

重载后的运算符必须至少有一个操作数是用户定义的类型。
使用运算符不能违反运算符原来的句法法则
不能创建新的运算符。
并不是所有的运算符都可以重载，C++中不能重载的运算符有以下几种：

域解析符(::)；

成员访问符（.）；

成员指针访问符（.*）;

三元条件运算符（? :）；

sizeof 运算符和typeid运算符。

const_cast: 强制类型转换符；

dynamic_cast: 强制类型转换符；

reinterpret_cas：强制类型转换符；

static_cast : 强制类型转换符。

其余的运算符对于C++都是可以重载的。但是以下几种运算符只能被作为成员函数重载即：

= ：赋值运算符

() : 函数调用运算符

[] : 下标运算符

->: 指针访问运算符

其余的与运算符可以通过成员或者非成员函数进行重载。

示例代码：

Complex.h

#ifndef COMPLEX_H_
#define COMPLEX_H_
#include <iostream>
class Complex {
 public:
  Complex();
  Complex(double real, double image);
  virtual ~Complex();

  Complex& operator=(const Complex& rhs);   // 赋值运算符
  Complex operator+(const Complex& rhs);    // 加法运算符
  Complex operator-(const Complex& rhs);    // 减法运算符
  Complex operator++(int);                  // 后置++
  Complex& operator++();                    // 前置++
  Complex operator--(int);                  // 后置--
  Complex& operator--();                    // 前置--
  Complex operator*(const Complex& rhs);    // 乘法运算符
  Complex operator/(const Complex& rhs);    //除法运算符
  Complex& operator*=(const Complex& rhs);  // *= 运算
  Complex& operator/=(const Complex& rhs);  // /= 运算
  Complex& operator+=(const Complex& rhs);  // += 运算
  Complex& operator-=(const Complex& rhs);  // -= 运算
  friend std::ostream& operator<<(std::ostream& os, const Complex& rhs);
  friend std::istream& operator>>(std::istream& in, Complex& rhs);
  friend bool operator>(const Complex& lhs, const Complex& rhs);
  friend bool operator<(const Complex& lhs, const Complex& rhs);
  friend bool operator==(const Complex& lhs, const Complex& rhs);
  friend bool operator!=(const Complex& lhs, const Complex& rhs);

 private:
  double m_real;   // real partition
  double m_image;  // image partition
};
#endif

Complex.cpp:

#include "Complex.h"

#include <exception>
#include <stdexcept>
Complex::Complex() : m_real(0), m_image(0) {}
Complex::Complex(double real, double image) : m_real(real), m_image(image) {}
Complex::~Complex() {
  m_real = 0;
  m_image = 0;
}
Complex& Complex::operator=(const Complex& rhs) {
  m_real = rhs.m_real;
  m_image = rhs.m_image;
  return (*this);
}
Complex Complex::operator+(const Complex& rhs) {
  Complex temp;
  temp.m_real = this->m_real + rhs.m_real;
  temp.m_image = this->m_image + rhs.m_image;
  return temp;
}
Complex Complex::operator-(const Complex& rhs) {
  Complex temp;
  temp.m_real = this->m_real - rhs.m_real;
  temp.m_image = this->m_image - rhs.m_image;
  return temp;
}
Complex Complex::operator++(int) {
  Complex temp = *this;
  this->m_real++;
  this->m_image++;
  return temp;
}
Complex& Complex::operator++() {
  this->m_real ++;
  this->m_image ++;
  return (*this);
}
Complex Complex::operator--(int) {
  Complex temp = *this;
  this->m_real--;
  this->m_image--;
  return temp;
}
Complex& Complex::operator--() {
  this->m_real --;
  this->m_image --;
  return (*this);
}
Complex Complex::operator*(const Complex& rhs) {
  Complex temp;
  temp.m_real = m_real * rhs.m_real - m_image * rhs.m_image;
  temp.m_image = m_real * rhs.m_image + m_image * rhs.m_real;
  return temp;
}  // 乘法运算符
Complex Complex::operator/(const Complex& rhs) {
  double div = rhs.m_real * rhs.m_real + rhs.m_image * rhs.m_image;
  if (div == 0) {
    throw std::logic_error("除数不能为0");
  }
  Complex temp = *this * Complex(rhs.m_real,-rhs.m_image);
  temp.m_real = this->m_real / div;
  temp.m_image = this->m_image / div;
  return temp;
}
Complex& Complex::operator*=(const Complex& rhs) {
  *this = *this * rhs;
  return *this;
}  // *= 运算
 Complex& Complex::operator/=(const Complex& rhs) {
  *this = *this / rhs;
  return *this;
}  // /= 运算
 Complex& Complex::operator+=(const Complex& rhs) {
  *this = *this + rhs;
  return *this;
}  // += 运算
Complex& Complex::operator-=(const Complex& rhs) {
  *this = *this - rhs;
  return *this;
}  // -= 运算
std::ostream& operator<<(std::ostream& os, const Complex& rhs) {
  os << "real = " << rhs.m_real << std::endl;
  os << "image = " << rhs.m_image << std::endl;
  return os;
}
std::istream& operator>>(std::istream& in, Complex& rhs) {
  std::cout << "请输入实部:";
  in >> rhs.m_real;
  std::cout << std::endl;
  std::cout << "请输入虚部:";
  in >> rhs.m_image;
  return in;
}
bool operator>(const Complex& lhs, const Complex& rhs) {
  return lhs.m_real > rhs.m_real && lhs.m_image > rhs.m_image;
}
bool operator<(const Complex& lhs, const Complex& rhs) {
  return lhs.m_real < rhs.m_real && lhs.m_image < rhs.m_image;
}
bool operator==(const Complex& lhs, const Complex& rhs) {
  return lhs.m_real == rhs.m_real && lhs.m_image == rhs.m_image;
}
bool operator!=(const Complex& lhs, const Complex& rhs) {
  return lhs.m_real != rhs.m_real || lhs.m_image != rhs.m_image;
}

main.cpp:

#include "Complex.h"
int main(int argc, char const *argv[]) {
  Complex c;
  Complex a(3.0, 4.0);
  Complex b(5.0, 6.0);
  std::cout << a << std::endl;
  std::cout << b << std::endl;
  std::cout << c << std::endl;

  c = a * b;
  std::cout << c << std::endl;
  c = a + b;
  std::cout << c << std::endl;
  c = a / b;
  std::cout << c << std::endl;

  std::cout << std::boolalpha << (a == b) << std::endl;
  a += b;
  std::cout << a << std::endl;

  a++;
  std::cout << a << std::endl;
  b--;
  std::cout << b << std::endl;
  return 0;
}