Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1827266
  • 博文数量: 159
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 5649
  • 用 户 组: 普通用户
  • 注册时间: 2013-01-23 18:56
个人简介

将晦涩难懂的技术讲的通俗易懂

文章分类

全部博文(159)

文章存档

2019年(13)

2018年(19)

2017年(9)

2016年(26)

2015年(18)

2014年(54)

2013年(20)

分类: C/C++

2014-04-14 21:51:33

箭头操作符(->)的通常用法是,使用一个类对象的指针来调用该指针所指对象的成员。左操作数为对象指针(this),右操作数为该对象的成员名称定义重载箭头操作符之后看起来就有点特别,可以用类对象的指针来调用,也可以用对象直接调用。重载箭头操作符必须定义为类成员函数

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

箭头操作符的调用过程

当这样编写时:

     point->action();

由于优先级规则,它实际等价于编写:

     (point->action)();

    换句话说,我们想要调用的是对 point->action 求值的结果。编译器这样对该代码进行求值:

1.如果 point 是一个指针,指向具有名为 action 的成员的类对象,则编译器将代码编译为调用该对象的 action 成员(默认语义)

2.否则,如果 point(注:中文版primer误写为action) 是定义了 operator-> 操作符的类的一个对象,则 point->action 与 point.operator->()->action 相同。即,执行 point 的 operator->(),然后使用该结果重复这三步。(递归调用)

3.否则,代码出错。

总结:通过箭头(->)操作符的执行过程,我们可以得到结论“重载箭头操作符必须返回指向类类型的指针,或者返回定义了自己的箭头操作符的类类型对象”返回前者用于执行编译器默认语义终结箭头运算符的调用如果返回类型是指针,则内置箭头操作符可用于该指针,编译器对该指针解引用并从结果对象获取指定成员,返回后者用于递归调用。(如果返回类型是类类型的其他对象(或是这种对象的引用),则将递归应用该操作符。编译器检查返回对象所属类型是否具有成员箭头,如果有,就应用那个操作符;否则,编译器产生一个错误。这个过程继续下去,直到返回一个指向带有指定成员的的对象的指针,或者返回某些其他值,在后一种情况下,代码出错。

2. 实例分析

根据理解,定义了3个类,C包含BB包含AABC都定义了一个action的成员函数。BC都重载箭头操作符,不同的是B的重载箭头操作符返回的是A类对象的指针,而C的重载箭头操作符返回的是B类对象。

1.

点击(此处)折叠或打开

  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. class A{  
  5. public:  
  6.     void action(){  
  7.         cout << "Action in class A!" << endl;  
  8.     }  
  9. };  
  10.   
  11. class B{  
  12.     A a;  
  13. public:  
  14.     A* operator->(){  //返回指针
  15.         return &a;  
  16.     }  
  17.     void action(){  
  18.         cout << "Action in class B!" << endl;  
  19.     }  
  20. };  
  21.   
  22. class C{  
  23.     B b;  
  24. public:  
  25.     B operator->(){  //返回对象
  26.         return b;  
  27.     }  
  28.     void action(){  
  29.         cout << "Action in class C!" << endl;  
  30.     }  
  31. };  
  32.   
  33. int main(int argc, char *argv[])  
  34. {  
  35.     C* pc = new C;  
  36.     pc->action();  //指针调用(使用默认语义)
  37.     C c;  
  38.     c->action();   //对象调用(使用重载语义)
  39.     getchar();  
  40.     return 0;  
  41. }  

 上面代码输出结果是:


Action in class C!
Action in class A!

 

其中的代码

 C* pc = new C;
 pc->action();

输出的结果是

Action in class C!

这个结果比较好理解,pc是类对象指针,此时的箭头操作符使用的是内置含义,对pc解引用然后调用对象的成员函数action

 

 而下面的代码

 C c;
 c->action();

输出的结果是

Action in class A!

 其实c->action();的含义与c.operator->().operator->()->action();相同。

c对象c后面的箭头操作符使用的是重载箭头操作符,即调用类Coperator->()成员函数。此时返回的是类B的对象,所以调用类Boperator->()成员函数,Boperator->()返回的是指针,所以现在可以使用内置箭头操作符了。对Boperator->()返回的指针进行解引用,然后调用解引用后的对象的成员函数action,此时调用的就是类Aaction()。这里存在一个递归调用operator->()的过程,最后再使用一次内置含义的箭头操作符。

总结对箭头(->)运算符的调用,最终都要归结到对指针自身的(->)调用。

阅读(2228) | 评论(0) | 转发(0) |
0

上一篇:C&C++混合编程

下一篇:同余定理

给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册