前言 - 什么是智能指针？

在全文开始之前，我们先来看一段代码：

class Object{
public:
    Object(){cout<<"Create Object"<<endl;}
    ~Object(){cout<<"Free Resources"<<endl;}
    void run(){
        throw -1;
    }
};
int main(){
    Object* pObj = new Object();
    pObj->run();
    delete pObj;
}

执行这段代码我们只会得到"Create Object"的输出，这表明析构函数没有被调用。有时候我们会忘记delete，有些时候，就像上面的代码一样，中途发生异常也会导致对象无法正常地释放资源，从而导致内存泄漏。

对此，C++之父Bjarne Stroustrup提出了 RAII(Resource Acquisition Is Initialization) 机制，翻译过来就是“资源获取就是初始化”。RAII要求由对象的构造函数完成资源的分配，同时由析构函数，完成资源的释放。在这种要求下，只要对象能正确地析构，就不会出现资源泄露问题。而 C++智能指针 正是RAII的实践。

C++ STL提供了四种智能指针：std::auto_ptr、std::unique_ptr、std::shared_ptr 和 std::weak_ptr。它们包含在<memory>之中。在本篇，我们会讲std::auto_ptr。

std::auto_ptr

auto_ptr是C++98提出的一种智能指针，它在C++11中就已经被弃用，在C++17中就完全去除了它。因为auto_ptr有很多局限性。所以，在我们实际的开发中不建议使用，但是它还是有必要讲的。在本文中，我们会先讲它的用法，再讲它的局限。

auto_ptr的使用

创建auto_ptr的方法如下：(其余的智能指针创建方法也都于此相同，后面就不多赘述了)

auto_ptr<Object> pObj(new Object());

Notice:
注意不能使用如下的方式创建，因为其构造函数阻止了隐式转换：

//The following code is incorrect
auto_ptr<Object> pObj = new Object();

常用成员方法：

其中 get()、operator*()、operator->()为观察器，reset()、release()为修改器。

1. get()方法

要获取其托管对象的地址可以使用get()方法：

auto_ptr<Object> pObj(new Object);
Object* pObj1 = pObj.get();
delete pObj1;

2. release()方法

如果我们此时想要取消托管，可以使用release()方法，这个函数会取消智能指针的所有权，并返回托管对象的地址：

auto_ptr<Object> pObj(new Object);
Object* pObj1 = pObj.release();
delete pObj1;

3. reset()方法

要替换管理对象，可以使用reset()方法。如果传入的为空，则释放托管对象资源并置空，如果传入另一指针，先释放前一指针，再托管后面的：

class Object{
public:
    Object(){cout<<"Create Object"<<endl;}
    ~Object(){cout<<"Free Resources"<<endl;}
    void run(){
        throw -1;
    }
public:
    int num=100;
};
int main(){
    auto_ptr<Object> pObj(new Object());
    cout<<"Addr: "<<pObj.get()<<endl;
    pObj.reset(new Object());
    cout<<"Addr: "<<pObj.get()<<endl;
}

输出如下：

Create Object
Addr: 0x26622b0
Create Object
Free Resources
Addr: 0x26622f0
Free Resources

4. operator=()

转移auto_ptr所有权，下面的代码将pObj1的所有权转交给了pObj2：

auto_ptr<Object> pObj1(new Object());
auto_ptr<Object> pObj2 = pObj1;

Notice:
注意这里不要与前面创建不能使用“=”搞混了，这里是重载赋值，而前面是隐式转换。

5. operator*() & operator->()

如果要访问托管的对象可以使用*，访问托管对象的成员可以使用->

auto_ptr<Object> pObj(new Object);
cout<<pObj->num;

auto_ptr的局限性

首先，auto_ptr意义不明确，使用浅拷贝方式时，两个对象拥有同一块资源，这样就会调用两次析构函数，有可能导致程序崩溃：

class Object{
public:
    Object(){cout<<"Create Object"<<endl;}
    ~Object(){cout<<"Free Resources"<<endl;}
    void run(){
        throw -1;
    }
};
int main(){
    Object* pObj = new Object();

    auto_ptr<Object> pObj1(pObj);
    auto_ptr<Object> pObj2(pObj);
}

结果如下：

Create Object
Free Resources
Free Resources

并且auto_ptr没有引用计数，转移所有权以后，如果在后面访问了前面对象的成员，程序就会Crash：

class Object{
public:
    Object(){cout<<"Create Object"<<endl;}
    ~Object(){cout<<"Free Resources"<<endl;}
    void run(){
        throw -1;
    }
public:
    int num=100;
};
int main(){
    Object* pObj = new Object;
    auto_ptr<Object> pObj1(pObj);
    auto_ptr<Object> pObj2(pObj1);
    cout<<pObj1->num;
}

可以看到pObj2已经拥有所有权，再访问pObj1->num就会报错

此外auto_ptr对象并不能作为STL容器的元素，因为C++的STL容器对于容器元素类型的要求是有值语义，即可以赋值和复制，auto_ptr在赋值和复制时都进行了特殊操作；也不能声明为数组，因为auto_ptr无法识别数组，其内部析构时是用的delete而非delete []，它只会析构一次，导致内存泄漏：

int main(){
    Object* pObj = new Object[3];
    auto_ptr<Object> pObj1(pObj);
}

输出结果为：

Create Object
Create Object
Create Object
Free Resources