《白话C++》第9章 泛型，Page845~847 AutoPtr 模仿裸指针（未完成）

模仿裸指针：

模仿版本的AutoPtr的使用形式和普通的指针不一样，例如：

struct S
{
    int a, b, c;
};

void test2()
{
    AutoPtr <S> sap; //sap的_ptr元素是一个指向S的指针。
    sap._ptr->a = 100; //需要通过sap._ptr来处理指针

    S s2 = *(sap._ptr); //同上
    S* tmp = sap._ptr;
    ...
    delete tmp; ///这里删除了tmp, 可是tmp就是sap._ptr,一会儿将再死一次。
}

指针最常见的操作，是成员访问操作和取值操作，分别有“->”和“*”表达。我们希望用AutoPtr模板来模拟指针，就是希望上面的代码中sap可以尽量和一个普通S*指针用法一致，如下表所列

//裸指针的用法 S* sap = new S; sap->a = 10; S sap2 = *sap;

//当前自动指针的用法 AutoPtr<S> sap; sap._ptr->a = 10; S sap1 = *(sap._ptr);

//期望自动指针的用法 AutoPtr <S> sap; sap->a = 10; S sap2 = *sap;

“->”和“*”都是C++语言的操作符，既然是操作符，我们就可以为指定的类型重载它们的行为，让这个类的对象，看起来像是拥有了指针的某些特性：

template <typename T>
struct AutoPtr
{
    AutoPtr(){this->_ptr = new T;}
    ~AutoPtr(){delete this->_ptr;}
    //重载“->”
    T* operator -> () //重载->
    {
        return _ptr;
    }
    //重载“*”
    T& operator * () //注意返回值是引用,重载*
    {
        return *_ptr;
    }

private:
    T* _ptr;
};

使用样例：

void test()
{
    AutoPtr <S> sap;
    sap->a = 10;
    (*sap).b = 11; 
    S s2 = *sap;
}

先重点看“sap->a  = 10” 这一句。“->”现在是AutoPtr的一个函数。所以“sap->”相当于是通过sap调用了一个叫“operator->()”的函数，依据我们的定义，这个函数，返回的是_ptr。

C++在调用这重载“->”的函数时，有特殊处理，会将“->”之后的内容，作为“->”返回的对象(_ptr)的成员处理，所以sap->a，会被解释为：_ptr->a。这样一来，魔术就被揭穿了：

sap->a = 10;
/*推导过程：
首先“sap->”被解释为：sap.operator->(),它返回 _ptr;
其次：“sap->a”被解释为：_ptr->a;(完整是sap._ptr->a)。
最后：“sap->a = 10”,就被解释为：_ptr.a = 10;(完整是：sap._ptr->a = 10)
*/

取值操作符“*”的解释过程类似，

(*sap).b = 11; 推导过程，首先 * 被解释为operator *(), *sap相当于 sap.operator * ()，它返回 *_ptr

所以(*sap).b=11,就解释为(*_ptr).b = 11，这正是我们期待的。

S s2 = *sap; 推导过程，首先 * 被解释为operator *(), *sap相当于 sap.operator * ()，它返回 *_ptr，而_ptr是一个S指针，所以取值后，可以赋给一个S对象。

考虑常量下的使用：

使用C++语言，一定不能忘记const这个关键字，上面的AutoPtr，在下面的代码中，编译失败：

AutoPtr <S> const c_sap;
c_sap->a = 10; //编译不过
cout << c_sap->a << endl; //编译不过

002行编译不过，在意料之中，因为c_sap是一个常量。

003行代码，只是要读取c_sap成员a的值，为什么也编译不过去呢？

解决方法是，为AutoPtr类，增加“常量成员函数”版本的“->”和“*”的重载：