Think_in_CPP第十二章 操作符重载(2)

12.3 二元运算符(Binary operators)

12.3.1 全局函数方式

class Integer { 
  long i; 
public: 
  Integer(long ll = 0) : i(ll) {} 
  // Operators that create new, modified value: 
  friend const Integer operator+(const Integer& left, const Integer& right); 
  friend const Integer operator-(const Integer& left, const Integer& right); 
  friend const Integer operator*(const Integer& left, const Integer& right); 
  friend const Integer operator/(const Integer& left, const Integer& right); 
  friend const Integer operator%(const Integer& left, const Integer& right); 
  friend const Integer operator^(const Integer& left, const Integer& right); 
  friend const Integer operator&(const Integer& left, const Integer& right); 
  friend const Integer operator|(const Integer& left, const Integer& right); 
  friend const Integer operator<<(const Integer& left, const Integer& right); 
  friend const Integer operator>>(const Integer& left, const Integer& right); 
// Assignments modify & return lvalue: 
  friend Integer& operator+=(Integer& left, const Integer& right); 
  friend Integer& operator-=(Integer& left, const Integer& right); 
  friend Integer& operator*=(Integer& left, const Integer& right); 
  friend Integer& operator/=(Integer& left, const Integer& right); 
  friend Integer& operator%=(Integer& left, const Integer& right); 
  friend Integer& operator^=(Integer& left, const Integer& right); 
  friend Integer& operator&=(Integer& left, const Integer& right); 
  friend Integer& operator|=(Integer& left, const Integer& right); 
  friend Integer& operator>>=(Integer& left, const Integer& right); 
  friend Integer& operator<<=(Integer& left, const Integer& right); 
// Conditional operators return true/false: 
  friend int operator==(const Integer& left, const Integer& right); 
  friend int operator!=(const Integer& left, const Integer& right); 
  friend int operator<(const Integer& left, const Integer& right); 
  friend int operator>(const Integer& left, const Integer& right); 
  friend int operator<=(const Integer& left, const Integer& right); 
  friend int operator>=(const Integer& left, const Integer& right); 
  friend int operator&&(const Integer& left, const Integer& right); 
  friend int operator||(const Integer& left, const Integer& right); 
}; 

const Integer 
  operator+(const Integer& left, 
            const Integer& right) { 
  return Integer(left.i + right.i); 
} 
const Integer 
  operator-(const Integer& left, 
            const Integer& right) { 
  return Integer(left.i - right.i); 
} 
const Integer 
  operator*(const Integer& left, 
            const Integer& right) { 
  return Integer(left.i * right.i); 
} 
const Integer 
  operator/(const Integer& left, 
            const Integer& right) { 
  require(right.i != 0, "divide by zero"); 
  return Integer(left.i / right.i); 
} 
const Integer 
  operator%(const Integer& left, 
            const Integer& right) { 
  require(right.i != 0, "modulo by zero"); 
  return Integer(left.i % right.i); 
} 
const Integer 
  operator^(const Integer& left, 
            const Integer& right) { 
  return Integer(left.i ^ right.i); 
} 
const Integer 
  operator&(const Integer& left, 
            const Integer& right) { 
  return Integer(left.i & right.i); 
} 
const Integer 
  operator|(const Integer& left, 
            const Integer& right) { 
  return Integer(left.i | right.i); 
} 
const Integer 
  operator<<(const Integer& left, 
              const Integer& right) { 
  return Integer(left.i << right.i); 
} 
const Integer 
  operator>>(const Integer& left, 
              const Integer& right) { 
  return Integer(left.i >> right.i); 
} 
// Assignments modify & return lvalue: 
Integer& operator+=(Integer& left, 
                     const Integer& right) { 
   if(&left == &right) {/* self-assignment */} 
   left.i += right.i; 
   return left; 
} 
Integer& operator-=(Integer& left, 
                     const Integer& right) { 
   if(&left == &right) {/* self-assignment */} 
   left.i -= right.i; 
   return left; 
} 
Integer& operator*=(Integer& left, 
                     const Integer& right) { 
   if(&left == &right) {/* self-assignment */} 
   left.i *= right.i; 
   return left; 
} 
Integer& operator/=(Integer& left, 
                    const Integer& right) { 
   require(right.i != 0, "divide by zero"); 
   if(&left == &right) {/* self-assignment */} 
   left.i /= right.i; 
   return left; 
} 
Integer& operator%=(Integer& left, 
                    const Integer& right) { 
   require(right.i != 0, "modulo by zero"); 
   if(&left == &right) {/* self-assignment */} 
   left.i %= right.i; 
   return left; 
} 
Integer& operator^=(Integer& left, 
                    const Integer& right) { 
   if(&left == &right) {/* self-assignment */} 
   left.i ^= right.i; 
   return left; 
} 
Integer& operator&=(Integer& left, 
                    const Integer& right) { 
   if(&left == &right) {/* self-assignment */} 
   left.i &= right.i; 
   return left; 
} 
Integer& operator|=(Integer& left, 
                    const Integer& right) { 
   if(&left == &right) {/* self-assignment */} 
   left.i |= right.i; 
   return left; 
} 
Integer& operator>>=(Integer& left, 
                      const Integer& right) { 
   if(&left == &right) {/* self-assignment */} 
   left.i >>= right.i; 
   return left; 
} 
Integer& operator<<=(Integer& left, 
                      const Integer& right) { 
   if(&left == &right) {/* self-assignment */} 
   left.i <<= right.i; 
   return left; 
} 
// Conditional operators return true/false: 
int operator==(const Integer& left, 
                const Integer& right) { 
    return left.i == right.i; 
} 
int operator!=(const Integer& left, 
                const Integer& right) { 
    return left.i != right.i; 
} 
int operator<(const Integer& left, 
              const Integer& right) { 
    return left.i < right.i; 
} 
int operator>(const Integer& left, 
              const Integer& right) { 
    return left.i > right.i; 
} 
int operator<=(const Integer& left, 
                const Integer& right) { 
    return left.i <= right.i; 
} 
int operator>=(const Integer& left, 
                const Integer& right) { 
    return left.i >= right.i; 
} 
int operator&&(const Integer& left, 
                const Integer& right) { 
    return left.i && right.i; 
} 
int operator||(const Integer& left, 
                const Integer& right) { 
    return left.i || right.i; 
} 

12.3.2 成员函数方式

class Byte { 
  unsigned char b; 
public: 
  Byte(unsigned char bb = 0) : b(bb) {} 
  // No side effects: const member function: 
  const Byte 
    operator+(const Byte& right) const { 
    return Byte(b + right.b); 
  } 
const Byte 
  operator-(const Byte& right) const { 
  return Byte(b - right.b); 
} 
const Byte 
  operator*(const Byte& right) const { 
  return Byte(b * right.b); 
} 
const Byte 
  operator/(const Byte& right) const { 
  require(right.b != 0, "divide by zero"); 
  return Byte(b / right.b); 
} 
const Byte 
  operator%(const Byte& right) const { 
  require(right.b != 0, "modulo by zero"); 
  return Byte(b % right.b); 
} 
const Byte 
  operator^(const Byte& right) const { 
  return Byte(b ^ right.b); 
} 
const Byte 
  operator&(const Byte& right) const { 
  return Byte(b & right.b); 
} 
const Byte 
  operator|(const Byte& right) const { 
  return Byte(b | right.b); 
} 
const Byte 
  operator<<(const Byte& right) const { 
  return Byte(b << right.b); 
} 
const Byte 
  operator>>(const Byte& right) const { 
  return Byte(b >> right.b); 
} 
// Assignments modify & return lvalue. 
// operator= can only be a member function: 
Byte& operator=(const Byte& right) { 
  // Handle self-assignment: 
  if(this == &right) return *this; 
  b = right.b; 
  return *this; 
} 
Byte& operator+=(const Byte& right) { 
  if(this == &right) {/* self-assignment */} 
  b += right.b; 
  return *this; 
} 
Byte& operator-=(const Byte& right) { 
  if(this == &right) {/* self-assignment */} 
  b -= right.b; 
  return *this; 
} 
Byte& operator*=(const Byte& right) { 
  if(this == &right) {/* self-assignment */} 
  b *= right.b; 
  return *this; 
} 
Byte& operator/=(const Byte& right) { 
  require(right.b != 0, "divide by zero"); 
  if(this == &right) {/* self-assignment */} 
  b /= right.b; 
  return *this; 
} 
Byte& operator%=(const Byte& right) { 
  require(right.b != 0, "modulo by zero"); 
  if(this == &right) {/* self-assignment */} 
  b %= right.b; 
  return *this; 
} 
Byte& operator^=(const Byte& right) { 
  if(this == &right) {/* self-assignment */} 
  b ^= right.b; 
  return *this; 
} 
Byte& operator&=(const Byte& right) { 
  if(this == &right) {/* self-assignment */} 
  b &= right.b; 
  return *this; 
} 
Byte& operator|=(const Byte& right) { 
  if(this == &right) {/* self-assignment */} 
  b |= right.b; 
  return *this; 
} 
Byte& operator>>=(const Byte& right) { 
  if(this == &right) {/* self-assignment */} 
     b >>= right.b; 
     return *this; 
   } 
   Byte& operator<<=(const Byte& right) { 
     if(this == &right) {/* self-assignment */} 
     b <<= right.b; 
     return *this; 
   } 
   // Conditional operators return true/false: 
   int operator==(const Byte& right) const { 
       return b == right.b; 
   } 
   int operator!=(const Byte& right) const { 
       return b != right.b; 
   } 
   int operator<(const Byte& right) const { 
       return b < right.b; 
   } 
   int operator>(const Byte& right) const { 
       return b > right.b; 
   } 
   int operator<=(const Byte& right) const { 
       return b <= right.b; 
   } 
   int operator>=(const Byte& right) const { 
       return b >= right.b; 
   } 
   int operator&&(const Byte& right) const { 
       return b && right.b; 
   } 
   int operator||(const Byte& right) const { 
       return b || right.b; 
   } 
   // Write the contents to an ostream: 
   void print(std::ostream& os) const { 
     os << "0x" << std::hex << int(b) << std::dec; 
   } 
}; 

12.3.3 要点备忘

1.operator=只允许成员函数方式。
2.所有的赋值操作符都要检查是否自赋值（self-assignment），但是在有的情况下是不需要的，比如A+=A。最需要检查此项的是operator=，尽管在某些情况下不检查也能得到想要的结果，但是建议在重载operator=的时候，检查是否是自赋值。