---

前言

  在C++中，动态内存的申请和释放是通过运算符：new 和 delete 进行管理的。其中 new 负责申请内存，delete负责释放内存。

  动态内存的使用很容易出现问题，这主要在于你需要保证在正确的时间释放内存，这是比较困难的，如果你忘记释放内存，就会造成内存泄露；有时在还有指针引用内存的情况下我们就释放了它，在这种情况下就会产生引用非法内存的指针。

  为了更容易（同时也更安全）地使用动态内存，新的标准库提供了两种智能指针类型来管理动态对象，智能指针的行为类似普通指针，最主要的区别在于它负责自动释放所指向的对象。这两种智能指针都定义在 memory 头文件内。

• 本文是对于shared_ptr的分析。

---

一、Shared_ptr

• shared_ptr 类对象默认初始化为一个空指针
• 类似 vector，智能指针也是模板。所以，创建智能指针必须提供额外的信息，如：

shared_ptr<string> p1;  // shared_ptr，可以指向 string
shared_ptr<list<int>> p2; // shared_ptr，可以指向 int 的 list

  智能指针的使用和普通指针类似，解引用一个智能指针返回它指向的对象，如过在条件判断中使用它，则是检测其是否为空。如：

shared_ptr<string> p1; 
if (p1 && p1->empty()) {
	*p1 = "h1"; // 如果p1指向一个空string，解引用p1，将一个新值赋予 string
}

1.1 shared_ptr类的操作

1.2 make_shared函数

  最安全的分配和使用动态内存的方法就是调用make_shared函数，此函数在内存中动态分配对象并初始化它，返回指向此对象的shared_ptr。make_shared 也定义在头文件 memory 中。

//指向一个值为42的int的shared_ptr
shared_ptr<int> p3 = make_shared<int>(42);
//p2指向一个值为'999999999'的string
shared_ptr<string> p4=make_shared<string>(10, '9');
//p3指向一个值初始化为0的int数
shared_ptr<int> p5 = make_shared<int>();

  类似顺序容器的 emplace 成员，make_shared用其参数来构造给定类型的对象。例如，调用 make_shared时传递的参数必须与 string 的某个构造函数相匹配。

当然，我们通常用auto定义一个对象来保存make_shared的结果：

auto p4 = make_shared<vector<string>>();

1.3 shared_ptr的拷贝赋值

  当进行拷贝或赋值操作时，每个shared_ptr都会记录有多少个其他shared_ptr指向相同的对象：

auto p = make_shared<int>(42); // p指向的对象只有 p 一个引用者
auto q(p); // p和q指向相同对象，此对象有两个引用者

  每个shared_ptr都有一个关联的计数器，通常称其为引用计数。

对shared_ptr类进行拷贝时，计数器就会增加。例如：当用一个shared_ptr初始化另一个shared_ptr、或者它作为参数传递给一个函数以及作为函数的返回值，它所关联的计数器就会增加当我们给让shared_ptr指向另一个对象或者shared_ptr销毁时，原对象的计数器就会递减一旦一个shared_ptr的计数器为0，就会自动释放该对象的内存。

auto r = make_shared<int>(42); // r指向的 int 只有一个引用者
r = q; // 给r赋值，那么： r原来所指的对象引用计数变为0，然后自动释放内存，q所指的对象的引用计数+1

1.4 shared_ptr的自动销毁对象内存机制

  当指向一个对象的最后一个shared_ptr对象被销毁时，shared_ptr类会自动销毁此对象。shared_ptr类是通过析构函数来完成销毁工作的。

shared_ptr还会自动释放相关联的内存

  当动态对象不再使用时，shared_ptr类会自动释放动态对象，这一特性使动态内存的使用变得容易。

  shared_ptr类所指向的内存何时被释放，与shared_ptr类的生存周期有关

  如：我们定义下面的函数返回一个share_ptr指针，指向一个Foo类型的动态分配的对象，对象是通过一个类型为T的参数进行初始化的：

shared_ptr<Foo> factory(T arg) {
    return make_share<Foo>(arg);//返回一个share_ptr类型的智能指针
}

  由于shared_ptr返回一个shared_ptr，所以我们可以确保它分配的对象会在恰当的时刻被释放。如：下面函数调用factory函数来生成一个shared_ptr指针，但是p一旦离开了作用域（use_factory函数），当p销毁时，将递减其引用计数并检查它是否为0，本例中，p是唯一引用 factory 返回的内存的对象。由于p将要销毁，p指向的这个对象也被销毁，因此p所指向的内存地址也就自动释放了。

void use_factory(T arg) {
    shared_ptr<Foo>  p=factory(arg);
}//函数结束之后，p就自动释放它所指向的对象的内存

  下面的函数也是 factory函数来生成一个shared_ptr指针，但是p指针通过返回值返回了，所以，如果有另一个shared_ptr指针调用了该函数，那么该p所指向的内存地址不会随着use_factory函数的调用而释放。

auto use_factory(T arg) {
    shared_ptr<Foo> p=factory(arg);
    return p;
}

1.5 使用动态生存期的资源的类

使用动态内存出于以下三种原因之一：

• 程序不知道自己需要使用多少对象
• 程序不知道所需对象的准确类型
• 程序需要多个对象间共享数据

使用动态内存的一个常见原因是允许多个对象共享相同的状态。

1.6 shared_ptr与new结合使用

  如果我们不初始化一个智能指针，它就会被初始化为一个空指针，我们也能用new返回的指针来初始化一个智能指针，因为，new申请的动态内存的使用、释放等规则仍然符合shared_ptr类的使用规则：

shared_ptr<double> p1; // shared_ptr可以指向一个double
shared_ptr<int> p2(new int(42)); // p2指向一个值为42的int   

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

shared_ptr<int> p=new int(1024);   //错误 
shared_ptr<int> p2(new int(1024)); //正确：使用直接初始化

  动态内存作为返回值时的使用手法：限于上面的使用语法，一个返回shared_ptr的函数不能在其返回语句中隐式转换为一个普通指针

shared_ptr<int> clone(int p)
{
    return new int(p); //错误
}
 
shared_ptr<int> clone(int p)
{
    return shared_ptr<int>(new int(p)); //正确
}

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

定义shared_ptr的其他方法：

1.7 不要混合使用普通/智能指针

  当一个函数的参数是shared_ptr类时，有以下规则：

• 函数的调用是传值调用

• 调用函数时，该shared_ptr类所指向的对象引用计数加1。但是函数调用完成之后，shared_ptr类自动释放，对象的引用计数又减1

void process(shared_ptr<int> ptr){ 
	... // 使用ptr
} // ptr 离开作用域，被销毁

shared_ptr<int> p(new int(42)); //初始化一个智能指针对象p，引用计数+1
process(p);  //p所指的对象引用计数=1，引用计数总数为2
//process函数调用之后，p所指的引用计数减1
int i=*p; //正确

函数参数使用时与new的关系：

  因为shared_ptr类会在生存周期结束之后，将引用计数减1，当引用计数为0时，会释放内存空间
下面是一个特殊的应用场景，需要注意

void process(shared_ptr<int> ptr){ ... }
 
int *x(new int(1024));
process(x);  //错误，不能将int*转换为一个shared_ptr<int>
process(shared_ptr<int>(x)); //合法的，但是process函数返回之后内存会被释放
int j=*x; //错误，x所指的内存已经被释放了

使用一个内置指针来访问一个智能指针所负责的对象是很危险的，因为我们无法知道对象何时被销毁。

1.8 不要使用 get 初始化另一个智能指针或为智能指针赋值

  shared_prt类的get函数返回一个内置指针，指向智能指针所管理的对象

  此函数的设计情况：我们需要向不能使用智能指针的代码传递一个内置指针

• get函数将内存的访问权限传递给一个指针，但是之后代码不会delete该内存的情况下，对get函数的使用才是最安全的。

• 永远不要用get初始化另一个智能指针或者为另一个智能指针赋值。

shared_ptr<int> p(new int(42));  //引用计数变为1
int *q=p.get();  //正确：使用q需要注意，不要让它管理的指针被释放
 
{//新语句块
    shared_ptr<int>(q); //用q初始化一个智能指针对象
} //语句块结束之后，智能指针对象释放它所指的内存空间
 
int foo=*p;//错误的，p所指的内存已经被释放了

1.9 reset、unique函数的使用

  reset函数会将shared_prt类原先所指的内存对象引用计数减1，并且指向于一块新的内存

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

  reset函数与unqie函数配合使用：在改变对象之前，检查自己是否为当前对象的唯一用户

shared_ptr<string> p=make_shared<string>("Hello");
 
if(!p.unique()) //p所指向的对象还有别的智能指针所指
    p.reset(new string(*p)); //现在可以放心的改变p了
 
*p+=newVal; //p所指向的对象只有自己一个智能指针，现在可以放心的改变对象的值了

1.10 异常处理

  当程序发生异常时，我们可以捕获异常来将资源被正确的释放。但是如果没有对异常进行处理，则有以下规则：

  shared_ptr的异常处理：如果程序发生异常，并且过早的结束了，那么智能指针也能确保在内存不再需要时将其释放

  new的异常处理：如果释放内存在异常终止之后，那么就造成内存浪费

voif f()
{
    shared_ptr<int> sp(new int(42));
    ...//此时抛出异常，未捕获，函数终止
}//shared_ptr仍然会自动释放内存

voif f()
{
    int *ip=new int(42);
    ...//此时抛出异常，未捕获
    delete ip; //在退出之前释放内存，此语句没有执行到，导致内存浪费
}

1.11 使用自己的释放操作

  当shared_ptr生命周期结束时，会调用默认的析构函数来释放(delete)自己所指向的内存空间。但是我们可以使用shared_prt的语法来指定删除器函数，那么在shared_ptr生命周期结束时就会自动调用这个函数。

示例：

下面是一个shared_ptr指定删除器函数以及避免内存泄露的例子

  错误操作：我们调用f函数来打开一个网络连接，但是在f函数调用之后没有关闭这个连接。因此就会造成内存的泄露

struct destination;    //连接的对象
struct connection;     //连接需要的信息
connection connect(destbination*); //打开连接
void disconnect(connection);       //关闭连接
void f(destination &d)
{
    connection c=connect(&d);//打开一个连接
    ....//使用这个连接
    
    //如果在f函数退出之前忘记调用disconnect函数，那么该连接就没有关闭
}

  正确操作：现在我们定义一个新的函数“end_connection”，并且配合shared_ptr类的使用。shared_ptr指定了一个删除器函数“end_connection”。因此下面的代码能够保证在f函数的各种调用结束时，保证连接正确的关闭

void end_connection(connection *p)
{
    disconnection (*p);
}
 
void f(destination &d)
{
    connection c=connect(&d);
    shared_ptr<connection> p(&c,end_connection);
    ....//使用这个连接
    
    //当f函数退出或者异常退出，p都会调用end_connection函数
}

1.12 shared_ptr与动态数组的使用

  与unique_ptr不同，shared_ptr不直接支持管理动态数组。如果希望使用shared_ptr管理动态数组，必须提供自己定义的删除器

  如果未提供删除器，shared_ptr默认使用delete删除动态数组，此时delete少一个“[]”，因为会产生错误

//本例中，传递给shared_ptr一个lambda作为删除器
shared_ptr<int> sp(new int[10], [](int *p) { delete[] p; } );
shared_ptr<int> sp2(new int[3]{1,2,3}, [](int *p) { delete[] p; });
sp2.reset();  //使用自己书写的lambda释放数组

  动态数组的访问：shared_ptr不支持点和箭头成员运算符访问数组，并且不提供下标运算符访问数组，只能通过get()函数来获取一个内置指针，然后再访问数组元素。

shared_ptr<int> sp(new int[3]{1,2,3}, [](int *p) { delete[] p; });
for (size_t i = 0; i != 3; ++i)
        *(sp.get() + i) = i;

总结

参考：

• C++ Primer 第五版 P400 - P406
• C++ Primer 第五版 P412 - P406

期待大家和我交流，留言或者私信，一起学习，一起进步！