这里以一个智能指针类为例,智能指针所指为一个对象。
而事实上,STL迭代器的开发均需要重载这两个操作符,上一篇文章分析STL 迭代器中除了要用到template技巧外,还需要重载技巧
#include<iostream>
using namespace std;
class Screen
{
public:
friend ostream& operator<<(ostream&os, Screen &s);
int action(){ return ++data; }
Screen(int i = 0) :data(i){}
private:
int data;
};
ostream& operator<<(ostream&os, Screen &s)
{
os << s.data;
return os;
}
class U_ptr
{
friend class ScreenPtr;
Screen* p;
size_t use;
U_ptr(Screen *pp) :p(pp), use(1){}
~U_ptr(){ delete p; }
};
class ScreenPtr
{
private:
U_ptr *ptr;
public:
ScreenPtr(Screen *p) :ptr(new U_ptr(p)){}
ScreenPtr(ScreenPtr &orgi_p) :ptr(orgi_p.ptr){ ++ptr->use; }
~ScreenPtr(){ if (--ptr->use == 0)delete ptr; }
Screen& operator*()
{
return *(ptr->p);
}
Screen* operator->()
{
return ptr->p;
}
};
class gao
{
private:
ScreenPtr *p;
public:
gao(ScreenPtr* q) :p(q){}
ScreenPtr& operator->()
{
return *p;
}
};
int main()
{
ScreenPtr ptr(new Screen(5));
cout << "*操作符 " << *ptr << endl;
cout << "->操作符 " << ptr->action() << endl;
ScreenPtr* pp = &ptr;
gao d(pp);
cout << "!" << d->action() << endl;
system("pause");
}
这里的代码逻辑如下:
1. 首先定义一个简单封装的U_ptr,其实就是指向Screen的指针+一个引用计数的封装
2. 然后定义真正的智能指针类ScreenPtr,其成员是U_ptr,
3. 然后定义构造函数和复制构造函数(对引用计数++)
4. 再定义析构函数,只有当--use==0时才进行析构,调用U_ptr类的析构函数
5. 最后,为了使类ScreenPtr 具有指针类似的表现,重载operator* 和 ->
*是一个一元操作符,作为成员函数故无形参,返回的是指向Screen的引用
->是一个一元操作符,尽管长得像二元操作符,故也无形参。
这里应该格外注意,为什么其返回值是一个Screen的指针?
可以这样理解,
对于一个指针类型变量p,p->action()表示返回其成员 //action()为Screen类的成员函数
而对于我们想要重载的类ScreenPtr而言,调用->的是ScreenPtr的对象,因此这里返回一个指向Screen的指针,然后编译器会自动绑定其成员,也就是说ScreenPtr对象 sp->action()的含义为 ( sp.operator->() )->action())
更一般的,->重载后返回值除了返回一个指针外,还可以返回一个已经重载了->操作符的类对象的引用,然后编译器递归调用重载过的->,直到有一个返回指针,如上面的类gao
原文:http://www.cnblogs.com/gaoduan/p/3903500.html