c++智能指针

1、std::auto_ptr

        std::auto_ptr真正容易让人误用的地方是其不常用的复制语义，即当复制一个std::auto_ptr对象时（拷贝复制或operator =复制），原对象所持有的堆内存对象也会转移给复制出来的对象。示例代码如下：

//测试拷贝构造函数
    std::auto_ptr<int> sp1(new int(8));
    std::auto_ptr<int> sp2(sp1);
    if (sp1.get() != NULL)
    {
        std::cout << " sp1 is not empty" << std::endl;
    }
    else {
        std::cout << " sp1 is  empty" << std::endl;
    }
 
    if (sp2.get() != NULL)
    {
        std::cout << " sp2 is not empty" << std::endl;
    }
    else {
        std::cout << " sp2 is  empty" << std::endl;
    }
 
    //测试赋值构造
    std::auto_ptr<int> sp3(new int(8));
    std::auto_ptr<int> sp4;
    sp4 = sp3;
    if (sp3.get() != NULL)
    {
        std::cout << " sp3 is not empty" << std::endl;
    }
    else {
        std::cout << " sp3 is  empty" << std::endl;
    }
 
    if (sp4.get() != NULL)
    {
        std::cout << " sp4 is not empty" << std::endl;
    }
    else {
        std::cout << " sp4 is  empty" << std::endl;
    }

上述代码中分别利用拷贝构造（sp1=>sp2）和赋值构造（sp3=>sp4）来创建新的std::auto_ptr对象，因此sp1 持有的堆对象被转移给sp2，sp3持有的堆对象被转移给sp4。因此输出为：

sp1 is  empty
sp2 is not empty
sp3 is  empty
sp4 is not empty

例如：

std::vector> myvectors;

当用算法对容器操作的时候（如最常见的容器元素遍历），很难避免不对容器中的元素实现赋值传递，这样便会使容器中多个元素被置为空指针，这不是我们希望看到的，可能会造成一些意想不到的错误。

2、std::unique_ptr

std::unique_ptr对其持有的堆内存具有唯一拥有权，也就是说引用计数永远是1，std::unique_ptr对象销毁时会释放其持有的堆内存。可以使用以下方式初始化一个std::unique_ptr对象：

//1
std::unique_ptr<int> sp1(new int(123));
//2
std::unique_ptr<int> sp2;
sp2.reset(new int(123));
//3
std::unique_ptr<int> sp3 = std::make_unique<int>(123);

应该尽量使用初始化方式3的方式去创建一个std::unique_ptr而不是方式1和2，因为形式3更安全。

std::unique_ptr禁止复制语义，为了达到这个效果，std::unique_ptr类的拷贝构造函数和赋值运算符（operator =）被标记为 =delete。

template <class T>
class unique_ptr
{
 //省略其他代码...
 
 //拷贝构造函数和赋值运算符被标记为delete
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
};

因此，下列代码是无法通过编译的：

 std::unique_ptr<int> sp1(new int(123));
 
    //报错
    std::unique_ptr<int> sp2(sp1);
 
    std::unique_ptr<int> sp3;
    //报错
    sp3 = sp2;

禁止复制语义也存在特例，即可以通过一个函数返回一个std::unique_ptr。

既然std::unique_ptr不能复制，那么如何将一个std::unique_ptr对象持有的堆内存转移给另外一个呢？答案是使用移动构造，示例代码如下：

 std::unique_ptr<int> sp1(std::make_unique<int>(123));
 
    std::unique_ptr<int> sp2(std::move(sp1));
 
    std::unique_ptr<int> sp3;
    sp3 = std::move(sp2);

以上代码利用std::move将sp1持有的堆内存（值为123）转移给sp2，再把sp2转移给sp3。最后，sp1和sp2不再持有堆内存的引用，变成一个空的智能指针对象。并不是所有的对象的std::move操作都有意义，只有实现了移动构造函数（Move Constructor）或移动赋值运算符（operator =）的类才行，而std::unique_ptr正好实现了这二者。

3、std::shared_ptr

        std::unique_ptr对其持有的资源具有独占性，而std::shared_ptr持有的资源可以在多个std::shared_ptr之间共享，每多一个std::shared_ptr对资源的引用，资源引用计数将增加1，每一个指向该资源的std::shared_ptr对象析构时，资源引用计数减1，最后一个std::shared_ptr对象析构时，发现资源计数为0，将释放其持有的资源。多个线程之间，递增和减少资源的引用计数是安全的。（注意：这不意味着多个线程同时操作std::shared_ptr引用的对象是安全的）。std::shared_ptr提供了一个use_count()方法来获取当前持有资源的引用计数。除了上面描述的，std::shared_ptr用法和std::unique_ptr基本相同。

初始化std::shared_ptr的示例：

//初始化方式1
    std::shared_ptr<int> sp1(new int(123));
 
    //初始化方式2
    std::shared_ptr<int> sp2;
    sp2.reset(new int(123));
 
    //初始化方式3
    std::shared_ptr<int> sp3;
    sp3 = std::make_shared<int>(123);

class A
{
public:
    A()
    {
        std::cout << "A constructor" << std::endl;
    }
 
    ~A()
    {
        std::cout << "A destructor" << std::endl;
    }
};
int main()
{
    {
        //初始化方式1
        std::shared_ptr sp1(new A());
 
        std::cout << "use count: " << sp1.use_count() << std::endl;
 
        //初始化方式2
        std::shared_ptr sp2(sp1);
        std::cout << "use count: " << sp1.use_count() << std::endl;
 
        sp2.reset();
        std::cout << "use count: " << sp1.use_count() << std::endl;
 
        {
            std::shared_ptr sp3 = sp1;
            std::cout << "use count: " << sp1.use_count() << std::endl;
        }
 
        std::cout << "use count: " << sp1.use_count() << std::endl;
    }
return 0；
}

A constructor
use count: 1
use count: 2
use count: 1
use count: 2
use count: 1
A destructor

//创建一个std::shared_ptr对象
    std::shared_ptr<int> sp1(new int(123));
    std::cout << "use count: " << sp1.use_count() << std::endl;
 
    //通过构造函数得到一个std::weak_ptr对象
    std::weak_ptr<int> sp2(sp1);
    std::cout << "use count: " << sp1.use_count() << std::endl;
 
    //通过赋值运算符得到一个std::weak_ptr对象
    std::weak_ptr<int> sp3 = sp1;
    std::cout << "use count: " << sp1.use_count() << std::endl;
 
    //通过一个std::weak_ptr对象得到另外一个std::weak_ptr对象
    std::weak_ptr<int> sp4 = sp2;
    std::cout << "use count: " << sp1.use_count() << std::endl;

use count: 1
use count: 1
use count: 1
use count: 1