探索：智能指针(c++)

最新推荐文章于 2024-04-03 20:48:56 发布
最新推荐文章于 2024-04-03 20:48:56 发布
阅读量206 收藏
点赞数
分类专栏： 探索计划C/C++ 文章标签： 开发语言 c++ c语言 算法 迭代加深
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44110278/article/details/131864145
版权

一、智能指针的概念

C++中堆内存对象需要手动使用new来创建，如果忘记delete操作则会造成内存泄漏的问题。诸如Java、C#等语言则直接提供垃圾回收机制来处理不使用的对象，因此C++在ISO 98标准中也引入了智能指针的概念，并在C++11中趋于完善。

使用智能指针，可以让堆内存的对象不使用delete就可以在特定的时机销毁。

智能指针对象位于栈内存，管理一个堆内存的对象，当智能指针对象的生命周期结束后，会在析构函数中释放掉管理的堆内存资源，从而防止堆内存对象内存泄漏。

C++中有四种智能指针：auto_ptr（自动指针）、unique_ptr（唯一指针）、shared_ptr（共享指针）与weak_ptr（虚指针），其中后三者是C++11中引入的，auto_ptr在C++11以后已经被弃用。

使用智能指针需要引入头文件 #include 

二、auto_ptr

基础使用如下。

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string name;

public:
    Test(string name):name(name)
    {
        cout << name << "构造函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }

    ~Test()
    {
        cout << name << "析构函数" << endl;
    }
};


int main()
{
    {
        Test* t = new Test("A"); 
        auto_ptr<Test> ap1(t); // 智能指针
        // 从智能指针对象中取出被管理的资源对象
        Test* t2 = ap1.get();
        t2->show();
//        delete t2; 错误：既然已经放手了，就别再插手
        // 解除ap1对资源的管理，ap1仅仅放弃管理权，不会销毁资源
        ap1.release();
        delete t;

        //ap2持有资源B
        auto_ptr<Test> ap2(new Test("B"));
        // 解除ap2对资源的管理并销毁资源对象
        ap2.reset();

        auto_ptr<Test> ap3(new Test("C"));
        // ap3持有的资源从C更换为D，C销毁
        ap3.reset(new Test("D"));
        ap3.get()->show();
    }

    cout << "主函数执行结束" << endl;
    return 0;
}

 

auto_ptr容易让人产生误用的地方是其复制语义，当执行复制相关操作时（拷贝构造函数、赋值运算符），会出现资源控制权转移的问题

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string name;

public:
    Test(string name):name(name)
    {
        cout << name << "构造函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }

    ~Test()
    {
        cout << name << "析构函数" << endl;
    }
};


int main()
{
    {
        auto_ptr<Test> ap1(new Test("A"));
        // 显式调用拷贝构造函数
        auto_ptr<Test> ap2(ap1);
        // 隐式调用拷贝构造函数
        auto_ptr<Test> ap3 = ap2;
        auto_ptr<Test> ap4;
        ap4 = ap3; // 赋值运算符
        // 指针转移
        cout << ap1.get() << endl; // 0
        cout << ap2.get() << endl; // 0
        cout << ap3.get() << endl; // 0
        cout << ap4.get() << endl; // 0x7a0fa8

        // 忘记转移了。。。
//        ap1.get()->show(); 错误
    }

    cout << "主函数执行结束" << endl;
    return 0;
}

三、unique_ptr

unique_ptr作为对auto_ptr的改进，其对象对资源具有唯一的控制权，无法通过常规的复制语义进行控制权的转移。

可以通过move函数来完成控制权的转移。

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string name;

public:
    Test(string name):name(name)
    {
        cout << name << "构造函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }

    ~Test()
    {
        cout << name << "析构函数" << endl;
    }
};


int main()
{
    {
        unique_ptr<Test> up1(new Test("A"));
        // 显式调用拷贝构造函数
        //        unique_ptr<Test> up2(up1); 错误
        // 隐式调用拷贝构造函数
        //        unique_ptr<Test> up3 = up2; 错误
        unique_ptr<Test> up4;
        // 赋值运算符
        //        up4 = up3; // 错误

        // 之前的复制语义结合move函数仍然可以转移控制权
        unique_ptr<Test> up2(move(up1));
        unique_ptr<Test> up3 = move(up2);
        up4 = move(up3);

        cout << up1.get() << endl; // 0
        cout << up2.get() << endl; // 0
        cout << up3.get() << endl; // 0
        cout << up4.get() << endl; // 0xc50fa8

        unique_ptr<Test> up5(new Test("B"));
        up4.swap(up5); // 交换控制权
        up4.get()->show(); // B成员函数
        up5.get()->show(); // A成员函数
    }

    cout << "主函数执行结束" << endl;
    return 0;
}

四、shared_ptr

unique_ptr对持有的资源具有独占性，而shared_ptr则可以把持有的资源在多个shared_ptr对象之间共享。

shared_ptr有两种初始化的方式：

" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }

    ~Test()
    {
        cout << name << "析构函数" << endl;
    }
};


int main()
{
    {
       // 使用new来初始化
       shared_ptr<Test> sp1(new Test("A"));
       // 使用make_shared函数来初始化
       shared_ptr<Test> sp2 = make_shared<Test>("B");

       sp1.get()->show();
       sp2.get()->show();
    }

    cout << "主函数执行结束" << endl;
    return 0;
}

make_shared函数相比传统new的方式区别如下：

1. 性能略高

2. 安全性更好

3. 内存释放可能延迟

推荐使用make_shared来创建shared_ptr对象。

每多一个shared_ptr持有同一资源，每个share_ptr内部的引用计数将增加1，每一个持有该资源的shared_ptr销毁时，引用计数将减1，直到引用计数减为0，则销毁持有的资源。

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string name;

public:
    Test(string name):name(name)
    {
        cout << name << "构造函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }

    ~Test()
    {
        cout << name << "析构函数" << endl;
    }
};


int main()
{
    shared_ptr<Test> sp4;
    {
        cout << "{" << endl;
        shared_ptr<Test> sp1= make_shared<Test>("A");
        cout << "引用计数：" << sp1.use_count() << endl; // 1
        shared_ptr<Test> sp2(sp1);
        shared_ptr<Test> sp3 = sp2;
        sp4 = sp3;
        cout << "引用计数：" << sp1.use_count() << endl; // 4
        cout << "引用计数：" << sp2.use_count() << endl; // 4
        cout << "引用计数：" << sp3.use_count() << endl; // 4
        cout << "引用计数：" << sp4.use_count() << endl; // 4
        cout << "}" << endl;
    }
    cout << "引用计数：" << sp4.use_count() << endl; // 1

    cout << "主函数执行结束" << endl;
    return 0;
}

再补充几个操作函数：

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string name;

public:
    Test(string name):name(name)
    {
        cout << name << "构造函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }

    ~Test()
    {
        cout << name << "析构函数" << endl;
    }
};


int main()
{
    shared_ptr<Test> sp4;
    cout << sp4.operator bool() << endl; // false
    cout << sp4.get() << endl; // 0
    {
        cout << "{"  << endl;
        shared_ptr<Test> sp1= make_shared<Test>("A");
        // 判断是否是独自持有资源
        cout << sp1.unique() << endl; // 1

        shared_ptr<Test> sp2(sp1);
        cout << sp1.unique() << endl; // 0

        sp4 = sp2;

        // 获得资源对象的引用
        Test &t = sp2.operator *();
        t.show();

        // 如果持有资源，则返回true
        cout << sp2.operator bool() << endl;

        cout << "}"  << endl;
    }

    cout << "主函数执行结束" << endl;
    return 0;
}

五、weak_ptr

weak_ptr无法控制资源，只能协助shared_ptr进行工作。因为不控制资源，因此weak_ptr不会影响引用计数。

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string name;

public:
    Test(string name):name(name)
    {
        cout << name << "构造函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }

    ~Test()
    {
        cout << name << "析构函数" << endl;
    }
};


int main()
{
    shared_ptr<Test> sp1;
    {
        cout << "{" << endl;
        shared_ptr<Test> sp2 = make_shared<Test>("A");
        sp1 = sp2;
        // 创建一个weak_ptr对象
        weak_ptr<Test> wp1(sp2);
        weak_ptr<Test> wp2 = wp1;
        weak_ptr<Test> wp3;
        wp3 = sp1;

//        wp3.get(); 错误：无法直接获得资源

        cout << wp1.use_count() << endl; // 2
        cout << wp2.use_count() << endl; // 2
        cout << wp3.use_count() << endl; // 2
        cout << sp1.use_count() << endl; // 2
        cout << sp2.use_count() << endl; // 2
        cout << "}" << endl;
    }
    cout << sp1.use_count() << endl; // 1

    cout << "主函数执行结束" << endl;
    return 0;
}

可以从weak_ptr中获得shared_ptr对象，从而持有资源。

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string name;

public:
    Test(string name):name(name)
    {
        cout << name << "构造函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }

    ~Test()
    {
        cout << name << "析构函数" << endl;
    }
};


int main()
{
    shared_ptr<Test> sp1 = make_shared<Test>("A");
    weak_ptr<Test> wp1(sp1);
    {
        cout << "{" << endl;
        cout << wp1.use_count() << endl; // 1
        // 通过wp1来获得shared_ptr对象
        shared_ptr<Test> sp2 = wp1.lock();
        sp2.get()->show();
        cout << wp1.use_count() << endl; // 2

        cout << "}" << endl;
    }
    cout << sp1.use_count() << endl; // 1

    cout << "主函数执行结束" << endl;
    return 0;
}

需要注意的是，weak_ptr对资源的持有可能失效，此时lock也会失效。因此，在执行lock函数之前，要先检测资源是否已经失效。

#include <iostream>
#include <memory>

using namespace std;

class Test
{
private:
    string name;

public:
    Test(string name):name(name)
    {
        cout << name << "构造函数" << endl;
    }

    void show()
    {
        cout << name << "成员函数" << endl;
    }

    ~Test()
    {
        cout << name << "析构函数" << endl;
    }
};


int main()
{
    weak_ptr<Test> wp1;
    {
        cout << "{" << endl;
        shared_ptr<Test> sp1 = make_shared<Test>("A");
        wp1=sp1;
        cout << "}" << endl;
    }
    // wp1持有的资源已经失效
    if(wp1.expired()) // 如果已经失效则返回true
    {
        cout << "资源已失效！" << endl;
    }else
    {
        shared_ptr<Test> sp2 = wp1.lock();
        sp2.get()->show();
    }
    cout << "主函数执行结束" << endl;
    return 0;
}

烤辣大师
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++:智能指针
赫菲斯托斯，，
10-09 749
RAII是什么？ RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。 智能指针（std::shared_ptr和std::unique_ptr）即RAII最具代表的实现，使用智能指针，可以实现自动的内存管理，再也不需要担心忘记delete造成的内存泄漏。毫不夸张的来讲，有...
C++深度探索系列：智能指针(Smart Pointer) [一]
RedStar81的专栏
03-21 3523
主题索引：一、剖析C++标准库智能指针(std::auto_ptr)        1.Do you Smart Pointer?    2.std::auto_ptr的设计原理    3.std::auto_ptr高级使用指南    4.你是否觉得std::auto_ptr还不够完美?二、C++条件,寻找构造更强大的智能指针(Smart Pointer)的    策略        1.
C++智能指针用法详解
12-22
一、简介 　　由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete，流程太复杂，终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见。 　　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: intrusive_ptr。你可能会想，如此多的智能指
4种智能指针
m0_65690223的博客
05-05 1125
C++11 中提供了四种智能指针类型：unique_ptr、shared_ptr、weak_ptr 和 auto_ptr（已废弃）。
C++面试经典问题
高处不胜寒
04-03 1424
常见问题：智能指针、多态、虚函数、STL原理、链表、排序、二叉树、设计模式、线程进程、内存 对象所有权 在接触智能指针之前首先要理解对象的所有权是什么，在这之前我们总是用new和delete来进行内存的申请与释放，在这种堆内存分配的方式中，要遵守一个很基本的原则-谁创建谁销毁原则，而对象所有权指的是谁来负责销毁这个对象的关系。根据几种智能指针的用途来分，对象的所有权可以分为独占所有权、分享所有权和弱引用。独占所有权(unique_ptr)：独占该对象，不共享，所有权可以转移，但是转移之后，所有权也是独占。比
简要总结四个智能指针
Think88666的博客
01-15 1446
在c++标准库里主要有四个智能指针： C++四种智能指针auto_ptr、unique_ptr、shared_ptr和weak_ptr。 其中auto_ptr是C++98标准化引入的； scope_ptr、shared_ptr和weak_ptr是C++11标准化才引入的（当然，早在C++03的TR1中就已经可以使用了）。我们都知道，auto_ptr虽说简单，但使用起来却到处是坑，以至于大家都不......
C++ STL 四种智能指针
热门推荐
Dablelv 的博客专栏。
08-07 7万+
auto_ptrunique_ptrshared_ptrweak_ptrauto_ptr 是 C++98 提出的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。虽然 auto_ptr 已被摒弃，但在实际项目中仍可使用，但建议使用更加安全的 unique_ptr，后文会详细叙述。shared_ptr 和 weak_ptr 则是 C+11 从准标准库 Boost 中引入的两种智能指针。
智能指针 （C++11）
weixin_71901858的博客
04-17 469
C++语言中堆内存的对象在new之后创建，如果忘记delete则会产生内存泄漏的问题。在Java、C#等语言直接提供垃圾回收机制来处理不使用的对象，因此在C++98中引入了智能指针的概念，能使堆内存对象自动回收，并在C++11趋于完善。智能指针主要用于管理堆内存对象的生命周期，本身指针对象是位于栈内存的对象，当智能指针对象的生命周期结束后，会在析构函数里释放管理的堆内存对象的内存空间，从而方式内存泄露。对象的指针位于栈，指向的内存在堆区。
C++智能指针详解
qq_44630255的博客
09-20 238
以为读懂C++智能指针
C++进阶，迈向C++高级世界
10-12
C++提供了智能指针、引用计数等机制，可以帮助开发者自动管理内存，避免内存错误和指针悬空等问题。 ### 40.2 左值和右值引用 左值和右值是C++中的两个重要概念。左值是指可以出现赋值操作左侧的表达式，而右值是...
cpp经典优化方案示例c++源码(涵盖对象优化、重载、继承、多态、线程、智能指针、函数对象等17种优化方案）.zip
最新发布
05-31
cpp经典优化方案示例c++源码(涵盖对象优化、重载、继承、多态、线程、智能指针、函数对象等17种优化方案）.zipcpp经典优化方案示例c++源码(涵盖对象优化、重载、继承、多态、线程、智能指针、函数对象等17种优化方案...
再再论指针修订版1
08-03
在C++98和C++2003标准中，对指针的使用进行了规范，包括智能指针（smart pointers）的引入，如`std::unique_ptr`和`std::shared_ptr`，它们可以帮助开发者更好地管理内存，防止内存泄漏。此外，C++11及其后续标准...
C++程序设计语言习题.pdf
06-04
此外，还将有机会探索C++11及后续版本引入的新特性，如智能指针、右值引用和lambda表达式。解决这些练习不仅可以提高编程能力，还能增强调试、测试和文档编写等软件工程实践。 总之，为了成为一名熟练的C++程序员，...
c++学习路径
09-07
掌握深拷贝与浅拷贝、特殊成员函数（构造、复制构造、赋值操作符、析构）、STL的使用、RAII（Resource Acquisition Is Initialization）和智能指针。了解对象构造与析构顺序、临时对象的销毁，以及何时何地抛出异常...
C++11智能指针的深度理解
weixin_33827590的博客
05-27 278
平时习惯使用cocos2d-x的Ref内存模式，回过头来在控制台项目中觉得c++的智能指针有点生疏，于是便重温一下。首先有请c++智能指针们登场:std::auto_ptr、std::unique_ptr、std::shared_ptr 、std::weak_ptr ｜auto_ptr（不要使用的指针） 没有智能指针的c++时代，对堆内存的管理就是简单的new delete。但是缺...
【9】C++四个智能指针
qq_33612665的博客
03-07 239
1 智能指针的作用 智能指针的作用是管理一个指针，因为存在以下这种情况：申请的空间在函数结束时忘记释放，造成内存泄漏。所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。对于编译器来说，智能指针实际上是一个栈对象，并非指针类型，在栈对象生命期即将结束时，智能指针通过析构函数释放有它管理的堆内存。所有智能指针都重载了“operator->”操作符，直接返回对象的引用...
学习-＞C++篇十九：四种智能指针及其实现
u014801954的博客
12-21 1284
目录 为什么需要智能指针？ 什么是内存泄露？ 如何避免内存泄露？ 什么是RAII？ RAII有什么用？ 智能指针的原理是什么？ C++的智能指针有哪些？ auto_ptr unique_ptr shared_ptr weak_ptr
C++中的智能指针有哪些？分别解决的问题以及区别？
敖丙007的博客
03-10 1254
可以看到fun函数中pa，pb之间互相引用，两个资源的引用计数为2，当要跳出函数时，智能指针pa，pb析构时两个资源引用计数会减一，但是两者引用计数还是为1，导致跳出函数时资源没有被释放（AB的析构函数没有被调用），如果把其中一个改为weak_ptr就可以了，我们把类A里面的shared_ptrpb_;运行结果如下，这样的话，资源B的引用开始就只有1，当pb析构时，B的计数变为0，B得到释放，B释放的同时也会使A的计数减一，同时pa析构时使A的计数减一，那么A的计数为0，A得到释放。
C++-什么是智能指针？智能指针有什么作用？分为哪几种？各自有什么样的特点？
MoOtA
03-06 437
智能指针分为：auto_ptr，unique_ptr，shared_ptr和weak_ptr四种。总之，每种智能指针都有其特点和适用场景，选择合适的智能指针可以更好地管理内存并提高程序效率。，就可以在离开作用域时，自动调用delete删除指针所指向的内存空间，从而。它们提供了一种自动管理内存的方式，其设计思想是将基本类型封装为（模板）智能指针是C++中用于。指针，这样，借助于类的。在C++11中被抛弃。
智能指针c++实现 csdn下载
07-29
智能指针是一种管理动态内存的工具，它可以自动管理内存的释放，防止内存泄漏和多次释放同一块内存等问题。在C语言中，可以通过自定义结构体和相关的函数来实现简单版的智能指针。 首先，我们可以定义一个结构体来表示智能指针： ```c typedef struct { void* data; // 指向需要被管理的内存的指针 int* count; // 该内存的引用计数 } SmartPtr; ``` 接下来，我们可以实现一些函数来创建和使用智能指针： 1. 创建智能指针： ```c SmartPtr* create_smart_ptr(void* data) { SmartPtr* smart_ptr = malloc(sizeof(SmartPtr)); smart_ptr->data = data; smart_ptr->count = malloc(sizeof(int)); *(smart_ptr->count) = 1; return smart_ptr; } ``` 2. 销毁智能指针： ```c void destroy_smart_ptr(SmartPtr* smart_ptr) { *(smart_ptr->count) -= 1; if (*(smart_ptr->count) == 0) { free(smart_ptr->data); free(smart_ptr->count); free(smart_ptr); } } ``` 3. 使用智能指针： ```c void use_smart_ptr(SmartPtr* smart_ptr) { // 使用智能指针管理的内存 // ... } ``` 通过使用上述的智能指针实现，我们可以更方便地管理动态分配的内存，使其在不再使用时能够自动释放，避免内存泄漏问题。当一个内存块不再被引用时，智能指针会自动销毁并释放该内存，从而提高程序的内存使用效率和安全性。 希望以上回答对您有所帮助，如有不明之处，请随时追问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值