c++智能指针详解

  • A+
所属分类:C/C++

1.什么是智能指针

从比较简单的层面来看,智能指针是RAII(Resource Acquisition Is Initialization,资源获取即初始化)机制对普通指针进行的一层封装。这样使得智能指针的行为动作像一个指针,本质上却是一个对象,这样可以方便管理一个对象的生命周期。

在c++中,智能指针一共定义了4种:
auto_ptr、unique_ptr、shared_ptr 和 weak_ptr。其中,auto_ptr 在 C++11已被摒弃,在C++17中已经移除不可用。

2.原始指针的问题

原始指针的问题大家都懂,就是如果忘记删除,或者删除的情况没有考虑清楚,容易造成悬挂指针(dangling pointer)或者说野指针(wild pointer)。

我们看个简单的例子

objtype *p = new objtype();
p -> func();
delete p;

上面的代码结构是我们经常看到的。里面的问题主要有以下两点:
1.代码的最后,忘记执行delete p的操作。
2.第一点其实还好,比较容易发现也比较容易解决。比较麻烦的是,如果func()中有异常,delete p语句执行不到,这就很难办。有的同学说可以在func中进行删除操作,理论上是可以这么做,实际操作起来,会非常麻烦也非常复杂。

此时,智能指针就可以方便我们控制指针对象的生命周期。在智能指针中,一个对象什么情况下被析构或被删除,是由指针本身决定的,并不需要用户进行手动管理,是不是瞬间觉得幸福感提升了一大截,有点幸福来得太突然的意思,终于不用我自己手动删除指针了。

3.unique_ptr

unique_ptr是独享被管理对象指针所有权(owership)的智能指针。unique_ptr对象封装一个原始指针,并负责其生命周期。当该对象被销毁时,会在其析构函数中删除关联的原始指针。

创建unique_ptr:

#include <iostream>
#include <string>
#include <memory>
using namespace std;

void f1() {
   
    unique_ptr<int> p(new int(5));
    cout<<*p<<endl;
}

上面的代码就创建了一个unique_ptr。需要注意的是,unique_ptr没有复制构造函数,不支持普通的拷贝和赋值操作。因为unique_ptr独享被管理对象指针所有权,当p2, p3失去p的所有权时会释放对应资源,此时会执行两次delete p的操作。

void f1() {
   
    unique_ptr<int> p(new int(5));
    cout<<*p<<endl;
    unique_ptr<int> p2(p);
    unique_ptr<int> p3 = p;
}

对于p2,p3对应的行,IDE会提示报错

无法引用 函数 "std::__1::unique_ptr<_Tp, _Dp>::unique_ptr(const std::__1::unique_ptr<int, std::__1::default_delete<int>> &) [其中 _Tp=int, _Dp=std::__1::default_delete<int>]" (已隐式声明) -- 它是已删除的函数

unique_ptr虽然不支持普通的拷贝和赋值操作,但却可以将所有权进行转移,使用std::move方法即可。

void f1() {
   
    unique_ptr<int> p(new int(5));
    unique_ptr<int> p2 = std::move(p);
    //error,此时p指针为空: cout<<*p<<endl; 
    cout<<*p2<<endl;
}

unique最常见的使用场景,就是替代原始指针,为动态申请的资源提供异常安全保证。

objtype *p = new objtype();
p -> func();
delete p

前面我们分析了这部分代码的问题,如果我们修改一下

unique_ptr<objtype> p(new objtype());
p -> func();
delete p

此时我们只要unique_ptr创建成功,unique_ptr对应的析构函数都能保证被调用,从而保证申请的动态资源能被释放掉。

4.shared_ptr

我们提到的智能指针,很大程度上就是指的shared_ptr,shared_ptr也在实际应用中广泛使用。它的原理是使用引用计数实现对同一块内存的多个引用。在最后一个引用被释放时,指向的内存才释放,这也是和 unique_ptr 最大的区别。当对象的所有权需要共享(share)时,share_ptr可以进行赋值拷贝。
shared_ptr使用引用计数,每一个shared_ptr的拷贝都指向相同的内存。每使用他一次,内部的引用计数加1,每析构一次,内部的引用计数减1,减为0时,删除所指向的堆内存。

std::shared_ptr<int> p4 = new int(1)

上面这种写法是错误的,因为右边得到的是一个原始指针,前面我们讲过shared_ptr本质是一个对象,将一个指针赋值给一个对象是不行的。

void f2() {
   
    shared_ptr<int> p = make_shared<int>(1);
    shared_ptr<int> p2(p);
    shared_ptr<int> p3 = p;
}

以上写法都是可以的

void f2() {
   
    shared_ptr<int> p = make_shared<int>(1);
    int *p2 = p.get();
    cout<<*p2<<endl;
}

上面的写法,可以获取shared_ptr的原始指针。

5.shared_ptr使用需要注意的点

5.1 不能将一个原始指针初始化多个shared_ptr

void f2() {
   
    int *p0 = new int(1);
    shared_ptr<int> p1(p0);
    shared_ptr<int> p2(p0);
    cout<<*p1<<endl;
}

上面代码就会报错。原因也很简单,因为p1,p2都要进行析构删除,这样会造成原始指针p0被删除两次,自然要报错。

5.2.循环引用问题

shared_ptr最大的坑就是循环引用。引用网络上的一个例子:

struct Father
{
   
    shared_ptr<Son> son_;
};

struct Son
{
   
    shared_ptr<Father> father_;
};

int main()
{
   
    auto father = make_shared<Father>();
    auto son = make_shared<Son>();

    father->son_ = son;
    son->father_ = father;

    return 0;
}

该部分代码会有内存泄漏问题。原因是
1.main 函数退出之前,Father 和 Son 对象的引用计数都是 2。
2.son 指针销毁,这时 Son 对象的引用计数是 1。
3.father 指针销毁,这时 Father 对象的引用计数是 1。
4.由于 Father 对象和 Son 对象的引用计数都是 1,这两个对象都不会被销毁,从而发生内存泄露。

为避免循环引用导致的内存泄露,就需要使用 weak_ptr。weak_ptr 并不拥有其指向的对象,也就是说,让 weak_ptr 指向 shared_ptr 所指向对象,对象的引用计数并不会增加。
使用 weak_ptr 就能解决前面提到的循环引用的问题,方法很简单,只要让 Son 或者 Father 包含的 shared_ptr 改成 weak_ptr 就可以了。

struct Father
{
   
    shared_ptr<Son> son_;
};

struct Son
{
   
    weak_ptr<Father> father_;
};

int main()
{
   
    auto father = make_shared<Father>();
    auto son = make_shared<Son>();

    father->son_ = son;
    son->father_ = father;

    return 0;
}

1.main 函数退出前,Son 对象的引用计数是 2,而 Father 的引用计数是 1。
2.son 指针销毁,Son 对象的引用计数变成 1。
3.father 指针销毁,Father 对象的引用计数变成 0,导致 Father 对象析构,Father 对象的析构会导致它包含的 son_ 指针被销毁,这时 Son 对象的引用计数变成 0,所以 Son 对象也会被析构。

6.智能指针小结

我们该如何选择智能指针:

如果程序要使用多个指向同一个对象的指针,应选择 shared_ptr。这样的情况包括
1.有一个指针数组,并使用一些辅助指针来标示特定的元素,如最大的元素和最小的元素;
2.两个对象包含都指向第三个对象的指针;
3.STL 容器包含指针。很多 STL 算法都支持复制和赋值操作,这些操作可用于 shared_ptr,但不能用于 unique_ptr(编译器发出 warning)和 auto_ptr(行为不确定)。如果你的编译器没有提供 shared_ptr,可使用 Boost 库提供的 shared_ptr。

如果程序不需要多个指向同一个对象的指针,则可使用 unique_ptr。如果函数使用 new 分配内存,并返还指向该内存的指针,将其返回类型声明为 unique_ptr 是不错的选择。这样,所有权转让给接受返回值的 unique_ptr,而该智能指针将负责调用 delete。

参考文献

https://zhuanlan.zhihu.com/p/461837602

w3cjava

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: