首页 > 编程学习 > C++智能指针之shared_ptr

C++智能指针之shared_ptr

发布时间:2022/11/27 9:44:38

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;

总结

参考:

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

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

Copyright © 2010-2022 dgrt.cn 版权所有 |关于我们| 联系方式