1. pointer-like class 意思是像指针的类，是指一个类被设计成像指针一样，可以当做指针来使用。下面来介绍两种常见的指针类：智能指针和迭代器。
a. 智能指针
namespace ll { template<class T> class shared_ptr { public: T& operator* () const { return *px; //返回指针所指的对象 } T* operator->() const { return px; } shared_ptr(T* p): px(p) {} private: T *px; }; } struct Foo { void method() { cout << "method" << endl; } }; ll::shared_ptr<Foo> sp(new Foo); // 定义了一个指向Foo类型的智能指针 Foo f(*sp); // 定义了一个Foo对象，并使用智能指针sp所指向的对象来进行初始化 f.method(); // 通过对象f调成成员函数 sp->method(); // 见下面的解释上述代码申明了一个智能指针sp，并通过->操作符来调用成员函数。sp->method();会首先调用操作符函数 operator->() const,得到智能指针内部真实的指针px,然后再通过px调用method函数(px->method())。在这里的疑问是，sp->通过调用操作符函数operator->()已经消耗了一个->符号，px->method()的->是如何来的？C++规定，对于调用->操作符后，->操作符并不消耗，而是会继续作用下去，这样一来，sp->method();便等同于sp->method();
b.迭代器
namespace ll { template<class T> struct __list_node { void *prev; void *next; T data; }; template<class T, class Ref, class Ptr> struct __list_iterator { typedef __list_iterator<T, Ref, Ptr> self; typedef Ptr pointer; typedef Ref reference; typedef __list_node<T>* link_type; link_type node; reference operator*() const { return (*node).data; } pointer operator->() const { return &(operator*()); } self& operator++() { node = (link_type)((*node).next); return *this; } self& operator--() { node = (link_type)((*node).prev); return *this; } }; } //上述代码的使用代码 struct Foo { void method() { cout << "method" << endl; } }; ll::__list_iterator<Foo, Foo&, Foo*> iter; *iter; // 获得一个Foo对象 iter->method(); // 意思是调用Foo::method()，相当于(*iter).method()，也相当于(&(*iter))->method()首先，我们申明一个_list_iterator迭代器iter,通过*操作符可以得到一个Foo对象，iter->method();则调用Foo::method(),解释如下：
iter->method();会首先调用operator->() const函数，由于operator->() const里还会调用operator*()先取得data,然后再取地址，所有operator->() const会返回data的地址，在上例中即是Foo对象的地址，这样，通过->操作符便可以调用到Foo::method();
注：->符号的含义， 成员提取，例如 A->B, A是指向类、结构、联合的指针，A->B是指提取A中的成员B。
2. function-like classes 仿函数的类
仿函数的类的特点是重载了操作符operator()，如下面的例子：
template <class T1, class T2> struct pair { T1 first; T2 second; //first和second类型不需要一样 pair() : first(T1()), second(T2()) {} pair(const T1& a, const T2& b) : first(T1()), second(T2()) ...... }; template<class T> struct identity ： public unary_function<T,T> { const T& operator() (const T& x) const { return x; } }; template<class Pair> struct select1st : public unary_function<Pair, typename Pair::first_type> { const typename Pair::first_type& operator() (const Pair& x) const { return x.first; } }; template<class Pair> struct select2nd : public unary_function<Pair, typename Pair::second_type> { const typename Pair::second_type& operator() (const Pair& x) const { return x.second; } };
参考博客：
https://blog.csdn.net/lihao21/article/details/50668271
https://blog.csdn.net/SUSU0203/article/details/80478029
