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::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;
}

     上述赋值语句将完成什么工作呢？如果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