C++（智能指针）

最新推荐文章于 2024-12-20 06:14:39 发布
最新推荐文章于 2024-12-20 06:14:39 发布
阅读量694 收藏 5
点赞数 12
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77143270/article/details/142925879
版权

1. 概念

C++堆内存对象在new之后使用，如果忘记delete则会产生内存泄漏的问题。

诸如Java、C#等语言直接提供垃圾回收机制来处理不使用的对象，因此在C++98中引入了智能指针的概念，并在C++11中趋于完善。

使用智能指针可以让堆内存对象不调用delete就能被销毁。

智能指针的原理是通过一个栈内存的智能指针对象，控制被管理的堆内存对象生命周期，当栈内存的智能指针对象销毁时，在析构函数中释放被管理管理的堆内存对象。这样程序员就不需要手动调用delete释放堆内存对象了。

C++中有四种只能指针：

  • auto_ptr 自动指针（C++98），已废弃。
  • unique_ptr 唯一指针（C++11）
  • shared_ptr 共享指针（C++11）
  • weak_ptr 虚指针（C++11）

智能指针的使用需要引入头文件 #include <memory>

2. auto_ptr

C++98的智能指针，目前已经不推荐使用。

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

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

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

int main()
{
    Source* src = new Source("A");
    // 创建一个智能指针对象ap1，管理对象A
    auto_ptr<Source> ap1(src);
    // 上面的操作可以一步完成
    auto_ptr<Source> ap2(new Source("B"));
    // 被管理的对象可以通过getter拿出来
    ap2.get()->show(); // B
    src = ap2.get();
    src->show(); // B
//    delete src; 乱码：对象内存不能释放两次
    // 解除ap1对A的管理，发返回值为对象A
    src = ap1.release();
    src->show(); // A
    delete src; // 因为A回到手动模式，所以可以delete销毁
    // 解除ap2对B的管理，同时销毁B
    ap2.reset();
    auto_ptr<Source> ap3(new Source("C"));
    // 使用新的资源对象D替代C，C被销毁
    ap3.reset(new Source("D"));

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

auto_ptr真正容易误用的地方是其不常用的复制语义（拷贝构造函数和赋值运算符），与浅拷贝的区别是，auto_ptr的复制语义不会让多个auto_ptr共享一个资源，而是会出现控制权的转移。

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

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

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

int main()
{
    auto_ptr<Source> ap1(new Source("A"));
    cout << ap1.get() << endl; // 0xfa1060
    auto_ptr<Source> ap2(ap1); // 拷贝构造函数
    cout << ap1.get() << " " << ap2.get() << endl; // 0 0xfa1060
    auto_ptr<Source> ap3;
    ap3 = ap2; // 赋值运算符
    cout << ap1.get() << " " << ap2.get()
         << " " << ap3.get() << endl; // 0 0 0xfa1060

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

3. unique_ptr

作为对auto_ptr的改进，unique_ptr对其持有的堆内存对象具有唯一控制权，即不可以转移到其他智能指针管理。

上面的代码中可以看到，所有复制语义都被屏蔽了。

unique_ptr可以增加move函数达到之前控制权转移的效果。

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

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

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

int main()
{
    unique_ptr<Source> up1(new Source("A"));
    cout << up1.get() << endl; // 0xfa1060
    unique_ptr<Source> up2(move(up1)); // 拷贝构造函数
    cout << up1.get() << " " << up2.get() << endl; // 0 0xfa1060
    unique_ptr<Source> up3;
    up3 = move(up2); // 赋值运算符
    cout << up1.get() << " " << up2.get()
         << " " << up3.get() << endl; // 0 0 0xfa1060
    // 如果两个unique_ptr对象交换资源，可以使用swap函数
    unique_ptr<Source> up4(new Source("B"));
    unique_ptr<Source> up5(new Source("C"));
    up4.swap(up5);
    up4.get()->show();
    up5.get()->show();

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

4. shared_ptr

shared_ptr可以把持有的资源在多个智能指针之间共享。

shared_ptr除了可以使用构造函数创建外，还可以使用make_shared函数创建。

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

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

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

int main()
{
    shared_ptr<Source> sp1(new Source("A"));
    shared_ptr<Source> sp2 = make_shared<Source>("B");

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

make_shared函数创建相比于普通的构造函数：

  • 性能更好
  • 更加安全
  • 可能内存延迟释放

更推荐使用make_shared函数创建shared_ptr对象。

每个shared_ptr内部都多一个隐藏的成员变量，这个变量通常被称为“引用计数”，每多一个shared_ptr持有资源就计数+1，每少一个shared_ptr持有资源就计数-1，当计数从1变为0时，释放资源。

持有相同资源的shared_ptr对象，引用计数一定相同。

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

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

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

int main()
{
    shared_ptr<Source> sp1 = make_shared<Source>("A");
    cout << sp1.use_count() << endl; // 1
    shared_ptr<Source> sp2(sp1); // 拷贝构造函数
    cout << sp1.use_count() << " " << sp2.use_count() << endl; // 2 2
    sp2.reset(); // 解除sp2对A的管理
    cout << sp1.use_count() << " " << sp2.use_count() << endl; // 1 0
    shared_ptr<Source> sp3;
    sp3 = sp1; // 赋值运算符
    cout << sp1.use_count() << " " << sp3.use_count() << endl; // 2 2
    shared_ptr<Source> sp4 = sp3; // 拷贝构造函数
    cout << sp1.use_count() << endl; // 3
//    shared_ptr<Source> sp5(sp4.get()); 错误
    sp4.get()->show();
    { // 局部代码块
        shared_ptr<Source> sp6;
        sp6 = sp1;
        cout << sp1.use_count() << endl; // 4
    }
    cout << sp1.use_count() << endl; // 3

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

5. weak_ptr

weak_ptr本身无法独立工作，但是可以配合shared_ptr进行工作，weak_ptr对资源对象的管理是一种“弱引用”，因为不会影响引用计数。

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

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

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

int main()
{
    shared_ptr<Source> sp1 = make_shared<Source>("A");
    weak_ptr<Source> wp1 = sp1;
    cout << sp1.use_count() << endl; // 1
    cout << wp1.use_count() << endl; // 1
//    wp1.get(); 无法获取资源
    sp1.reset(); // 计数1→0，对象A销毁
    cout << wp1.use_count() << endl; // 0

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

可以使用expired函数检测虚指针对资源持有的有效性，即资源对象是否已销毁。如果资源对象没有被销毁，可以使用lock函数生成一个shared_ptr对象共享资源。

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

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

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

int main()
{
    shared_ptr<Source> sp1 = make_shared<Source>("A");
    weak_ptr<Source> wp1 = sp1;
//    sp1.reset();
    shared_ptr<Source> sp2;
    // lock能用的前提是资源对象还在
    if(wp1.expired())
    {
        cout << "资源已失效" << endl;
    }else
    {
        sp2 = wp1.lock(); // 返回一个shared_ptr<Source>，但是是临时的，需要保存下来
        cout << sp1.use_count() << " " <<
                sp2.use_count() <<" " << wp1.use_count() << endl; // 2 2 2
    }

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

6. 窥探源码（了解）

经过上述学习可以得到结论：智能指针使用模板实现，堆内存对象和引用计数分别是智能指针对象的成员变量，可以通过sizeof观察到。

#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

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

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

int main()
{
    auto_ptr<Source> ap1(new Source("A"));
    cout << sizeof(ap1) << endl; // 4

    unique_ptr<Source> up1(new Source("N"));
    cout << sizeof(up1) << endl; // 4

    shared_ptr<Source> sp1 = make_shared<Source>("S");
    cout << sizeof(sp1) << endl; // 8

    weak_ptr<Source> wp1 = sp1;
    cout << sizeof(wp1) << endl; // 8

    return 0;
}

下面手搓一个简化版的SharedPtr类，简单了解一下智能指针的内部构造，包含以下功能：

  • 构造函数
  • 拷贝构造函数
  • 赋值运算符
  • get函数
  • use_count函数
  • reset函数
  • 析构函数
#include <iostream>
#include <memory> // 头文件

using namespace std;

/**
 * @brief The Source class
 * 被智能指针管理的堆内存资源对象类
 */
class Source
{
private:
    string name;

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

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

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

template <class T>
class SharedPtr
{
private:
    T* res = NULL;
    int* count = NULL;

public:
    // 构造函数
    SharedPtr(T* t):res(t),count(new int(1)){}

    SharedPtr(const SharedPtr& sp):res(sp.res),count(sp.count)
    {
        (*count)++; // 因为使用的是拷贝构造函数，因此计数+1
    }

    SharedPtr& operator =(const SharedPtr& sp)
    {
        if(this != &sp) // 避免自赋值
        {
            // 如果之前有资源
            // 如果计数>1，计数-1
            // 如果计数=1，计数-1，变0，销毁
            reset();
            res = sp.res;
            count = sp.count;
            (*count)++;
        }
        return *this;
    }

    void reset()
    {
        // 如果之前有资源
        if(res != NULL)
        {
            // 计数-1
            (*count)--;
            if(*count == 0) // 减完之后如果计数为0
            {
                delete res;
                delete count;
            }
            res = NULL;
            count = NULL;
        }
    }

    T* get() const
    {
        return res;
    }

    int use_count() const
    {
        return *count;
    }

    ~SharedPtr()
    {
        reset();
    }
};

int main()
{
    SharedPtr<Source> sp1(new Source("A"));
    SharedPtr<Source> sp2(new Source("B"));
    sp2 = sp1; // A销毁，sp2持有B

    return 0;
}

C++ 智能指针
qq_37373742的博客
09-26 1129
一个shared_ptr对象管理一个指针（new T，在堆空间），多个shared_ptr对象可以管理同一个指针，只有某个shared_ptr对象第一次初始化指针时才执行指针的构造函数，管理同一个指针的shared_ptr对象个数称为引用计数，这个引用计数保存在每个管理该指针的shared_ptr对象中，当引用计数为0时，这个指针执行析构函数释放；shared_ptr对象也可以管理空指针，此时引用计数为0。
C++ 11 智能指针
vvstormhao的博客
07-14 144
智能指针在头文件<memory>中定义。共包含4种：auto_ptr、unique_ptr、share_ptr以及weak_ptr。 auto_ptr在C++98中定义，在C++11中引入unique_ptr后推荐使用unique_ptr替代auto_ptr。 一、unique_ptr 指针指向的内存空间不与其他指针共享。但可通过移动语义将所有权转移给其他的unique_ptr。 无法将一个unique_ptr赋值给另一个unique_ptr unique_ptr<Un..
C++智能指针_主动销毁智能指针的方法，【大牛疯狂教学
2301_79097795的博客
04-17 1385
6.但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。涉及到共享，我们不得不将线程安全问题考虑进来，很显然shared_ptr无论是要管理的资源的使用，还是要指向的该资源对应的计数器的加减操作，都不是线程安全的。3.node1和node2析构，引用计数减到1，但是_next还指向下一个节点。2.node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
C++智能指针
BUAAer_xuyang的博客
02-25 883
较为详细地介绍了C++智能指针，包括 unique_ptr 、shared_ptr 、 weak_ptr 。
c++智能指针
weixin_63207763的博客
10-11 1090
智能指针的原理是通过一个栈内存的智能指针对象，控制被管理的堆内存对象生命周期，当栈内存的智能指针对象销毁时，在析构函数中释放被管理管理的堆内存对象。每个shared_ptr内部都多一个隐藏的成员变量，这个变量通常被称为“引用计数”，每多一个shared_ptr持有资源就计数+1，每少一个shared_ptr持有资源就计数-1，当计数从1变为0时，释放资源。weak_ptr本身无法独立工作，但是可以配合shared_ptr进行工作，weak_ptr对资源对象的管理是一种“弱引用”，因为不会影响引用计数。
C/C++学习笔记 C++中的智能指针
学以致用 知行合一
10-07 2478
在现代 C++ 编程中，标准库包含智能指针，用于帮助确保程序没有内存和资源泄漏，并且是异常安全的。智能指针是一个组合类，旨在管理动态分配的内存并确保在智能指针对象超出范围时删除内存。智能指针只是包装原始指针并重载->and*运算符的类；这允许它们提供与原始指针相同的语法。智能指针在头文件的std命名空间中定义。它们对于RAII(对象生命周期和资源管理)或Resource Acquisition Is Initialization编程习惯至关重要。
C++ 智能指针 — 探索智能指针变量在类中销毁的顺序（学习笔记二）
acdfg123的博客
06-26 1201
各位路过的大神，要看懂我这篇文章，需要看一下我的第一章笔记： https://blog.csdn.net/acdfg123/article/details/118226287?spm=1001.2014.3001.5502 我这一章是基于前一章的序章，后续的笔记都是由第一章的最基础工程来进行实验 1.创建新类 TestB（直接复制TestA的内容），内容如下： class TestB { public: TestB(const std::string inName) :_name...
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
C++智能指针-unique-ptr智能指针详解.pdf
02-27
《C++智能指针——unique_ptr智能指针详解》 智能指针是C++中用于自动管理动态分配内存的一种工具，它可以确保在适当的时候自动释放内存，从而避免内存泄漏的问题。其中，`unique_ptr`是一种特殊的智能指针，它拥有...
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
C++智能指针及容器测试用例
06-11
在C++编程中，智能指针和容器是两个非常重要的概念，它们极大地提高了代码的效率和安全性。本文将深入探讨这两个主题，并结合`CppTest`测试框架，展示如何编写测试用例来验证其正确性。 首先，让我们了解智能指针。...
（头文件，智能指针和动态内存）c++第一次复习
weixin_43166107的博客
04-15 520
默认构造函数优先度 先执行构造函数初始值列表，列表中没有初始化的数据成员执行类内初始化，如果 前面两种方式都没有执行，则执行默认初始化。 头文件应该包括什么 （1）类的定义。 将类定义在头文件中，友元声明也应该与相应的类定义在同一个头文件中。 （2）const变量 建议const变量定义在cpp文件中，在头文件中只包含该const变量的声明（前提是这个const变量 需要在多文件中使用）。还有一点...
C++——智能指针
JAN6055的博客
01-29 1261
智能指针的简单介绍和使用
【C++】智能指针详解
chongchujianghu3的博客
02-11 219
参考资料：《C++ Primer中文版 第五版》 我们知道除了静态内存和栈内存外，每个程序还有一个内存池，这部分内存被称为自由空间或者堆。程序用堆来存储动态分配的对象即那些在程序运行时分配的对象，当动态对象不再使用时，我们的代码必须显式的销毁它们。 在C++中，动态内存的管理是用一对运算符完成的：new和delete，new:在动态内存中为对象分配一块空间并返回一个指向该对象的指针，delete：...
智能指针 （C++11）
weixin_71901858的博客
04-17 669
C++语言中堆内存的对象在new之后创建，如果忘记delete则会产生内存泄漏的问题。在Java、C#等语言直接提供垃圾回收机制来处理不使用的对象，因此在C++98中引入了智能指针的概念，能使堆内存对象自动回收，并在C++11趋于完善。智能指针主要用于管理堆内存对象的生命周期，本身指针对象是位于栈内存的对象，当智能指针对象的生命周期结束后，会在析构函数里释放管理的堆内存对象的内存空间，从而方式内存泄露。对象的指针位于栈，指向的内存在堆区。
C++指针的使用及注意事项
保持分享欲
02-21 1287
我们常说的指针是一个变量，为复合类型（包括数组、字符串、结构等），指针变量实质是指存储了一个内存地址。而变量会有自己的内存空间，所以虽然指针变量代表着另外一个内存地址，但其自身也会有对应的内存空间存储值，从而导致双重指针或多重指针的存在（多级间接寻址）。在计算机中每个变量都有自己的内存位置，并定义了使用地址运算符（&）可以取用的内存地址。即如果var是一个变量，则&var代表它的地址。总之，指针和内存管理是C++编程中非常重要的一部分，需要程序员对其有深入的理解和掌握。
2024年最全C++智能指针_主动销毁智能指针的方法(1)，2024年最新字节跳动面试
2401_84978673的博客
05-13 972
/当为0的时候删除计数器。AddCount();//对管理的新资源的计数器进行++DelCount();//释放管理的旧资源。
C++智能指针_主动销毁智能指针的方法
最新发布
2401_89722439的博客
12-20 1068
在C++中，动态内存的使用时有一定的风险的，因为它没有垃圾回收机制，很容易导致忘记释放内存的问题，具体体现在异常的处理上。想要释放掉抛异常的程序的一些内存，往往需要多次抛异常，这种处理方式是十分麻烦的。智能指针的本质就是使用一个对象来接管一段开辟的空间，在该对象在销毁的时候，自动调用析构函数来释放这段内存。因此智能指针的本质是一个类，类中最主要的对象是一个指针，该类的析构函数就是销毁该指针指向的空间，使用智能指针的本质就是将一个指向动态开辟空间的指针赋给该类中的指针。
C++智能指针实现与应用
"C++智能指针是一种管理动态分配内存的有效工具，它们通过引用计数或其他机制自动释放所指向的对象，防止内存泄漏。本资源主要介绍了一个自定义的智能指针实现，以及智能指针在C++编程中的重要性。" 在C++编程中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值