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

最新推荐文章于 2012-09-17 19:53:08 发布

tjcbq

最新推荐文章于 2012-09-17 19:53:08 发布

阅读量484

点赞数

CC 4.0 BY-SA版权

分类专栏：读书笔记文章标签： integer byte class function

本文链接：https://blog.youkuaiyun.com/tjcbq/article/details/7980801

读书笔记专栏收录该内容

8 篇文章

订阅专栏

本文介绍了C++中操作符重载的两种方式——全局函数和成员函数。通过Integer类举例，详细阐述了全局函数重载（包括前置和后置的情况）以及成员函数重载的不同实现方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

12.1 重载方式

操作符有两种重载方式：成员函数和全局函数。以Integer类来说明这两种方式。

12.1.1 全局函数方式

class Integer { 
  long i; 
  Integer* This() { return this; } 
public: 
  Integer(long ll = 0) : i(ll) {} 
  // No side effects takes const& argument: 
  friend const Integer& 
    operator+(const Integer& a); 
}

const Integer& operator+(const Integer& a) { 
  cout << "+Integer\n"; 
  return a; // Unary + has no effect 
}

12.1.2 成员函数方式

class Integer { 
  long i; 
  Integer* This() { return this; } 
public: 
  Integer(long ll = 0) : i(ll) {} 
  // No side effects takes const& argument: 
  const Integer& operator+() const{ 
		cout << "+Integer\n"; 
		return *this;
  }; 
}

12.2 一元操作符(Unary operators)

12.2.1 全局函数重载方式

class Integer { 
  long i; 
  Integer* This() { return this; } 
public: 
  Integer(long ll = 0) : i(ll) {} 
  // No side effects takes const& argument: 
  friend const Integer& operator+(const Integer& a); 
  friend const Integer  operator-(const Integer& a); 
  friend const Integer  operator~(const Integer& a); 
  friend Integer* operator&(Integer& a); 
  friend int      operator!(const Integer& a); 
  // Side effects have non-const& argument: 
  // Prefix: 
  friend const Integer&  operator++(Integer&  a); 
   // Postfix: 
   friend const Integer  operator++(Integer&  a, int); 
   // Prefix: 
   friend const Integer& operator--(Integer&  a); 
   // Postfix: 
   friend const Integer  operator--(Integer&  a, int); 
}; 
// Global operators: 
const Integer& operator+(const Integer& a) { 
   cout << "+Integer\n"; 
   return a; // Unary + has no effect 
} 

const Integer operator-(const Integer& a) { 
   cout << "-Integer\n"; 
   return Integer(-a.i); 
} 

const Integer operator~(const Integer& a) { 
   cout << "~Integer\n"; 
   return Integer(~a.i); 
} 

Integer* operator&(Integer& a) { 
   cout << "&Integer\n"; 
   return a.This(); // &a is recursive! 
} 

int operator!(const Integer& a) { 
   cout << "!Integer\n"; 
   return !a.i; 
} 

// Prefix; return incremented value 
const Integer& operator++(Integer& a) { 
   cout << "++Integer\n"; 
   a.i++; 
   return a; 
} 

const Integer operator++(Integer& a, int) { 
  cout << "Integer++\n"; 
  Integer before(a.i); 
  a.i++; 
  return before; 
} 

// Prefix; return decremented value 
const Integer& operator--(Integer& a) { 
  cout << "--Integer\n"; 
  a.i--; 
  return a; 
} 

// Postfix; return the value before decrement: 
const Integer operator--(Integer& a, int) { 
  cout << "Integer--\n"; 
  Integer before(a.i); 
  a.i--; 
  return before; 
}

12.2.2 成员函数重载方式

class Byte { 
  unsigned char b; 
public: 
  Byte(unsigned char bb = 0) : b(bb) {} 
  // No side effects: const member function: 
  const Byte& operator+() const { 
    cout << "+Byte\n"; 
    return *this; 
  } 
  const Byte operator-() const { 
    cout << "-Byte\n"; 
    return Byte(-b); 
  } 
  const Byte operator~() const { 
    cout << "~Byte\n"; 
    return Byte(~b); 
   } 
   Byte operator!() const { 
     cout << "!Byte\n"; 
     return Byte(!b); 
   } 
   Byte* operator&() { 
     cout << "&Byte\n"; 
     return this; 
   } 
   // Side effects: non-const member function: 
   const Byte& operator++() { // Prefix 
     cout << "++Byte\n"; 
     b++; 
     return *this; 
   } 
   const Byte operator++(int) { // Postfix 
     cout << "Byte++\n"; 
     Byte before(b); 
     b++; 
     return before; 
   } 
   const Byte& operator--() { // Prefix 
     cout << "--Byte\n"; 
     --b; 
     return *this; 
   } 
   const Byte operator--(int) { // Postfix 
     cout << "Byte--\n"; 
     Byte before(b); 
     --b; 
     return before; 
   }

12.2.3关于++和--的前置和后置使用

为了区别前置和后置这两种情况，对于后者重载函数，在声明时多加一个int参数，这个参数只是为了和前置版本进行区别，在实际的函数调用中不使用。