C++ 的智能指针你了解吗？

shared_ptr<T> p; //空智能指针 可以指向类型为T的对象

p.get(); //返回p中保存的指针

swap(p,q);//交换p和q的指针

p.swap(q);//交换p和q的指针

shared_ptr<T> p(q); //p是share_ptr q的拷贝；此操作会递增q中的计数器。此外q中的指针必须能转为T*；

p.use_count(); //返回与p共享对象的智能指针的数量，可能很慢，主要用于调试

unique_ptr<T> u1；//空unique_ptr，可以指向类型为T的对象。

unique_ptr<T ,D> u2；

//u1会使用delet来释放它的指针，u2会使用一个类型为D的可调用对象来释放它的指针

unique_ptr<T ,D> u（d）；///空unique_ptr，指向类型为T的对象，用类型为D的对象d代替delete

u1 = nullptr; //释放u指向的对象，将u置为空

u.release(); //u放弃对指针的控制权，返回指针，并将u置为空

u.reset(); //释放u指向的对象

u.reset(q); //如果提供了内置指针q，令u指向这个对象;否则将u置空

u.reset(nullptr);

f(std::unique_ptr<MyClass>(new MyClass(param)), g()); // Syntax A

f(std::make_unique<MyClass>(param), g());             // Syntax B

class A;

class B;

class A {

public:

         A() {cout<< "A Created" << endl;}

         ~A() {   cout<< "A Destroyed" << endl;

}

         shared_ptr<B>ptr;

};

class B {

public:

         B() {cout<< "B Created" << endl;       }

         ~B() {cout<< "B Destroyed" << endl;}

         shared_ptr<A>ptr;

};

int main() {

         shared_ptr<A>pt1(new A());

         shared_ptr<B>pt2(new B());

         pt1->ptr = pt2;

    pt2->ptr = pt1;

    cout << "useof pt1: " << pt1.use_count() << endl;

    cout << "useof pt2: " << pt2.use_count() << endl;

    return 0;

}

class A;

class B;

class A {

public:

         A() {cout<< "A Created" << endl;}

         ~A() {   cout<< "A Destroyed" << endl;

}

         weak_ptr<B>ptr;

};

class B {

public:

         B() {cout<< "B Created" << endl;       }

         ~B() {cout<< "B Destroyed" << endl;}

         weak_ptr<A>ptr;

};

int main() {

         shared_ptr<A>pt1(new A());

         shared_ptr<B>pt2(new B());

         pt1->ptr = pt2;

    pt2->ptr = pt1;

    cout << "useof pt1: " << pt1.use_count() << endl;

    cout << "useof pt2: " << pt2.use_count() << endl;

    return 0;

}

auto_ptr< string> ps (new string ("I reigned lonely as a cloud.”）;

auto_ptr<string> vocation; 

vocaticn = ps;

     上述赋值语句将完成什么工作呢？如果ps和vocation是常规指针，则两个指针将指向同一个string对象。这是不能接受的，因为程序将试图删除同一个对象两次——一次是ps过期时，另一次是vocation过期时。要避免这种问题，方法有多种：

1.定义陚值运算符，使之执行深复制。这样两个指针将指向不同的对象，其中的一个对象是另一个对象的副本，缺点是浪费空间，所以智能指针都未采用此方案。

2.建立所有权（ownership）概念。对于特定的对象，只能有一个智能指针可拥有，这样只有拥有对象的智能指针的构造函数会删除该对象。然后让赋值操作转让所有权。这就是用于auto_ptr和uniqiie_ptr 的策略，但unique_ptr的策略更严格。

3.创建智能更高的指针，跟踪引用特定对象的智能指针数。这称为引用计数。例如，赋值时，计数将加1，而指针过期时，计数将减1,。当减为0时才调用delete。这是shared_ptr采用的策略。

当然，同样的策略也适用于复制构造函数。

每种方法都有其用途，但为何说要摒弃auto_ptr呢？

下面举个例子来说明。

#include <iostream>

#include <string>

#include <memory>

using namespace std;

int main() {

  auto_ptr<string> films[5] =

 {

  auto_ptr<string> (new string("Fowl Balls")),

  auto_ptr<string> (new string("Duck Walks")),

  auto_ptr<string> (new string("Chicken Runs")),

  auto_ptr<string> (new string("Turkey Errors")),

  auto_ptr<string> (new string("Goose Eggs"))

 };

 auto_ptr<string> pwin;

 pwin = films[2]; // films[2] loses ownership. 将所有权从films[2]转让给pwin，此时films[2]不再引用该字符串从而变成空指针

 cout << "The nominees for best avian baseballl film are\n";

 for(int i = 0; i < 5; ++i)

  cout << *films[i] << endl;

 cout << "The winner is " << *pwin << endl;

 cin.get();

 return 0;

}

unique_ptr<string> pwin;

pwin = films[2]; // films[2] loses ownership.

unique_ptr<int> make_int(int n)

{

    return unique_ptr<int>(new int(n));

}

void show(unique_ptr<int> &p1)

{

    cout << *a << ' ';

}

int main()

{

    ...

    vector<unique_ptr<int> > vp(size);

    for(int i = 0; i < vp.size(); i++)

        vp[i] = make_int(rand() % 1000);              // copy temporary unique_ptr

    vp.push_back(make_int(rand() % 1000));     // ok because arg is temporary

    for_each(vp.begin(), vp.end(), show);           // use for_each()

    ...

}

unique_ptr<int> pup(make_int(rand() % 1000));   // ok

shared_ptr<int> spp(pup);                       // not allowed, pup as lvalue

shared_ptr<int> spr(make_int(rand() % 1000));   // ok