【C++ 学习 ㊱】- 智能指针详解

目录

一、为什么需要智能指针？

二、智能指针的原理及使用

三、auto_ptr

3.1 - 基本使用

3.2 - 模拟实现

四、unique_ptr

4.1 - 基本使用

4.2 - 模拟实现

五、shared_ptr

5.1 - 基本使用

5.2 - 模拟实现

六、weak_ptr

6.1 - shared_ptr 的循环引用问题

6.2 - 模拟实现

七、定制删除器

一、为什么需要智能指针？

问题引入：

#include <iostream>
using namespace std;
​
int division(int x, int y)
{
    if (y == 0)
        throw "Division by zero condition!";
    else
        return x / y;
}
​
void func()
{
    string* p1 = new string("hello");
    pair<string, string>* p2 = new pair<string, string>{ "hello", "你好" };
​
    int a = 0, b = 0;
    cin >> a >> b;
    cout << division(a, b) << endl;
​
    delete p1;
    delete p2;
}
​
int main()
{
    try {
        func();
    }
    catch (const char* errmsg) {
        cout << errmsg << endl;
    }
    catch (...) {
        cout << "Unknow exception" << endl;
    }
    return 0;
}

调用 func 函数：

  1. 如果在执行 string* p1 = new string("hello"); 语句的过程中抛出了异常，那么在 main 函数中会捕获到抛出的异常；

  2. 如果在执行 pair<string, string>* p2 = new pair<string, string>{ "hello", "你好" }; 语句的过程中抛出了异常，那么在 main 函数中会捕获到抛出的异常，但是 p1 指向的动态分配的内存没有被释放，最终会造成内存泄漏；

  3. 如果在调用 division(a, b) 函数的过程中抛出了异常，那么在 main 函数中会捕获到抛出的异常，但是 p1 以及 p2 指向的动态分配的内存都没有被释放，最终也会造成内存泄漏。

二、智能指针的原理及使用

RAII（Resource Acquisition Is Initialization，资源获取即初始化）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

在对象构造时获取资源，对资源的访问在对象生命周期内始终有效；在对象析构时，即对象生命周期结束时，释放资源。

SmartPtr.h：

#pragma once
​
namespace yzz
{
    template<class T>
    class SmartPtr
    {
    public:
        SmartPtr(T* ptr = nullptr) : _ptr(ptr) 
        { }
​
        ~SmartPtr()
        {
            if (_ptr)
            {
                delete _ptr;
                _ptr = nullptr;
            }
        }
        
        T& operator*()
        {
            return *_ptr;
        }
​
        T* operator->()
        {
            return _ptr;
        }
    private:
        T* _ptr;
    };
}

test.cpp：

#include <iostream>
#include "SmartPtr.h"
using namespace std;
​
int division(int x, int y)
{
    if (y == 0)
        throw "Division by zero condition!";
    else
        return x / y;
}
​
void func()
{
    yzz::SmartPtr<string> sp1 = new string("hello");
    cout << *sp1 << endl;
​
    yzz::SmartPtr<pair<string, string>> sp2 = new pair<string, string>{ "hello", "你好"};
    cout << (*sp2).first << " : " << (*sp2).second << endl;
    cout << sp2->first << " : " << sp2->second << endl;  
    // 为了可读性，编译器将 sp2->->first/second 优化成了 sp2->first/second
​
    int a = 0, b = 0;
    cin >> a >> b;
    cout << division(a, b) << endl;
    // 在 func 函数中，无论有没有异常抛出，
    // func 函数结束后，都会自动调用 sp1 以及 sp2 对象的析构函数释放动态分配的内存，
    // 不再需要手动 delete
}
​
int main()
{
    try {
        func();
    }
    catch (const char* errmsg) {
        cout << errmsg << endl;
    }
    catch (...) {
        cout << "Unknow exception" << endl;
    }
    return 0;
}

三、auto_ptr

C++98/03 标准中提供了 auto_ptr 智能指针。

3.1 - 基本使用

#include <memory>
#include <iostream>
using namespace std;
​
class A
{
public:
    A(int x = 0) : _i(x)
    {
        cout << "A(int x = 0)" << endl;
    }
​
    ~A()
    {
        cout << "~A()" << endl;
    }
​
    int _i;
};
​
int main()
{
    auto_ptr<A> ap1(new A(1));
    auto_ptr<A> ap2(new A(2));
​
    auto_ptr<A> ap3(ap1);  // 管理权转移
    auto_ptr<A> ap4(new A(4));
    ap4 = ap2;  // 管理权转移
​
    // cout << ap1->_i << endl;  // error
    // cout << ap2->_i << endl;  // error
    cout << ap3->_i << endl;  // 1
    cout << ap4->_i << endl;  // 2
    return 0;
}

3.2 - 模拟实现

namespace yzz
{
    template<class T>
    class auto_ptr
    {
    public:
        auto_ptr(T* ptr = nullptr) : _ptr(ptr)
        { }
​
        ~auto_ptr()
        {
            if (_ptr)
            {
                delete _ptr;
                _ptr = nullptr;
            }
        }
​
        auto_ptr(auto_ptr<T>& ap)
            : _ptr(ap._ptr)
        {
            ap._ptr = nullptr;
        }
​
        auto_ptr<T>& operator=(auto_ptr<T>& ap)
        {
            if (this != &ap)
            {
                if (_ptr)
                    delete _ptr;
​
                _ptr = ap._ptr;
                ap._ptr = nullptr;
            }
            return *this;
        }
​
        T& operator*()
        {
            return *_ptr;
        }
​
        T* operator->()
        {
            return _ptr;
        }
    private:
        T* _ptr;
    };
}

四、unique_ptr

C++11 标准废弃了 auto_ptr，新增了 unique_ptr、shared_ptr 以及 weak_ptr 这三个智能指针。

4.1 - 基本使用

#include <memory>
#include <iostream>
using namespace std;
​
class A
{
public:
    A(int x = 0) : _i(x)
    {
        cout << "A(int x = 0)" << endl;
    }
​
    ~A()
    {
        cout << "~A()" << endl;
    }
​
    int _i;
};
​
int main()
{
    unique_ptr<A> up1(new A(1));
    unique_ptr<A> up2(new A(2));
​
    // unique_ptr<A> up3(up1);  // error
    unique_ptr<A> up4(new A(4));
    // up4 = up2;  // error
    return 0;
}

4.2 - 模拟实现

从上面的例子中可以看出，unique_ptr 的实现原理就是简单粗暴的防拷贝。

namespace yzz
{
    template<class T>
    class unique_ptr
    {
    public:
        unique_ptr(T* ptr = nullptr) : _ptr(ptr)
        { }
​
        ~unique_ptr()
        {
            if (_ptr)
            {
                delete _ptr;
                _ptr = nullptr;
            }
        }
​
        unique_ptr(const unique_ptr<T>& up) = delete;
        unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;
​
        T& operator*()
        {
            return *_ptr;
        }
​
        T* operator->()
        {
            return _ptr;
        }
    private:
        T* _ptr;
    };
}

五、shared_ptr

5.1 - 基本使用

#include <memory>
#include <iostream>
using namespace std;
​
class A
{
public:
    A(int x = 0) : _i(x)
    {
        cout << "A(int x = 0)" << endl;
    }
​
    ~A()
    {
        cout << "~A()" << endl;
    }
​
    int _i;
};
​
int main()
{
    shared_ptr<A> sp1(new A(1));
    shared_ptr<A> sp2(new A(2));
    cout << sp1.use_count() << endl;  // 1
    cout << sp2.use_count() << endl;  // 1
    cout << "-------------" << endl;
​
    shared_ptr<A> sp3(sp1);
    cout << sp1.use_count() << endl;  // 2
    cout << sp3.use_count() << endl; // 2
    sp3->_i *= 10;
    cout << sp1->_i << endl;  // 10
    cout << sp3->_i << endl;  // 10
    cout << "-------------" << endl;
​
    shared_ptr<A> sp4(new A(4));
    sp4 = sp2;
    cout << sp2.use_count() << endl;  // 2
    cout << sp4.use_count() << endl; // 2
    sp4->_i *= 10;
    cout << sp2->_i << endl;  // 20
    cout << sp4->_i << endl;  // 20
    return 0;
}

5.2 - 模拟实现

shared_ptr 的实现原理：通过引用计数的方式实现多个 shared_ptr<T> 类对象之间共享资源。

引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成 1，每增加一个对象使用该资源，就给计数增加 1，当某个对象被销毁时，先给该计数减 1，然后再检查是否需要释放资源，如果计数为 0，说明该对象是资源的最后一个使用者，于是将资源释放，否则就不能释放，因为还有其他对象在使用该资源。

namespace yzz
{
    template<class T>
    class shared_ptr
    {
    public:
        shared_ptr(T* ptr = nullptr)
            : _ptr(ptr), _pCnt(new int(1))
        { }
​
        ~shared_ptr()
        {
            if (--(*_pCnt) == 0)
            {
                if (_ptr)
                {
                    delete _ptr;
                    _ptr = nullptr;
                }
                delete _pCnt;
            }
        }
​
        shared_ptr(const shared_ptr<T>& sp)
            : _ptr(sp._ptr), _pCnt(sp._pCnt)
        {
            ++(*_pCnt);
        }
​
        shared_ptr<T>& operator=(const shared_ptr<T>& sp)
        {
            if (_ptr != sp._ptr)
            {
                if (--(*_pCnt) == 0)
                {
                    if (_ptr)
                        delete _ptr;
​
                    delete _pCnt;
                }
​
                _ptr = sp._ptr;
                _pCnt = sp._pCnt;
                ++(*_pCnt);
            }
            return *this;
        }
​
        T& operator*()
        {
            return *_ptr;
        }
​
        T* operator->()
        {
            return _ptr;
        }
​
        int use_count() const
        {
            return *_pCnt;
        }
​
        T* get() const
        {
            return _ptr;
        }
    private:
        T* _ptr;
        int* _pCnt;
    };
}

 

六、weak_ptr

6.1 - shared_ptr 的循环引用问题

#include <memory>
#include <iostream>
using namespace std;
​
class A
{
public:
    A(int x = 0) : _i(x)
    {
        cout << "A(int x = 0)" << endl;
    }
​
    ~A()
    {
        cout << "~A()" << endl;
    }
​
    int _i;
};
​
struct ListNode
{
    A _val;
    shared_ptr<ListNode> _prev;
    shared_ptr<ListNode> _next;
};
​
int main()
{
    shared_ptr<ListNode> sp1(new ListNode);
    shared_ptr<ListNode> sp2(new ListNode);
    // A(int x = 0)
    // A(int x = 0)
    cout << sp1.use_count() << endl;  // 1
    cout << sp2.use_count() << endl;  // 1
​
    sp1->_next = sp2;
    sp2->_prev = sp1;
    cout << sp1.use_count() << endl;  // 2
    cout << sp2.use_count() << endl;  // 2
    // 出现内存泄漏问题
    return 0;
}

解决方案：

#include <memory>
#include <iostream>
using namespace std;
​
class A
{
public:
    A(int x = 0) : _i(x)
    {
        cout << "A(int x = 0)" << endl;
    }
​
    ~A()
    {
        cout << "~A()" << endl;
    }
​
    int _i;
};
​
struct ListNode
{
    A _val;
    // weak_ptr 不增加引用计数，并且在可以访问资源的同时，不参与释放资源
    weak_ptr<ListNode> _prev;
    weak_ptr<ListNode> _next;
};
 
int main()
{
    shared_ptr<ListNode> sp1(new ListNode);
    shared_ptr<ListNode> sp2(new ListNode);
    // A(int x = 0)
    // A(int x = 0)
    cout << sp1.use_count() << endl;  // 1
    cout << sp2.use_count() << endl;  // 1
    
    sp1->_next = sp2;
    sp2->_prev = sp1;
    cout << sp1.use_count() << endl;  // 1
    cout << sp2.use_count() << endl;  // 1
    // ~A()
    // ~A()
    return 0;
}

6.2 - 模拟实现

namespace yzz
{
    template<class T>
    class weak_ptr
    {
    public:
        weak_ptr() : _ptr(nullptr)
        { }
​
        weak_ptr(const shared_ptr<T>& sp)
            : _ptr(sp.get())
        { }
​
        weak_ptr<T>& operator=(const shared_ptr<T>& sp)
        {
            _ptr = sp.get();
            return *this;
        }
​
        T& operator*()
        {
            return *_ptr;
        }
​
        T* operator->()
        {
            return _ptr;
        }
    private:
        T* _ptr;
    };
}

七、定制删除器

template<class T>
struct DeleteArrayFunc
{
    void operator()(T* ptr)
    {
        delete[] ptr;
    }
};
​
template<class T>
struct FreeFunc
{
    void operator()(T* ptr)
    {
        free(ptr);
    }
};
​
int main()
{
    shared_ptr<A> sp1(new A(1));  // ok
​
    // shared_ptr<A> sp2(new A[5]);   // error
    shared_ptr<A> sp2(new A[5], DeleteArrayFunc<A>());   // ok
​
    // shared_ptr<A> sp3((A*)malloc(sizeof(A)));  // error
    shared_ptr<A> sp3((A*)malloc(sizeof(A)), FreeFunc<A>());  // ok
​
    // shared_ptr<FILE> sp4(fopen("test.cpp", "r"));  // error
    shared_ptr<FILE> sp4(fopen("test.cpp", "r"), 
                         [](FILE* fp) { fclose(fp); });  // error
    return 0;
}

shared_ptr 的模拟实现：

#include <functional>
​
namespace yzz
{
    template<class T>
    class shared_ptr
    {
    public:
        shared_ptr(T* ptr = nullptr)
            : _ptr(ptr), _pCnt(new int(1)), _del([](T* ptr) { delete ptr; })
        { }
​
        template<class D>
        shared_ptr(T* ptr, D del)
            : _ptr(ptr), _pCnt(new int(1)), _del(del)
        { }
​
        ~shared_ptr()
        {
            if (--(*_pCnt) == 0)
            {
                if (_ptr)
                {
                    _del(_ptr);
                    _ptr = nullptr;
                }
                delete _pCnt;
            }
        }
        
        // ... ...
    private:
        T* _ptr;
        int* _pCnt;
        std::function<void(T*)> _del;
    };
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/139925.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Amazon Bedrock | 大语言模型CLAUDE 2体验

Amazon Bedrock | 大语言模型CLAUDE 2体验

这场生成式AI与大语言模型的饥饿游戏&#xff0c;亚马逊云科技也参与了进来。2023年&#xff0c;亚马逊云科技正式发布了 Amazon Bedrock&#xff0c;是客户使用基础模型构建和扩展生成式AI应用程序的最简单方法&#xff0c;为所有开发者降低使用门槛。在 Bedrock 上&#xff0…
阅读更多...
【PG】PostgreSQL 预写日志(WAL)、checkpoint、LSN

【PG】PostgreSQL 预写日志(WAL)、checkpoint、LSN

目录 预写式日志&#xff08;WAL&#xff09; WAL概念 WAL的作用 WAL日志存放路径 WAL日志文件数量 WAL日志文件存储形式 WAL日志文件命名 WAL内容 检查点&#xff08;checkpoint&#xff09; 1 检查点概念 2 检查点作用 触发检查点 触发检查点之后数据库操作 设置合…
阅读更多...
Spark SQL 每年的1月1日算当年的第一个自然周, 给出日期，计算是本年的第几周

Spark SQL 每年的1月1日算当年的第一个自然周, 给出日期，计算是本年的第几周

一、问题 按每年的1月1日算当年的第一个自然周 (遇到跨年也不管&#xff0c;如果1月1日是周三&#xff0c;那么到1月5号&#xff08;周日&#xff09;算是本年的第一个自然周, 如果按周一是一周的第一天) 计算是本年的第几周&#xff0c;那么 spark sql 如何写 ? 二、分析 …
阅读更多...
C++实现查找连通域

C++实现查找连通域

目录 一、概述 1.1、四连通域算法 1.2、八连通域算法 1.3、种子填充法 二、代码 一、概述 图像处理中&#xff0c;查找连通域的算法是图像分割的重要方法之一。它能够将一幅图像分成若干个不重叠的区域&#xff0c;每个区域内部像素具有相似的性质&#xff0c;而不同区域…
阅读更多...
重磅：RHCA架构师新班要开课啦：《OpenShift 企业管理（DO280）》

重磅：RHCA架构师新班要开课啦：《OpenShift 企业管理（DO280）》

OpenShift 即将开班 想了解的可提前咨询 课程介绍 学习如何安装、配置和管理实例OpenShift企业版管理 (DO280) 旨在帮助系统管理员为安装、配置和管理红帽OpenShift企业版实例做好准备。OpenShift企业版是一款红帽的平台即服务(PaaS)产品&#xff0c;通过使用容器技术为各类…
阅读更多...
Linux Zabbix企业级监控平台+cpolar实现远程访问

Linux Zabbix企业级监控平台+cpolar实现远程访问

文章目录 前言1. Linux 局域网访问Zabbix2. Linux 安装cpolar3. 配置Zabbix公网访问地址4. 公网远程访问Zabbix5. 固定Zabbix公网地址 前言 Zabbix是一个基于WEB界面的提供分布式系统监视以及网络监视功能的企业级的开源解决方案。能监视各种网络参数&#xff0c;保证服务器系…
阅读更多...
Linux系统上配置MySQL自动备份

Linux系统上配置MySQL自动备份

1、编写Shell脚本&#xff0c;并保存为.sh文件 #!/bin/bash# 获取当前日期和时间 current_date$(date %Y%m%d) current_time$(date %H%M%S)# 设置备份文件名 path"/usr/local/mysql5.7/bak" bakFileName"dbname_backup_${current_date}_${current_time}.sql&qu…
阅读更多...
ChineseChess.2023.11.13.01

ChineseChess.2023.11.13.01

中国象棋残局模拟器ChineseChess.2023.11.13.01
阅读更多...
树木二维码怎么生成

树木二维码怎么生成

众所周知&#xff0c;二维码在当今社会已经普及应用。而制作树木二维码也开始受到人们的关注。那么&#xff0c;如何制作树木二维码呢&#xff1f; 树木二维码管理系统的功能 1、基本信息查看&#xff1a;为每棵树木生成唯一的二维码&#xff0c;该二维码扫码后可以了解树木的种…
阅读更多...
Java：异常

Java：异常

基本概念 在Java中将程序执行过程中发生的不正常行为称为异常 常见异常 1.算术异常 这一行告诉你异常发生的对应程序和位置 当程序出现异常后&#xff0c;将不会继续执行异常后的代码 这里异常后的abcd不会再打印 2.数组越界异常 3.空指针异常 异常体系结构 上图中Excepti…
阅读更多...
C/C++：在#define中使用参数

C/C++：在#define中使用参数

文章目录 在#define中使用参数参考资料 在#define中使用参数 在#define中使用参数可以创建外形和作用与函数类似的类函数宏。带有 参数的宏看上去很像函数&#xff0c;因为这样的宏也使用圆括号。类函数宏定义的圆 括号中可以有一个或多个参数&#xff0c;随后这些参数出现在替…
阅读更多...
RestCloud AppLink已支持的数据源有哪些？

RestCloud AppLink已支持的数据源有哪些？

RestCloud AppLink是什么&#xff1f; 首先&#xff0c;我们需要了解RestCloud AppLink是什么&#xff0c;AppLink是一款由RestCloud公司推出的超级应用连接器。不需要开发&#xff0c;零代码&#xff0c;低成本即可快速打通数百款应用之间的数据。通过流程搭建&#xff0c;可…
阅读更多...
C语言实现单身狗问题（找出单身狗详解版）

C语言实现单身狗问题（找出单身狗详解版）

今天我们用C语言来实现一个单身狗问题&#xff0c;让我们开始学习吧! 目录 1.单身狗问题初阶版&#xff08;找一只单身狗&#xff09; 代码实现 2.单身狗问题进阶版&#xff08;找两只单身狗&#xff09; 代码实现 1.单身狗问题初阶版&#xff08;找一只单身狗&#xff09;…
阅读更多...
二十六、W5100S/W5500+RP2040树莓派Pico＜WOL示例＞

二十六、W5100S/W5500+RP2040树莓派Pico＜WOL示例＞

文章目录 1 前言2 简介2 .1 什么是Wake on LAN&#xff1f;2.2 Wake on LAN的优点2.3 Wake on LAN数据交互原理2.4 Wake on LAN应用场景 3 WIZnet以太网芯片4 Wake on LAN示例概述以及使用4.1 流程图4.2 准备工作核心4.3 连接方式4.4 主要代码概述4.5 结果演示 5 注意事项6 相关…
阅读更多...
华为组织绩效管理——华为战略执行和落地的核心抓手（好文分享）

华为组织绩效管理——华为战略执行和落地的核心抓手（好文分享）

【导语&#xff1a;华为战略执行和落地的核心抓手是组织绩效管理。在战略管理中&#xff0c;华为和其他企业最大区别的地方就是华为更强调的是组织绩效的管理。】​ 我接触的很多企业只有个人绩效没有组织绩效&#xff0c;也就是公司的战略直接分解到个人。对于小企业而言&…
阅读更多...
LeetCode题94，44，145，二叉树的前中后序遍历，非递归

LeetCode题94，44，145，二叉树的前中后序遍历，非递归

注意&#xff1a;解题都要用到栈 一、前序遍历 题目要求 给你二叉树的根节点 root &#xff0c;返回它节点值的 前序 遍历。 示例 1&#xff1a; 输入&#xff1a;root [1,null,2,3] 输出&#xff1a;[1,2,3]示例 2&#xff1a; 输入&#xff1a;root [] 输出&#xff1a;[…
阅读更多...
如何ThingsBoard 仪表盘中快速地构建自己的实时应用？使用html markdwon 最新值部件

如何ThingsBoard 仪表盘中快速地构建自己的实时应用？使用html markdwon 最新值部件

众所周知&#xff0c;tb是一个非常优秀的开源物联网平台&#xff0c;当我们使用它收集了一些设备数据后&#xff0c;该如何将其更加美化&#xff0c;自由自在地显示到页面上&#xff0c;搭建一个仪表盘&#xff0c;给客户看那&#xff1f; 要显示某个遥测数据&#xff0c;或者…
阅读更多...
金蝶云星空与金蝶云星空对接集成盘亏单查询打通盘亏单新增

金蝶云星空与金蝶云星空对接集成盘亏单查询打通盘亏单新增

金蝶云星空与金蝶云星空对接集成盘亏单查询打通盘亏单新增 接通系统&#xff1a;金蝶云星空 金蝶K/3Cloud&#xff08;金蝶云星空&#xff09;是移动互联网时代的新型ERP&#xff0c;是基于WEB2.0与云技术的新时代企业管理服务平台。金蝶K/3Cloud围绕着“生态、人人、体验”&am…
阅读更多...
解决pikachu中RCE中文乱码的问题

解决pikachu中RCE中文乱码的问题

这个问题我在DVWA中的RCE栏目同样遇到过&#xff0c;今天在做pikachu的RCE的时候也遇到了&#xff0c;所以特此来解决一下这个问题&#xff0c;解决方法很简单&#xff0c;在源码中加入下一行代码。 $result iconv("GBK", "UTF-8", $result);加在68行前面…
阅读更多...
Java学习笔记（七）——面向对象编程（中级）

Java学习笔记（七）——面向对象编程（中级）

一、IDEA &#xff08;一&#xff09;常用的快捷键 &#xff08;二&#xff09;模版/自定义模版 二、包 &#xff08;一&#xff09;包的命名 &#xff08;二&#xff09;常用的包 &#xff08;三&#xff09;如何引入&#xff08;导入&#xff09;包 &#xff08;四&am…
阅读更多...
最新文章

Copyright @ 2022~2023