C++智能指针之shared_ptr

前言
一、Shared_ptr
- 1.1 shared_ptr类的操作
- 1.2 make_shared函数
- 1.3 shared_ptr的拷贝赋值
- 1.4 shared_ptr的自动销毁对象内存机制
- 1.5 使用动态生存期的资源的类
- 1.6 shared_ptr与new结合使用
- 1.7 不要混合使用普通/智能指针
- 1.8 不要使用 get 初始化另一个智能指针或为智能指针赋值
- 1.9 reset、unique函数的使用
- 1.10 异常处理
- 1.11 使用自己的释放操作
- 1.12 shared_ptr与动态数组的使用
总结

前言

在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;

var code = “a26143db-0210-41e9-a85f-ce01ea73e815”

总结

参考：

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

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

C++智能指针之shared_ptr相关推荐

C++ 智能指针std::shared_ptr简单使用和理解
参考:https://blog.csdn.net/u011068702/article/details/83692838 1 智能指针std::shared_ptr相关知识和如何使用我们这里先说下 ...
C++之智能指针std::shared_ptr简单使用和理解
前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家.点击跳转到教程 1 智能指针std::shared_ptr相关知识和如何使用我们这里先说下智能指针std::sha ...
【C++11新特性】 C++11智能指针之shared_ptr
http://blog.csdn.net/Xiejingfa/article/details/50750037 原创作品,转载请标明:http://blog.csdn.net/Xiejingfa/ar ...
C++ 实现智能指针：shared_ptr 和 unique_ptr
简述: C++11 智能指针的深入分析,和动手实现简版的智能指针 std::shared_ptr .std::unique_ptr 文章目录背景 std::shared_ptr 原理代码 ref ...
c语言 ptr 用法,C++之智能指针std::shared_ptr简单使用和理解
1 智能指针std::shared_ptr相关知识和如何使用我们这里先说下智能指针std::shared_ptr,因为我看到我我们项目c++代码里面用得很多,我不是不会,所以记录学习下先让ubu ...
C++11 智能指针之shared_ptr
0.Overview 在实际的 C++ 开发中,我们经常会遇到诸如程序运行中突然崩溃.程序运行所用内存越来越多最终不得不重启等问题,这些问题往往都是内存资源管理不当造成的.比如: 有些内存资源已经被释 ...
智能指针之shared_ptr易错点05
一 shared_ptr易错点 1 慎用裸指针给shared_ptr赋值例1 class A {public:A() {};A(int i) {m_i=i;cout<<"A&q ...
【C++11智能指针】shared_ptr的初始化、拷贝构造和拷贝赋值、移动构造和移动赋值
文章目录 1.智能指针概述 2.shared_ptr的初始化 2.1 shared_ptr和new结合使用(直接初始化) 2.2 make_shared函数 3.shared_ptr的拷贝构造和拷贝赋 ...
C++ 智能指针(unique_ptr / shared_ptr)代码实现
文章目录 unique_ptr 智能指针的实现 shared_ptr 智能指针的实现指针类型转换 unique_ptr 智能指针的实现一个对象只能被单个unique_ptr 所拥有. #inclu ...

C++智能指针之shared_ptr

C++智能指针之shared_ptr

前言

一、Shared_ptr

1.1 shared_ptr类的操作

1.2 make_shared函数

1.3 shared_ptr的拷贝赋值

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

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

1.6 shared_ptr与new结合使用

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

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

1.9 reset、unique函数的使用

1.10 异常处理

1.11 使用自己的释放操作

1.12 shared_ptr与动态数组的使用

总结

C++智能指针之shared_ptr相关推荐

最新文章

热门文章