C++操作符重载实际操作方法解析

原文地址：http://developer.51cto.com/art/201002/182596.htm

我们为什么要使用C++操作符重载，又该如何正确的声明一个C++操作符重载呢？我们今天将会为大家详细介绍一下这两个方面的具体知识。

AD：

C++编程语言发展至今已经成为了开发领域中一个重要的应用语言。其中有很多比较高深的内容还值得我们在实践中去不断的探索。在这里我们就先从对C++操作符重载的应用方式的了解来进一步解读这一编程语言。

一、为什么使用C++操作符重载？

对于系统的所有操作符，一般情况下，只支持基本数据类型和标准库中提供的class，对于用户自己定义的class，如果想支持基本操作，比如比较大小，判断是否相等，等等，则需要用户自己来定义关于这个操作符的具体实现。比如，判断两个人是否一样大，我们默认的规则是按照其年龄来比较，所以，在设计person 这个class的时候，我们需要考虑操作符==，而且，根据刚才的分析，比较的依据应该是age。那么为什么叫重载呢？这是因为，在编译器实现的时候，已经为我们提供了这个操作符的基本数据类型实现版本，但是现在他的操作数变成了用户定义的数据类型class，所以，需要用户自己来提供该参数版本的实现。

二、如何声明一个C++操作符重载？

A:操作符重载实现为类成员函数

重载的操作符在类体中被声明，声明方式如同普通成员函数一样，只不过他的名字包含关键字operator，以及紧跟其后的一个c++预定义的操作符。可以用如下的方式来声明一个预定义的==操作符:

  1. class person{  
  2. private:  
  3. int age;  
  4.  public:  
  5.  person(int a){  
  6. this->aage=a;  
  7. }  
  8. inline bool operator ==(const person &ps) const;  
  9. }; 

C++操作符重载实现方式如下：

  1. inline bool person::operator==(const person &ps) const  
  2. { if (this->age==ps.age)  
  3.  return true;  
  4. return false;  
  5. } 

调用方式如下：

  1.  #include  
  2. using namespace std;  
  3. int main()  
  4. { person p1(10);  
  5. person p2(20);  
  6. if(p1==p2) cout<<”the age is equal!”<return 0;   
  7. } 

这里，因为operator ==是class person的一个成员函数，所以对象p1,p2都可以调用该函数，上面的if语句中，相当于p1调用函数==，把p2作为该函数的一个参数传递给该函数，从而实现了两个对象的比较。

考虑如下的if语句：

  1. if(10==p1) cout<<”the age is equal!”< 

是否回正确执行呢？

答案是不会的，因为只有左操作数是该类类型的对象的时，才会考虑作为类成员重载操作符。因为10不是person类型的对象，所以，不能调用classperson的操作符==。
考虑如下if语句：

  1. if(person(10)==person(11))  
  2.  cout<<"ok"< 

是否能够正确执行呢？答案是可以，因为操作符两边均是无名对象。重载的操作符并不要求两个操作数的类型一定相同。例如：我们可以为class person定义下标操作符，以表示该person和电话的对应关系：

#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <queue>
#include <vector>


using namespace std;  
class person  
{ private:  
    int tel;  
public:  
    int & operator[](string const & nm)   
    {  
        return tel;  
    }  
    int GetTel()  
    {  
        return tel;  
    }  
};  
int main()  
{  
    person p1;  
    p1["suo"]=110;  
    person p2;  
    p2["rose"]=120;
    cout<<p2.GetTel()<<endl;
        return 0;  
}

　　

对于重载为成员函数方式的操作符，隐式的this指针被作为该函数的第一个参数,来代表左操作数。

B:C++操作符重载实现为非类成员函数(全局函数)

对于全局重载操作符，代表左操作数的参数必须被显式指定。例如：

  1. #include  
  2. #include  
  3. using namespace std;  
  4. class person  
  5. {  
  6. public:  
  7.  int age;  
  8. public:  
  9. }; 

在类的外部，不能访问该类私有数据，所以，要把age设置为public

  1. bool operator==(person const &p1 ,person const & p2)  
  2. {  
  3.  if(p1.age==p2.age)  
  4.  return true;  
  5.  return false;  
  6. }  
  7. int main()  
  8. {  
  9. person rose;  
  10. person jack;  
  11. rose.age=18;  
  12. jack.age=23;  
  13. if(rose==jack)/*两个对象分别代表左右操作数*/   
  14. cout<<"ok"<return 0;  
  15. } 

C:如何决定把一个操作符重载为类成员函数还是全局名字空间的成员呢？

①如果一个重载操作符是类成员，那么只有当与他一起使用的左操作数是该类的对象时，该操作符才会被调用。如果该操作符的左操作数必须是其他的类型，则操作符必须被重载为全局名字空间的成员。

②C++要求赋值=，下标[]，调用()， 和成员指向-> 操作符必须被定义为类成员操作符。任何把这些操作符定义为名字空间成员的定义都会被标记为编译时刻错误。

③如果有一个操作数是类类型如string类的情形那么对于对称操作符比如等于操作符最好定义为全局名字空间成员。

D:操作符重载为友元函数方式

如果把C++操作符重载为友元函数方式，则在该函数的内部，可以直接访问授权类的私有数据成员，这是友元函数方式和全局名字空间方式的主要区别。

E:怎样判断一个非类成员的操作符应该是类的友元还是应该使用成员访问函数呢？一般来说，类的实现者应该尽量使得名字空间函数和访问类内部表示的操作符的数目最小化。如果已经提供了访问成员函数并且它们具有等同的效率，那么最好是使用这些成员函数。但是如果类的实现者决定不为该类的某些私有成员提供访问成员函数而且名字空间操作符需要引用这些私有成员才能完成，它们的操作那么就必须使用友元机制。例如：

  1. #include  
  2. #include  
  3. using namespace std;  
  4. class person{  
  5. public:   
  6.  int age;  
  7. public:  
  8. };　   
  9. bool operator==(person const &p1 ,person const & p2)  
  10. {  
  11. if(p1.age==p2.age) return true;  
  12. return false;  
  13. }  
  14. ostream operator<<(ostream &os,person const &p)  
  15. {  
  16. os<<"the person age is:"<return os;  
  17. }  
  18. int main()  
  19. {  
  20. person rose;  
  21. person jack;  
  22. rose.age=18;  
  23. jack.age=23;  
  24. cout</*call ostream operator<<(ostream &os,person const &p) */  
  25. cout<return 0;  
  26. } 

三、C++操作符重载的设计

①类的设计者不能声明一个没有预定义的重载操作符。

②不能为内置数据类型定义其他的操作符。

③预定义的操作符优先级不能被改变。

④一个类最终需要提供哪些操作符，是由该类预期的用途来决定的。

四、prefix and postfix

为区分后置操作符与前置操作符的声明，重载的递增和递减后置操作符的声明有一个额外的int 类型的参数。这里不需要给出参数名，因为它没有被用在操作符定义中。额外的整型参数对于后置操作符的用户是透明的，编译器为它提供了缺省值因而该参数也可以被忽略。例如：

  1. #include  
  2. #include  
  3. using namespace std;  
  4. class person  
  5. {  
  6. private:  
  7.  int age;  
  8. public:  
  9.  person(int a)  
  10.  {  
  11.  aage=a;  
  12.  }  
  13. person const operator++()/*prefix ++ */  
  14. {  
  15.  this->age++;  
  16.  return *this;  
  17. }  
  18. person const operator++(int a)/*postfix ++ */  
  19. {  
  20.  person temp(1);  
  21.  temp=*this;  
  22.  this->age++;  
  23.  return temp;  
  24. }  
  25. int GetAge()  
  26. {  
  27.  return age;  
  28. }  
  29. };  
  30. int main()  
  31. {  
  32. person rose(10);  
  33. person jack(20);  
  34. person marry(22);  
  35. person tom(30);  
  36. jack=++rose;  
  37. marry= tom++;  
  38. return 0;  
  39. } 

以上就是对C++操作符重载的相关介绍。

完

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/wangkangluo1/p/2130006.html