devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

重载箭头运算符->_箭头运算符重载

作者：很楠不爱3 | 2024-03-28 10:47:27

赞

踩

箭头运算符重载

一
在看到C++primer page445,重载箭头操作符时候，发现有点疑惑。在网上一查，原来是中文版本的错误。搞了我半天费解。现在自己整理理解后，写于此，后来人可以借鉴。
箭头运算符的重载小结：
    对于该箭头运算符，其内置类型的意义为：结构体或者类类型解引用取其成员的操作符。也就说着这玩意目的就是 取结构体或者类类型对象成员的。那么重载一个比较重要的原则就是尽量保存其内置类型常规的意义。正如C++Primer所说的，尽量不要去重载+号去完成-的功能。下面举个例子。例子是从别人那里看到的。这里例子比较好说明问题：

[cpp]  view plain  copy
 print ? 在CODE上查看代码片 派生到我的代码片
  1. #include <iostream>  
  2. using namespace std;  
  3. class A  
  4. {  
  5. public:  
  6.     void hello(){  
  7.         cout<<"A say hello "<<endl;  
  8.     }  
  9. };  
  10. class B  
  11. {  
  12.     A a;  
  13. public:  
  14.     A* operator->(){  
  15.         return &a;  
  16.     }  
  17.     void hello(){  
  18.         cout<<"B said hello"<<endl;  
  19.     }  
  20. };  
  21. class C  
  22. {  
  23.     B b;  
  24. public:  
  25. //  B* operator->(){  
  26. //      return &b;  
  27. //      }  
  28.     B operator->(){  
  29.         return b;  
  30.     }  
  31.     void hello(){  
  32.         cout<<"C said hello"<<endl;  
  33.     }  
  34. };  
  35. void main()  
  36. {     
  37.     C *pc;  
  38.     pc->hello(); //pc为一个类的指针 所以直接  
  39.     C c;  
  40.     c->hello();  
  41. }  

所以重载箭头运算的规则就变得简单了。如例子中的p->hello。将按照以下顺序：
1. 编译器首先检查是否为 默认内置->的意义.也就说是不是常规意思，p是否为类类型指针，hello是否为其所指的成员。如果是的话直接调用就OK了。如上述代码中C *pc; pc肯定为指向一个类类型的具有hello成员的指针。所以直接调用。所以 显示的 c said hello. 
2.如果不是的话，就按照对象重载来考虑了。
     再检查是不是 具有重载->运算符的对象，不是就出错了，是的话就使用。然后就直接调用重载运算符了。因为运算符的重载其本质就是 函数的 重载。所以 在例子中的 C c;这里是c是个对象。所以 调用 c->hello() 
就相当于调用 Operator->函数了。再使用其结果。既然是当做函数调用使用，那么结果就是函数值了。这里对于重载->的返回值有要求（不是类类型指针，就是类类型对象）。然后根据函数返回值。再次按照规则递归调用->。
    比如这里： c->hello();由于c为具有hello方法的类对象。所以直接调用重载方法 
那么相当于 c.operator->() ->hello() ，这里红色部分就是个函数，调用完毕，返回值。在上例中返回的是对象b.所以
其结果就相当于 b->Hello().此时 b又是个对象，并非指向类类型的指针。所以在此调用b的重载operataor->()方法。这里也就是递归调用的意思。也就是b.operator->()->hello()。这里返回是指向对象a的指针。调用完毕后也就相当于
a->hello()。现在 a就是一个指向一个类类型的指针，且Hello()仍然为其成员。所以这里按照内置类型的->调用。也就是常规调用。所以输出 "A say hello"。
     也就是：能解释为内置类型的先解释为内置类型的->意思。不然就查是不是重载。还要要注意对重载函数返回类型的要求。然后就是不断重复这个解释过程（递归解释）。欧拉...

二

箭头操作符(->)的内置用法是，使用一个类对象的指针来调用所指对象的成员。左操作数为对象指针，右操作数为该对象的成员。

定义重载箭头操作符之后看起来就有点特别，既可用类对象的指针来调用，也可用类对象直接调用。

重载箭头操作符，首先重载箭头操作符必须定义为类成员函数。

箭头操作符与众不同。它其实是一元操作符，却表现得像二元操作符一样：接受一个对象和一个成员名。对对象解引用以获取成员。不管外表如何，箭头操作符不接受显式形参。
这里没有第二个形参，因为 -> 的右操作数不是表达式，相反，是对应着类成员的一个标识符。没有明显可行的途径将一个标识符作为形参传递给函数，相反，由编译器处理获取成员的工作。

对于形如point->member的表达式来说，point必须是二者之一：指向类对象的指针、一个重载了operator->() 的类对象。

=============================================================================================

根据point类型的不同，有如下两条作用规则：

1.如果point是指针，则按照内置的箭头运算符去处理。表达式等价于(*point).member。首先解引用该指针，然后从所得的对象中获取指定的成员。如果point所指的类没有名为member的成员，则编译器报错。

2.如果point是一个定义了operator->() 的类对象，则point->member等价于point.operator->() ->member。其中，如果operator->()的返回结果是一个指针，则转第1步；如果返回结果仍然是一个对象，且该对象本身也重载了operator->()，则重复调用第2步，否则编译器报错。最终，过程要么结束在第一步，要么无限递归，要么报错。

==============================================================================================

也就是说，如果返回类型是类类型的其他对象（或是这种对象的引用），则将递归应用该操作符。编译器检查返回对象所属类型是否具有成员箭头，如果有，就应用那个操作符；否则，编译器产生一个错误。这个过程继续下去，直到返回一个指向带有指定成员的的对象的指针。

基于以上分析，我们可以调戏一下编译器，看一下它的智能程度如何。我们让operator->()返回对象本身，则可知这是一个无穷递归。

[cpp]  view plain  copy
  1. #include <iostream>  
  2.   
  3. class myClass {  
  4. public:  
  5.     myClass& operator->() {  
  6.         std::cout << "myClass ->() is called!" << std::endl;  
  7.         return *this;  
  8.     }  
  9.     void action() {  
  10.         std::cout << "myClass action() is called!" << std::endl;  
  11.         return;  
  12.     }  
  13. };  
  14.   
  15. int main() {  
  16.     myClass obj;  
  17.     obj->action();  
  18.   
  19.     return 0;  
  20. }  
编译器表现不错：error: circular pointer delegation detected


下面我们以一下正确的例子结束本篇：

[cpp]  view plain  copy
  1. #include <iostream>  
  2.   
  3. class firstClass {  
  4. public:  
  5.     firstClass* operator->() {  
  6.         std::cout << "firstClass ->() is called!" << std::endl;  
  7.         return this;  
  8.     }  
  9.     void action() {  
  10.         std::cout << "firstClass action() is called!" << std::endl;  
  11.         return;  
  12.     }  
  13. };  
  14.   
  15. class myClass {  
  16.     firstClass firstObj;  
  17. public:  
  18.     firstClass& operator->() {  
  19.         std::cout << "myClass ->() is called!" << std::endl;  
  20.         return firstObj;  
  21.     }  
  22.     void action() {  
  23.         std::cout << "myClass action() is called!" << std::endl;  
  24.         return;  
  25.     }  
  26. };  
  27.   
  28. int main() {  
  29.     myClass obj;  
  30.     obj->action();  
  31.   
  32.     return 0;  
  33. }  

调用结果为：

[html]  view plain  copy
  1. myClass ->() is called!  
  2. firstClass ->() is called!  
  3. firstClass action() is called!  
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/329668
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号