参考

• C++ Primer 第5版
• C++11 Smart Pointers

直接管理动态内存

在C++中，动态内存的管理是通过一对运算符来完成的：

• new：在动态内存中为对象分配空间并返回一个指向该对象的指针，可以选择对对象进行初始化

  int *pi = new int;//pi指向一个动态分配的、未初始化的无名对象
  string *ps = new string;//初始化为空string
  int *pi = new int(1024);//pi指向的对象的值为1024
  string *ps = new string(10, '9');//ps指向"9999999999"
  

• delete：接受一个动态对象的指针，销毁该对象，并释放与之关联的内存

  传递给delete的指针必须指向动态分配的内存，或者是一个空指针，释放一块并非new分配的内存，或者将相同的指针值释放多次，其行为是未定义的

  int i, *pi1 = &i, *pi2 = nullptr;
  double *pd = new double(33), *pd2 = pd;
  delete i;//错误，i不是一个指针
  delete pi1;//未定义，pi1指向一个局部变量，编译器不能分辨
  delete pd;//正确
  delete pd2;//未定义，pd2指向的内存已经被释放了，编译器不能分辨
  delete pi2;//正确，释放空指针是正确的
  

• 动态内存的使用很容易出问题，因为确保在正确的时间释放内存是及其困难的。

  • 忘记释放内存会产生内存泄露
  • 在尚有指针引用内存的情况下就释放该内存，会产生引用非法内存的指针

为了更容易（也更安全）的使用动态内存，C++11提供了两种==智能指针==类型来管理动态对象，两种类型都定义在memory头文件中。智能指针的行为类似常规指针，重要的区别是它负责自动释放所指向的对象。

• shared_ptr：允许多个指针指向同一个对象
• unique_ptr：独占所指向的对象

智能指针之一：shared_ptr类

多个指针可以同时指向一个对象，当最后一个shared_ptr离开作用域时，内存才会自动释放

• 初始化

  类似vector，智能指针也是模板。当我们创建一个智能指针时，必须提供指针可以指向的类型（在尖括号内给出类型）。

  • 默认初始化的智能指针中保存着一个空指针

    shared_ptr<string> p1;//shared_ptr，保存着一个空指针，可以指向string
    shared_ptr<list<int>> p2;//shared_ptr，保存着一个控指针，可以指向int的list
    

  • 调用make_shared库函数在动态内存中分配一个对象并初始化它，返回指向此对象的shared_ptr，make_shared效率更高，推荐使用make_shared

    //p3指向一个值为42的int的shared_ptr
    shared_ptr<int> p3 = make_shared<int>(42);
    //p4指向一个值初始化的int，值为0
    shared_ptr<int> p4 = make_shared<int>();
    //使用auto定义一个对象来保存make_shared_ptr的结果
    auto p5 = make_shared<vector<int>>();
    

• 引用计数

  当进行拷贝或者赋值操作时，每个shared_ptr都会记录有多少个其他shared_ptr指向相同的对象。每个shared_ptr都有一个关联的计数器，称为引用计数。

  • 无论何时拷贝一个shared_ptr，计数器都会递增
  • 给shared_ptr赋予一个新值或者shared_ptr被销毁，计数器就会递减
  • 一旦一个shared_ptr的计数器变为0，它就会自动释放自己所管理的对象

  auto p = make_shared<int>(25);//p指向的对象只有p一个引用者
  auto q(p);//p和q指向同一个对象25
  
  auto r = make_shared<int>(32);//r指向的int只有一个引用者
  r = q;//给r赋予一个新值，q指向的对象的计数器递增，r指向的对象的计数器递减，r原来指向的32对象已经没有引用者，自动释放
  

  shared_ptr的析构函数来递减它所指向的对象的引用计数。如果引用计数变为0，shared_ptr的析构函数就会销毁对象，并释放它占用的内存。

• shared_ptr和new结合使用

  如果不初始化一个智能指针，它就会被默认初始化为一个空指针。默认情况下，一个用来初始化智能指针的普通指针必须指向动态内存，因为智能指针默认使用delete释放它所关联的对象。

  • 用new返回的指针来初始化智能指针

    接受指针参数的智能指针构造函数是explicit。因此，不能将一个内置指针隐式转换为一个智能指针，必须使用直接初始化形式来初始化一个智能指针。

    shared_ptr<int> p1 = new int(1024);//错误，必须使用直接初始化形式
    shared_ptr<int> p(new int(1024));//正确，使用了直接初始化形式，p指向一个值为1024的int
    

  • 返回shared_ptr的函数不能在其返回语句中隐式转换一个普通指针

    shared_ptr<int> tarversal(int p) {
        return new int(p);//错误：隐式转换为shared_ptr<int>
    }
    
    shared_ptr<int> traversal(int p) {
        return shared_ptr<int>(new int(p));//正确：显示地用int*创建shared_ptr<int>
    }
    

• 其他shared_ptr操作

  • 用**reset()**来将一个新的指针赋予一个shared_ptr

    p = new int(1024);//错误，不能将一个指针赋予shared_ptr
    p.reset(new int(1024));//正确，p指向一个新对象
    

    与赋值类似，reset会更新引用计数，如果需要的话，会释放p指向的对象。

    p.reset();//若p是唯一指向其对象的shared_ptr，reset会释放此对象
    p.reset(q);//若传递了可选的参数内置指针q，会令p指向q，否则会将p置为空
    p.reset(q, d);//若还传递了参数d，将会调用d，而不是delete来释放q
    

  • 用unique判断是否是唯一指向当前内存的shared_ptr

    返回 shared_ptr 对象是否不与其他 shared_ptr 对象共享其指针的所有权（即，它是唯一的）。空指针从来都不是唯一的（因为它们不拥有任何指针）。此函数应返回与 (use_count()==1) 相同的值，尽管它可能以更有效的方式执行此操作。

    true：当前shared_ptr是唯一的

    std::shared_ptr<int> foo;//shared_ptr,保存着一个空指针，可以指向int
    std::shared_ptr<int> bar (new int);//shared_ptr，指向一个int对象
    std::cout << "1: " << foo.unique() << '\n';  // false，空指针从来都不是唯一的
    foo = bar;
    std::cout << "2: " << foo.unique() << '\n';  // false，foo和bar共同指向同一个int对象
    bar = nullptr;
    std::cout << "3: " << foo.unique() << '\n';  // true
    
    

  • 用**get()**函数获取智能指针中保存的原始指针

    要小心使用，若智能指针释放了其对象，返回的指针所指向的对象也就消失了

    get用来将指针的访问权限传递给代码，你只有在确定代码不会delete指针的情况下，才能使用get。特别是，永远不要用get初始化另一个智能指针或者另一个智能指针赋值。

    int* p = new int (10);
    std::shared_ptr<int> a (p);
    if (a.get()==p)std::cout << "a and p point to the same location\n";
    //以下三种形式访问同一块地址
    std::cout << *a.get() << "\n";//输出10
    std::cout << *a << "\n";//输出10
    std::cout << *p << "\n";//输出10
    

• shared_ptr陷阱

  • void main( )
    {
     shared_ptr<int> sptr1( new int );
     shared_ptr<int> sptr2 = sptr1;
     shared_ptr<int> sptr3;
     sptr3 =sptr1
    }
    

    上述代码中引用计数变化情况：

    

    所有的shared_ptr拥有相同的引用计数，属于相同的组。

  • void main( )
    {
     int* p = new int;
     shared_ptr<int> sptr1(p);
     shared_ptr<int> sptr2(p);
    }
    

    上述代码出现了一个错误，因为两个来自不同组的shared_ptr指向同一个资源

    

    为了避免这个问题，尽量不要从一个裸指针创建shared_ptr，此外万一在智能指针作用域结束之前删除了普通指针p，又将是一个错误。

  • class B;
    class A
    {
    public:
     A(  ) : m_sptrB(nullptr) { };
     ~A( )
     {
      cout<<" A is destroyed"<<endl;
     }
     shared_ptr<B> m_sptrB;
    };
    class B
    {
    public:
     B(  ) : m_sptrA(nullptr) { };
     ~B( )
     {
      cout<<" B is destroyed"<<endl;
     }
     shared_ptr<A> m_sptrA;
    };
    //***********************************************************
    void main( )
    {
     shared_ptr<B> sptrB( new B );
     shared_ptr<A> sptrA( new A );
     sptrB->m_sptrA = sptrA;
     sptrA->m_sptrB = sptrB;
    }
    

    上述代码产生了一个循环引用A对B有一个shared_ptr，B对A也有一个shared_ptr，与sptrA和sptrB关联的资源都没有被释放

    

    当sptrA和sptrB离开作用域时，它们的引用计数都只减少到1，所以它们指向的资源并没有释放

智能指针之二：unique_ptr类

unique_ptr也是对auto_ptr的替换。unique_ptr遵循着独占语义。在任何时间点，资源只能唯一地被一个unique_ptr占有。当unique_ptr离开作用域，所包含的资源被释放。如果资源被其它资源重写了，之前拥有的资源将被释放。所以它保证了他所关联的资源总是能被释放。

• 初始化

  与shared_ptr不同，没有类似make_shared的标准库返回一个unique_ptr。定义unique_ptr的时候需要将其绑定到一个new返回的指针上，类似shared_ptr，初始化unique_ptr的时候必须采用直接初始化的形式。

  unique_ptr<double> p;//可以指向一个int的unique_ptr
  unique_ptr<int> p1(new int(42));//unique_ptr，指向一个值为42的int
  
  //unique_ptr不支持拷贝或赋值操作
  unique_ptr<string> p2(new string("aabbcc"));//unique_ptr，指向一个值为aabbcc的string
  unique_ptr<string> p3(p2);//错误，unique_ptr不支持拷贝操作
  unique_ptr<string> p4;
  p4 = p2;//错误，unique_ptr不支持赋值操作
  

• 转移所有权

  调用release或者reset将指针的所有权转移

  release成员返回unique_ptr当前保存的指针并将其置为空，释放所有权不释放资源

  reset成员接受一个可选的指针参数，令unique_ptr重新指向给定的指针，释放所有权也释放资源

  unique_ptr<string> p1(new string("aabbcc"));//unique_ptr，指向一个值为aabbcc的string
  unique_ptr<string> p2(p1.release());//将所有权从p1转移给p2，release将p1置为空
  
  unique_ptr<string> p3(new string("tex"));//unique_ptr，指向一个值为tex的string
  p2.reset(p3.release);//将所有权从p3转移到p2，reset释放了p2原来指向的内存