智能指针c++11-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

总结

到此这篇关于c++智能指针的文章就介绍到这了,更多相关c++智能指针内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.adminjs.cn！