【C++】详解RAII思想与智能指针

template<class T>
class smartptr {
public:
smartptr(T data)
{
cout << "smartptr(T data)" << endl;
_ptr = new T(data);
}
~smartptr()
{
cout << "~smartptr()" << endl;
delete _ptr;
}

private:
T* _ptr;
};

int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
int main()
{
try
{
smartptr<int> p1(1);
smartptr<int> p2(2);
div();
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}

我们可以看到，RAII思想实际上就是将资源的获取与释放封装到一个类中，在构造函数中获取资源，在析构函数中释放资源。我们不需要显式地释放资源，并且将资源与对象的生命周期绑定

输入3 0时，抛出除零异常，执行流跳转的同时，try块内部生命周期结束，此时会调用内部对象的析构函数，完成了资源的释放，避免了资源泄露。

二、智能指针

上述smartptr还不能被称作智能指针，因为它不具备指针的行为，我们还需要在类内部重载解引用*、访问->等操作，使其能像指针一样使用：

template<class T>
class smartptr {
public:
smartptr(T data = T())
{
_ptr = new T(data);
}
~smartptr(){
delete _ptr;
}
T& operator*(){
return *_ptr;
}
T* operator->(){
return _ptr;
}
private:
T* _ptr;
};

struct Date {
int _year;
int _month;
int _day;
};

int main()
{
smartptr<Date> p1;
p1->_year = 2024;
p1->_month = 11;
p1->_day = 9;
cout << (*p1)._year << "-" << (*p1)._month << "-" << (*p1)._day << endl;
return 0;
}

智能指针采用RAII原理来管理动态分配的内存，也是将资源的管理与对象的生命周期绑定，并且可以像普通指针那样进行*、->等操作。

下面我们来介绍一下C++98提供的auto_ptr智能指针：

1.auto_ptr

auto_ptr是C++98标准引入的一种智能指针，是RAII思想的体现，其核心功能是自动管理动态分配的内存，确保指针在超出作用域时，资源被正确释放，下面是它的主要实现原理：

实现原理

构造函数

auto_ptr的构造函数接受一个原始指针（裸指针），并将其封装成auto_ptr对象内部的指针：

auto_ptr<int> p(new int(10)); // 构造函数

析构函数

auto_ptr的析构函数会在对象生命周期结束时自动调用delete操作符，释放指针所指向的内存：

~auto_ptr() {
    delete _ptr;  // 释放内存
}

拷贝构造函数

与普通对象的拷贝构造函数不同，auto_ptr在拷贝时会转移其资源所有权给新对象。因此，拷贝构造后，原对象会变成一个空指针（指向nullptr）

auto_ptr(const auto_ptr& other) : _ptr(other._ptr) {
    other._ptr = nullptr;  // 将原对象的指针设为 nullptr，避免重复释放
}

赋值操作符

auto_ptr的赋值操作符也会转移资源所有权，先释放当前对象的资源，然后将传入的指针复制到当前对象，并将传入指针置空：

auto_ptr& operator=(const auto_ptr& other) {
    if (this != &other) {
        delete _ptr;  // 先释放当前资源
        _ptr = other._ptr;
        other._ptr = nullptr;  // 将 other 的指针置空
    }
    return *this;
}

成员访问

通过重载*、->实现指针的解引用与访问成员操作：

auto_ptr<int> p(new int(10));
*p = 20;  // 访问值

模拟实现

下面是对auto_ptr的简单模拟实现：

template<class T>
class auto_ptr
{
public:
        // 构造函数
auto_ptr(T* ptr)
:_ptr(ptr)
{}
        // 拷贝构造函数
auto_ptr(auto_ptr<T>& other)
:_ptr(other._ptr)
{
// 管理权转移
other._ptr = nullptr;
}
        // 赋值函数
auto_ptr operator=(const auto_ptr<T> other)
{
// 检测是否给自己赋值
if (*this != other)
{
// 释放当前资源
if (_ptr)
delete _ptr;
_ptr = other._ptr;
other._ptr = nullptr;
}
return *this;
}
        // 析构函数
~auto_ptr()
{
if(_ptr)
delete _ptr;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};

弊端

auto_ptr在拷贝和赋值时隐式地转移了资源所有权，会导致一些潜在的资源管理问题。

auto_ptr被拷贝时，源对象指针被置空，此时无法再进行访问：

auto_ptr<int> p1(new int(10));  // 创建 p1
auto_ptr<int> p2 = p1;          // p1 的资源转移给 p2，p1 变为 nullptr
cout << *p1 << std::endl;       // 错误，p1 已为空指针

这种隐性的资源转移，使得auto_ptr在传递和返回时不直观，比如，我们在函数调用对象时，希望资源可以被复制并共享，但是auto_ptr不允许资源的共享，可能会导致意料之外的资源转移：

void foo(auto_ptr<int> ptr) {
    // ptr 的资源所有权已经转移到 foo 函数的局部变量中
}

int main() {
    auto_ptr<int> p1(new int(10));
    foo(p1);  // p1 的资源被转移到 foo，p1 变为空指针
    cout << *p1 << std::endl;  // 错误，p1 已为空指针
}

auto_ptr在实际使用过程中，会引发许多不易察觉的错误，这并不是我们想要的智能指针，为了避免上述问题，C++11引入了更多新的智能指针，例如unique_ptr：

2.unique_ptr

为了避免所有权转移导致的一系列潜在问题，unique_ptr采用了一种简单粗暴的办法：禁止拷贝，禁止一切拷贝行为，从根源上解决了问题。

实现原理

禁止拷贝行为
编译器会禁止unique_ptr的拷贝构造与拷贝复制操作，试图拷贝将会报错：

std::unique_ptr<int> p1(new int(10));
// 编译错误，禁止拷贝构造
std::unique_ptr<int> p2 = p1; // 错误：拷贝构造被删除

明确的资源所有权转移

禁止拷贝并不意味着对资源所有权转移的全面封杀，实际上还是可以对资源进行转移的，只不过auto_ptr是隐式地转移，而unique_ptr是显式地进行转移：

unique_ptr<int> p1(new int(10));
unique_ptr<int> p2 = move(p1); // 明确转移资源所有权

// p1 现在为空指针，p2 拥有资源
cout << *p2 << endl;  // 输出 10
// cout << *p1 << endl; // 错误：p1 现在为空指针

模拟实现

那么unique_ptr在底层是怎么实现对拷贝的禁止的呢，其实是用到了delete关键字，在成员函数后面加上 = delete，表示禁止该成员函数的使用，通过delete删除拷贝构造函数与拷贝赋值函数，从而禁止了拷贝行为的发生：

template<class T>
class unique_ptr
{
public:
unique_ptr(T* ptr)
:_ptr(ptr)
{}
~unique_ptr()
{
if (_ptr)
delete _ptr;
}

// 指针操作
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}

// 不支持拷贝构造、拷贝赋值
unique_ptr(const unique_ptr<T>& other) = delete;
unique_ptr operator=(const unique_ptr<T> other) = delete;
private:
T* _ptr;
};

C++11还提供了一种智能指针，它支持拷贝行为，并且允许多个对象共享资源，即拷贝赋值并不会将原指针置空，而是让它们指向同一块空间：

3.shared_ptr

shared_ptr支持拷贝构造以及拷贝赋值，它们可以共享资源，各自进行操作，但要考虑一个问题：RAII的思想是将资源的获取和释放与对象的生命周期绑定，当我通过函数传参的方式将一个对象赋值给了另一个对象，会导致资源的提前释放（函数结束），这样外部指针就悬空了，共享的资源只需要进行一次释放即可，那么我们怎么知道何时释放资源呢？通过计数器的方式实现：

实现原理

shared_ptr通过引用计数来实现资源的正确释放，确保在所有共享该资源的shared_ptr对象都销毁后才释放资。

当另一个shared_ptr对象拷贝构造或者赋值时，引用计数增加，表示多了一个对象在共享资源；当shared_ptr对象析构或被赋值到新的对象时，引用计数减少，表示减少一个共享资源的持有者。

模拟实现

实现过程如下：

template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
:_ptr(ptr)
,_pCount(new int(0))
{
++* _pCount; // 增加计数
}
shared_ptr(shared_ptr<T>& other)
:_ptr(other._ptr)
,_pCount(other._pCount)
{
cout << "shared_ptr(shared_ptr<T>& other)" << endl;
++* _pCount; // 增加计数
}
shared_ptr operator=(shared_ptr<T>& other)
{
// 检测是否给自己赋值
if (_ptr  != other._ptr)
{
cout << "shared_ptr operator=(const shared_ptr<T>& other)" << endl;
--* _pCount; // 减少当前资源的计数
// 释放当前资源
if (*_pCount == 0)
{
delete _ptr;
delete _pCount;
}
_ptr = other._ptr;
_pCount = other._pCount;
++* _pCount; // 增加新资源的计数
}
return *this;
}
~shared_ptr()
{
--* _pCount; // 减少计数
if (*_pCount == 0)
{
                // 共享对象全部销毁，进行析构
cout << "~shared_ptr()" << endl;
delete _ptr;
delete _pCount;
}
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
int* _pCount;
};

shared_ptr适用于绝大多数场景，但是在某些场景下，会引发循环引用问题，此时资源不能得到正确释放：

循环引用问题

来看下面这段代码：

struct ListNode
{
int _data;
shared_ptr<ListNode> _prev;
shared_ptr<ListNode> _next;
~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
shared_ptr<ListNode> node1(new ListNode);
shared_ptr<ListNode> node2(new ListNode);
cout << node1.use_count() << endl;
cout << node2.use_count() << endl;
node1->_next = node2;
node2->_prev = node1;
cout << node1.use_count() << endl;
cout << node2.use_count() << endl;
return 0;
}

我们将节点的_prev和_next定义成shared_ptr智能指针，并定义了两个节点，节点2的_prev指向节点1，节点1的_next指向节点2:

这个时候会造成什么结果呢，我们来看运行结果：

node1的_next和node2共享资源，所以它们的计数为2，node2的_prev和node1共享资源，所以它们的计数也为2，从运行结果可以看出，节点空间没有得到释放（没有打印"~ListNode()"内容），这是为什么呢？

由于Node1和Node2的相互引用，它们的任意一个要想释放空间，都得建立在对方已经释放空间的基础上，于是乎两者都不能正常进行空间释放，这就是循环引用问题。

4.weak_ptr

C++11提供了一种弱引用智能指针weak_ptr，它的出现就是为了解决循环引用问题的，其原理是：weak_ptr是对对象的弱引用，不会增加计数，不会阻止资源的释放。

由于互相指向时，计数没有增加，所以最后析构函数正常调用，资源得到释放。

以上就是对RAII思想及智能指针的介绍与个人理解，欢迎指正~

码文不易，还请多多关注支持，这是我持续创作的最大动力！

原文地址：https://blog.csdn.net/dhgiuyawhiudwqha/article/details/143644132

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：书生大模型基础岛第一关书生大模型全链路开源体系
下一篇：【计网不挂科】计算机网络期末考试——【选择题＆填空题＆判断题＆简述题】试卷（3）

Web 学习笔记 - 网络安全
作为前端开发者，了解一点 Web 安全方面的基本知识是有很必要的，未必就要深入理解。本文主要介绍常见的网络攻击类型，不作深入探讨。CSRF（Cross-site request forgery跨站请
阅读更多2024-11-26
14 —— Webpack解析别名
— 在webpack.config.js中配置解析别名@来代表src绝对路径。这么使用相对路径不安全。
阅读更多2024-11-26
【eNSP】动态路由协议RIP和OSPF
动态路由RIP（Routing Information Protocol，路由信息协议）和OSPF（Open Shortest Path First，开放式最短路径优先）是两种常见的动态路由协议，它们
阅读更多2024-11-26
【多线程-第一天-多线程的技术方案-pthread演示 Objective-C语言】
【多线程-第一天-多线程的技术方案-pthread演示 Objective-C语言】
阅读更多2024-11-26
如何定制谷歌浏览器的外观主题
无论是更改背景颜色、开启文本光标模式还是解决上传文件失败的问题，这些定制选项都能帮助你打造更加个性化的浏览体验。随着技术的不断发展，我们相信谷歌浏览器将会提供更多丰富和实用的定制选项，以满足用户日益增
阅读更多2024-11-26
即时通讯平台-音视频即时通讯平台就选WorkPlus
在现代社会，企业和组织对沟通的需求日益增加，尤其是在瞬息万变的商业环境中，音视频即时通讯已成为沟通的主流形式。WorkPlus作为一款专注于音视频即时通讯的平台，凭借其强大的功能和出色的用户体验，成为
阅读更多2024-11-26
vue中el-table合并单元格
1.在el-table中添加 :span-method=“handdelSpanMethod”2.handdelSpanMethod方法。
阅读更多2024-11-26
2022年计算机网络408考研真题解析
题目中提到了下发二字，如果这题不会的话，可以直接蒙个南向接口，因为上北下南。。。SDN控制器有控制层面和数据层面上下两个层面，通过北向API控制网络控制应用层序，通过南向API控制分组交换机。综上所述
阅读更多2024-11-26
滑动窗口最大值(java)
给你一个整数数组nums，有一个大小为k的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的k个数字。滑动窗口每次只向右移动一位。返回滑动窗口中的最大值。滑动窗口的位置
阅读更多2024-11-26
（原创）Android Studio新老界面UI切换及老版本下载地址
这两天下载了一个新版的Android Studio，发现整个界面都发生了很大改动：但是对于一些急着开发的小伙伴来说，没有时间去适应，那么怎么办呢？只能先下回老的，或者看有没有版本支持新老ui界面的切换
阅读更多2024-11-26

【C++】详解RAII思想与智能指针

引言

内存泄漏

内存泄漏的危害

内存泄漏的处理

一、RAII思想

二、智能指针

1.auto_ptr

实现原理

模拟实现

弊端

2.unique_ptr

实现原理

模拟实现

3.shared_ptr

实现原理

模拟实现

循环引用问题

4.weak_ptr

相关文章