C++中的智能指针

已于 2024-04-23 17:52:14 修改
阅读量785 收藏 9
点赞数 17
分类专栏： # C\Cpp # ROS2 文章标签： c++ 开发语言 算法
于 2024-04-23 17:50:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44940689/article/details/138134286
版权
C\Cpp 同时被 2 个专栏收录
31 篇文章 24 订阅
订阅专栏
ROS2
14 篇文章 7 订阅
订阅专栏
本文详细介绍了C++中的智能指针，包括它们为何需要、不同类型（std::shared_ptr、std::unique_ptr和std::weak_ptr）的工作原理、示例以及它们在内存管理和引用计数中的应用。特别关注了std::make_shared和弱引用的概念。
摘要由CSDN通过智能技术生成

C++中的智能指针

文章目录

笔者在学习ROS2的过程中，遇到了std::make_shared这种用法，一眼看不懂，才发现笔者对于Cpp 11/17/20的一些新特性还不太了解，于是查找了许多资料写成此文，感谢诸君的分享。

1.为什么需要智能指针？

在C++中，智能指针是一种用于管理动态分配对象的内存工具，它们自动处理内存的分配和释放，并且提供方便的对象所有权管理。说到动态分配内存，很多读者肯定想到了new和delete这两个关键字，智能指针也是类似的内存管理的功能，只不过智能指针会更加安全。举个例子：

#include <iostream>

class Foo{
public:
    Foo(int value) {
        this-> myval = value;
        std::cout << "This is construct function!" << std::endl;
    }

    ~Foo() {
        std::cout << "This is destruct function!" << std::endl;
    }

    int getValue() {
        return this->myval;
    }

private:
    int myval = 10;
};

int main() {
    Foo *foo = new Foo(10);
    delete foo;
    return 0;
}

Output：

This is construct function!
This is destruct function!

我们正确使用new和delete的情况下，程序正常运行，但如果我们忘记使用delete来恢复空间的时候，会产生如下的异常从而导致内存泄漏

int main() {
    Foo *foo = new Foo;
    return 0;
}

如图所示

Image

使用智能指针可以在超过其作用域的时候，自动进行释放而无需手动delete，提升了程序的安全性。举个例子：

#include <iostream>
#include <memory>

class Foo{
private:
    int myval;

public:
    Foo(int value) {
        this->myval = value;
        std::cout << "This is construct function!" << std::endl;
    }

    ~Foo() {
        std::cout << "This is destruct function!" << std::endl;
    }

    int getValue() {
        return this->myval;
    }
};

int main() {
    std::unique_ptr<Foo> foo_up(new Foo(42));
    std::cout << "Call of operator '->' that value of foo is " << foo_up->getValue() << std::endl;
    std::cout << "Call of operator '*' that value of foo is " << (*foo_up).getValue() << std::endl;
    return 0;
}   // foo_up is deleted automatically here

Output:

This is construct function!
Call of operator '->' that value of foo is 10
Call of operator '*' that value of foo is 10
This is destruct function!

可见我们使用智能指针std::unique_ptr可以有效地保证安全性，使用智能指针首先需要先包含头文件<memory>。智能指针可以像普通指针一样使用指针运算符（->和*）访问封装指针，这是因为智能指针重载了这些运算符。

2.智能指针的类型

一共有四种类型的智能指针std::auto_ptr、std::unique_ptr、std::shared_ptr、std::weak_ptr，其中std::auto_ptr是C++11标准推出的，在C++17已经被弃用了。我们重点关注std::unique_ptr、std::shared_ptr、std::weak_ptr这三个智能指针，使用这三个智能指针需要包含头文件<memory>。

在介绍智能指针之前，我们先了解一下引用计数，引用计数的基本思想是对于动态分配的对象，进行引用计数的时候，每当增加一次对同一个对象的引用，那么引用对象的引用计数就会增加一次，每删除一次对同一个对象的引用，引用计数就会删除一次，当一个对象的引用计数为零的时候，就自动释放该对象存放的内存。

2.1 std::shared_ptr

std::shared_ptr是一种智能指针，它能够记录有多少个shared_ptr指向同一个对象，当引用计数为零的时候会将对象自动删除，这样就避免了显示地调用delete。

引用计数可以帮助我们不显示调用delete，但是我们还需要显示地调用new进行创建，这是一种不对等的方式，所以在C++ 17中提出了std::make_shared方法来创建智能指针shared_ptr，std::make_shared会分配创建传入参数中的对象，并且返回这个对象类型的std::shared_ptr，这样就避免了我们显示使用new。但我们也可以显示地使用new来构建一个shared_ptr，如下：

auto ptr = std::make_shared<int> (10);		// use 'std::make_shared' to construct a shared_ptr
std::shared_ptr<int> ptr (new int(10));		// use 'new' to construct a shared_ptr

举个基本的使用例子：

#include <iostream>
#include <memory>
void add_(std::shared_ptr<int> p) {
    (*p) ++;
    return;
}

int main() {
    // Constructed a std::shared_ptr
    // std::shared_ptr<int> ptr (new int(10));  // we also can use 'new' to construct a shared_ptr
    auto ptr = std::make_shared<int> (10);
    std::cout << *ptr << std::endl;     // cout 10
    add_(ptr);
    std::cout << *ptr << std::endl;     // cout 11
    return 0;
} // The shared_ptr will be destructed here

Output:

10
11

std::shared_ptr顾名思义是可以进行共享的，我们可以将其复制给别的对象，并且曾加一次对原对象的引用，可以使用get()方法来返回一个原始指针，通过reset()方法来减少一个引用计数，即抛弃当前的指针，通过use_count()方法来查看一个对象的引用次数。举个例子：

#include <iostream>
#include <memory>
void add_(std::shared_ptr<int> p) {
    (*p) ++;
    return;
}

int main() {
    // Constructed a std::shared_ptr
    auto ptr1 = std::make_shared<int> (10);
    // Reference count add twice
    auto ptr2 = ptr1;
    auto ptr3 = ptr1;
    // Check the value of ptr1,ptr2,ptr3
    std::cout << "ptr1.use_count() is " << ptr1.use_count() << ", `*ptr1` is "  << *ptr1 << ", address of ptr1 is " << ptr1 << std::endl;
    std::cout << "ptr2.use_count() is " << ptr2.use_count() << ", `*ptr2` is "  << *ptr2 << ", address of ptr2 is " << ptr2 << std::endl;
    std::cout << "ptr3.use_count() is " << ptr3.use_count() << ", `*ptr3` is "  << *ptr3 << ", address of ptr3 is " << ptr3 << std::endl;
    std::cout << std::endl;

    ptr2.reset();
    std::cout << "ptr1.use_count() is " << ptr1.use_count() << ", `*ptr1` is "  << *ptr1 << ", address of ptr1 is " << ptr1 << std::endl;
    std::cout << "ptr2.use_count() is " << ptr2.use_count() << ", address of ptr2 is " << ptr2 << std::endl;        // ptr2 reset, clear the address of ptr2
    std::cout << "ptr3.use_count() is " << ptr3.use_count() << ", `*ptr3` is "  << *ptr3 << ", address of ptr3 is " << ptr3 << std::endl;
    std::cout << std::endl;

    ptr3.reset();
    std::cout << "ptr1.use_count() is " << ptr1.use_count() << ", `*ptr1` is "  << *ptr1 << ", address of ptr1 is " << ptr1 << std::endl;
    std::cout << "ptr2.use_count() is " << ptr2.use_count() << ", address of ptr2 is " << ptr2 << std::endl;
    std::cout << "ptr3.use_count() is " << ptr3.use_count() << ", address of ptr3 is " << ptr3 << std::endl;        // ptr3 reset, clear the address of ptr3
    std::cout << std::endl;

    auto original_ptr = ptr1.get();
    std::cout << "ptr1.use_count() is " << ptr1.use_count() << ", `*ptr1` is "  << *ptr1 << ", address of ptr1 is " << ptr1 << std::endl;
    std::cout << "ptr2.use_count() is " << ptr2.use_count() << ", address of ptr2 is " << ptr2 << std::endl;
    std::cout << "ptr3.use_count() is " << ptr3.use_count() << ", address of ptr3 is " << ptr3 << std::endl; 
    std::cout << "*original_ptr is " << *original_ptr << ", address of original_ptr is " << original_ptr <<std::endl;

    return 0;
} // The shared_ptr will be destructed here

Output:

ptr1.use_count() is 3, `*ptr1` is 10, address of ptr1 is 0x573a3a29eec0
ptr2.use_count() is 3, `*ptr2` is 10, address of ptr2 is 0x573a3a29eec0
ptr3.use_count() is 3, `*ptr3` is 10, address of ptr3 is 0x573a3a29eec0

ptr1.use_count() is 2, `*ptr1` is 10, address of ptr1 is 0x573a3a29eec0
ptr2.use_count() is 0, address of ptr2 is 0
ptr3.use_count() is 2, `*ptr3` is 10, address of ptr3 is 0x573a3a29eec0

ptr1.use_count() is 1, `*ptr1` is 10, address of ptr1 is 0x573a3a29eec0
ptr2.use_count() is 0, address of ptr2 is 0
ptr3.use_count() is 0, address of ptr3 is 0

ptr1.use_count() is 1, `*ptr1` is 10, address of ptr1 is 0x573a3a29eec0
ptr2.use_count() is 0, address of ptr2 is 0
ptr3.use_count() is 0, address of ptr3 is 0
*original_ptr is 10, address of original_ptr is 0x573a3a29eec0

可以看出，使用get()返回一个原始指针并不会减少引用计数。

2.2 std::unique_ptr

std::unique_ptr是一种独占所有权的智能指针，它确保在任何时候都只有一个指针可以管理对象，它不进行共享，也无法复制到其他的unique_ptr，无法通过值传递到函数，只能移动unique_ptr。同样，我们也有两种方式可以来构建unique_ptr

std::unique_ptr<int> ptr = std::make_unique<int>(20);	// use 'std::make_unique' to construct a unique_ptr
std::unique_ptr<int> ptr (new int(20));					// use 'new' to construct a unique_ptr

unique_ptr同样提供了get()方法用于获取原始指针，我们不能将unique_ptr副值给别的变量，但是我们可以使用std::move()方法将其转移给其他的unique_ptr，举个例子：

#include <iostream>
#include <memory>

class Foo {
public:

    Foo(int value) {
        this-> myval = value;
        std::cout << "Foo::Foo" << std::endl;
    }
    ~Foo() {
        std::cout << "Foo::~Foo" << std::endl;
    }

    int myval;
    void printval() {
        std::cout << "Value is " << myval << std::endl;
    }
};

void addone(Foo& foo) {
    foo.myval++;
    std::cout << "add 1" << std::endl;
}

int main() {
    // Constructed a std::unique_ptr
    auto ptr1 = std::make_unique<Foo>(1);
    if (ptr1 != nullptr) ptr1->printval();
    {
        auto ptr2 = std::move(ptr1);	// move unique_ptr to ptr2
        addone(*ptr2);
        if (ptr2 != nullptr) ptr2->printval();
        if (ptr1 != nullptr) ptr1->printval();
        else std::cout << "ptr1 is destoryed" << std::endl;

        ptr1 = std::move(ptr2);		// move unique_ptr to ptr1
        if (ptr2 != nullptr) ptr2->printval();
        else std::cout << "ptr2 is destoryed" << std::endl;
    }
    return 0;
} // The unique_ptr will be destructed here

Output:

Foo::Foo
Value is 1
add 1
Value is 2
ptr1 is destoryed
ptr2 is destoryed
Foo::~Foo

2.3 std::weak_ptr

按理来说，使用shared_ptr和unique_ptr已经能够满足大多数场景的需求了，为什么还需要一个weak_ptr呢，这是因为，shared_ptr当存在交叉引用的时候，仍然会导致内存泄漏的问题，举个例子：

#include <iostream>
#include <memory>
class A;
class B;

class A {
public:
    std::shared_ptr<B> pointer;
    A() {
        std::cout << "Construct A" << std::endl;
    }
    ~A() {
        std::cout << "Destory A" << std::endl;
    }
};

class B {
public:
    std::shared_ptr<A> pointer;
    B() {
        std::cout << "Construct B" << std::endl;
    }
    ~B() {
        std::cout << "Destory B" << std::endl;
    }
};

int main() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->pointer = b;
    b->pointer = a;

    return 0;
}

Output:

Construct A
Construct B

可以看到A和B并没有析构，说明这两块内存还没有得到释放，这是由于我们存在交叉引用，下面这张图很好的说明了这一点

Image

这是因为a,b内部的pointer同时又引用了a,b，这使得a,b的引用计数变为2了，离开作用域的时候，a,b的智能指针被析构，只能让这块区域的引用计数-1,这样就导致了a,b的引用计数不为零，造成了内存泄漏。

解决这个问题的好方式是使用std::weak_ptr，std::weak_ptr是一种弱引用，这种弱引用不会引起引用计数的增加，当换作弱引用的时候，最终的释放流程如图所示

Image 
#include <iostream>
#include <memory>
class A;
class B;

class A {
public:
    std::weak_ptr<B> pointer;
    A() {
        std::cout << "Construct A" << std::endl;
    }
    ~A() {
        std::cout << "Destory A" << std::endl;
    }
};

class B {
public:
    std::weak_ptr<A> pointer;
    B() {
        std::cout << "Construct B" << std::endl;
    }
    ~B() {
        std::cout << "Destory B" << std::endl;
    }
};

int main() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->pointer = b;
    b->pointer = a;

    return 0;
}

Output:

Construct A
Construct B
Destory B
Destory A

需要注意的是std::weak_ptr只提供对一个或多个 shared_ptr 实例拥有的对象的访问，但不参与引用计数。 如果你想要观察某个对象但不需要其保持活动状态，请使用该实例，也就是说weak_ptr不能使用->和*来访问实例对象的方法。

Reference

[1]智能指针（现代 C++）

[2]现代C++教程：高速上手C++ 11/14/17/20

木心
关注
专栏目录
C++中智能指针详解
king_weng的博客
08-29 1498
1、问题引入 在C++中，静态内存和栈内存外，还有一部分内存称为堆程序用堆来存储动态分配的对象即那些在程序运行时分配的对象，当动态对象不再使用时，我们的代码必须显式的销毁它们。在C++中一般使用“new”：在动态内存中为对象分配一块空间并返回一个指向该对象的指针，“delete”：指向一个动态独享的指针，销毁对象，并释放与之关联的内存。 动态内存管理经常会出现两种问...
C++ 智能指针
TABE_的博客
05-29 7975
C++STL共提供了四个智能指针: auto_ptr, unique_ptr,shared_ptr, weak_ptr 其中C++11只支持后三个，C++98支持所有四个。 STL智能指针auto_ptrunique_ptrshared_ptrweak_ptrshare_ptr和weak_ptr的核心实现Counter简单实现share_ptr的简单实现weak_ptr简单实现 auto_ptr auto_ptr采用所有权模式，下面有一个例子： auto_ptr<string> p1 (new
C++智能指针
05-24
C++ 中推出了强大的智能指针smart_ptr ，本文具体说说 shared_ptr 和 weak_ptr ，特别是 enable_shared_from_this 和 shared_from_this
C++中智能指针的设计和使用
编程资料大全
05-12 349
智能指针(smart pointer)是存储指向动态分配（堆）对象指针的类，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造...
『 C++ 』智能指针 ( 万字梳理 )
最新发布
小侯宝的博客
08-08 1469
现代智能指针提供了一个自定义的删除器使智能指针通过包含不同的对象来对其进行特殊的删除;以shared_ptr为例,存在一个包含特定的类内模板函数的构造函数,支持传入一个自定义删除器对特殊的资源完成特殊的资源清理工作;其传入的自定义删除器可以为任何可调用对象,lambda表达式,function包装器,bind绑定对象,仿函数等可调用对象;});// 使用定制删除器(lambda表达式)关闭文件});
C++中智能指针如何设计和使用
12-26
智能指针(smart pointer)是存储指向动态分配（堆）对象指针的类，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个...
C++中智能指针的设计和使
05-17
### C++中智能指针的设计和使用 #### 智能指针概述 在C++中，智能指针是一类特殊的设计模式，旨在通过模仿原始指针的行为来提供额外的安全性和资源管理机制。它们通常用来解决传统指针所带来的内存泄漏问题和其他...
C++的智能指针
Edidaughter的博客
05-16 236
大佬的讲解
c++中的智能指针
newyher的专栏
03-19 1045
c++中的智能指针C++11中新增的智能指针unique_ptrshared_ptrweak_ptr功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 C++11中新增的智能指针 c++是一门讲究效率的语言，这就导致很多的内存管理需要
c++中智能指针的用法
08-05
在C++中，智能指针是一种封装了动态分配内存的指针类，用于自动处理内存的分配和释放，避免内存泄漏的问题。C++中有三种智能指针：std::unique_ptr、std::shared_ptr和std::weak_ptr（C++11中摒弃了auto_ptr）。它们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

木心

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值