1. Toy模板网首页
  2. > Toy博客

C++智能指针shared_ptr详解

10月前 作者：Lion Long 分类：Toy博客 阅读(40) 违法举报

这篇具有很好参考价值的文章主要介绍了C++智能指针shared_ptr详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、简介

C++智能指针shared_ptr是一种可以自动管理内存的智能指针，它是C++11新增的特性之一。与传统指针不同，shared_ptr可以自动释放所管理的动态分配对象的内存，并避免了手动释放内存的繁琐操作，从而减少了内存泄漏和野指针的出现。

shared_ptr是一个模板类，通过引用计数器实现多个智能指针共享对一个对象的所有权。每次复制一个shared_ptr对象时，该对象的引用计数器会增加1，当最后一个shared_ptr对象被销毁时，引用计数器减1，如果引用计数器变为0，则释放所管理的对象的内存。

使用shared_ptr需要包含头文件，并且可以通过以下方式创建：

std::shared_ptr<int> p(new int(10));

上面的代码创建了一个shared_ptr对象p，它指向一个动态分配的int类型对象，初始值为10。

在使用shared_ptr时，需要注意以下几点：

  1. 不要使用裸指针来初始化shared_ptr，否则可能导致多次删除同一个对象的情况。

  2. 避免在shared_ptr中存储数组，因为shared_ptr只能处理单个对象的释放，而不能正确地处理数组的销毁。

  3. 可以通过自定义删除器（deleter）来实现对对象的特定方式的释放。

  4. shared_ptr可以作为函数参数传递，但要注意避免循环引用的问题，否则会导致内存泄漏。

shared_ptr是一种方便且安全的内存管理工具，能够有效地避免内存泄漏和野指针的出现。

二、底层原理

C++智能指针shared_ptr详解

2.1、引用计数

shared_ptr的核心是引用计数技术。在每个shared_ptr对象中，都有一个指向所管理对象的指针和一个整型计数器。这个计数器统计有多少个shared_ptr对象指向该所管理对象。当一个新的shared_ptr对象指向同一块内存时，该内存的引用计数就会增加1。当一个shared_ptr对象不再指向该内存时，该内存的引用计数就会减少1。当引用计数为0时，说明没有任何shared_ptr对象指向该内存，此时该内存将会被自动释放。

2.2、shared_ptr的构造和析构

  1. shared_ptr的构造函数需要一个指针作为参数，该指针指向要被管理的对象。当一个新的shared_ptr对象被创建时，它会尝试增加所管理对象的引用计数。如果该对象还未被其他shared_ptr对象管理，则会创建一个新的引用计数，并将其设置为1。否则，它会与已经存在的shared_ptr对象共享同一个引用计数。

  2. shared_ptr的析构函数会尝试减少所管理对象的引用计数。如果引用计数变成0，则会自动释放所管理对象的内存。

  3. shared_ptr的控制块（包含引用计数和删除器等信息）会在最后一个指向所管理对象的shared_ptr析构时被释放。当引用计数减为0时，就说明没有任何shared_ptr对象指向该所管理对象了，此时shared_ptr会自动调用删除器，并释放掉控制块。由于shared_ptr可以共享同一个控制块，因此只有所有shared_ptr对象都析构后，控制块才能被释放。如果一个shared_ptr对象使用reset()方法手动解除与所管理对象的关联，也会相应地减少引用计数，当引用计数变成0时，控制块也会被释放。

2.3、shared_ptr的共享和拷贝

shared_ptr可以与其他shared_ptr对象共享同一个指向对象的指针。当一个shared_ptr对象被复制时，它所管理的对象的引用计数也会增加1。因此，任何一个持有相同指针的shared_ptr对象都可以通过更改其所管理对象的状态来影响所有其他shared_ptr对象。

2.4、循环引用问题

如果一个对象A包含指向另一个对象B的shared_ptr，而对象B也包含指向对象A的指针，则这两个对象将形成循环引用。在这种情况下，可能会出现内存泄漏。

shared_ptr 循环引用问题是指两个或多个对象之间通过shared_ptr相互引用，导致对象无法被正确释放，从而造成内存泄漏。

常见的情况是两个对象A和B，它们的成员变量互相持有了对方的shared_ptr。当A和B都不再被使用时，它们的引用计数不会降为0，无法被自动释放。

解决这个问题的方法有以下几种：

1.打破循环引用：可以通过将shared_ptr改为weak_ptr来解决。weak_ptr是一种弱引用，不会增加对象的引用计数，在对象释放时会自动设置为nullptr。可以使用weak_ptr.lock()方法来获取对象的shared_ptr，当对象已经释放时会返回一个空shared_ptr。

2.使用std::enable_shared_from_this：如果其中一个对象A需要获取对另一个对象B的shared_ptr，可以让对象B继承std::enable_shared_from_this，并在A中使用shared_from_this()方法获取B的shared_ptr，这样就不会形成循环引用。

3.手动析构：如果无法修改代码结构或者无法使用前两种方法解决问题，可以使用手动析构的方式来释放对象。通过调用reset()方法手动释放shared_ptr，确保引用计数降为0，对象会被正确释放。

4.使用weak_ptr和shared_ptr组合：将两个对象的循环引用中的一个改为weak_ptr，另一个仍使用shared_ptr。这样可以避免循环引用导致的内存泄漏。

三、shared_ptr的使用

创建shared_ptr对象的语法有以下几种方式：

  1. 通过new关键字创建
std::shared_ptr<int> p(new int);
  1. 通过make_shared函数创建，该函数可以避免使用new关键字
std::shared_ptr<int> p = std::make_shared<int>();
  1. 传递指针和删除器作为参数创建
void my_deleter(int* p) {
    delete p;
}

std::shared_ptr<int> p(new int, my_deleter);
  1. 传递指针、删除器和分配器作为参数创建
void my_deleter(int* p) {
    delete p;
}

struct MyAllocator {
    void* allocate(size_t size);
    void deallocate(void* ptr, size_t size);
};

MyAllocator my_allocator;

std::shared_ptr<int> p(new int, my_deleter, my_allocator);
  1. 从另一个shared_ptr对象创建
std::shared_ptr<int> p1(new int);
std::shared_ptr<int> p2(p1);
  1. 使用移动语义从另一个shared_ptr对象创建
std::shared_ptr<int> p1(new int);
std::shared_ptr<int> p2(std::move(p1));

3.1、创建一个shared_ptr

使用shared_ptr创建一个智能指针非常简单，只需要将一个指向动态分配内存的裸指针作为参数传递给shared_ptr的构造函数即可：

// 创建一个int类型的智能指针
std::shared_ptr<int> p(new int(10));

3.2、共享一个shared_ptr

shared_ptr可以与其他shared_ptr对象共享同一个指向对象的指针，这样就可以避免多次动态分配内存和释放内存的问题。共享一个shared_ptr可以通过复制构造函数和赋值运算符实现：

// 复制构造函数
std::shared_ptr<int> p1(new int(10));
std::shared_ptr<int> p2(p1);

// 赋值运算符
std::shared_ptr<int> p3(new int(10));
std::shared_ptr<int> p4;
p4 = p3;

注意：共享一个shared_ptr会增加所管理对象的引用计数。因此，任何一个持有相同指针的shared_ptr对象都可以通过更改其所管理对象的状态来影响所有其他shared_ptr对象。

3.3、使用删除器

除了管理所分配的内存外，shared_ptr还可以使用删除器（deleter）来管理对象。删除器是一个函数或者函数对象，用于在shared_ptr释放所管理对象时执行特定的操作。删除器可以通过shared_ptr的模板参数指定：

// 使用Lambda表达式作为删除器
std::shared_ptr<int> p(new int(10), [](int* p){ delete[] p; });

3.4、解除关联

如果需要解除shared_ptr与所管理对象的关联，可以使用reset()方法：

std::shared_ptr<int> p(new int(10));
p.reset();

注意：当调用reset()方法后，所管理对象的引用计数会减少1。如果引用计数变成0，则会自动释放所管理对象的内存。

3.5、使用示例

#include <memory>
#include <iostream>

using namespace std;

class MyClass {
public:
    MyClass() { cout << "MyClass constructor" << endl; }
    ~MyClass() { cout << "MyClass destructor" << endl; }
    void printInfo() { cout << "This is MyClass" << endl; }
};

int main() {
    shared_ptr<MyClass> p1(new MyClass()); // 创建一个shared_ptr指向MyClass对象
    shared_ptr<MyClass> p2 = p1; // p1和p2都指向同一个MyClass对象

    p1->printInfo(); // 访问MyClass对象的成员函数
    p2.reset(); // 释放p2所指向的MyClass对象
    p1->printInfo(); // 由于p1仍然指向MyClass对象，所以此处输出"This is MyClass"

    return 0;
}

上述代码中，通过调用shared_ptr<MyClass>构造函数创建了两个指针p1和p2，并且它们都指向一个MyClass对象。我们调用reset()函数来释放p2所指向的MyClass对象，但是由于p1仍然指向该对象，所以在调用p1->printInfo()时仍然输出"This is MyClass"。当程序结束时，p1所指向的MyClass对象会被自动释放。

可以看到，使用shared_ptr可以很方便地避免内存泄漏和悬空指针等问题。另外，需要注意的是，shared_ptr指针之间的赋值和拷贝操作都会增加指向对象的引用计数，即使一个指针已经释放了它所指向的对象，只要其他指针还在使用该对象，该对象就不会被自动删除。因此，在使用shared_ptr时需要注意对象的生命周期，避免产生意外的副作用。

四、shared_ptr循环引用问题的解决方法

假设存在这样的循环引用：

#include <memory>

class B; //前向声明

class A {
public:
    std::shared_ptr<B> b_ptr; // A类持有B类的shared_ptr

    ~A() {
        std::cout << "A destructor" << std::endl;
    }
};

class B {
public:
    std::shared_ptr<A> a_ptr; // B类持有A类的shared_ptr

    ~B() {
        std::cout << "B destructor" << std::endl;
    }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    
    a->b_ptr = b;
    b->a_ptr = a;
    
    // 此时a和b之间形成了循环引用，导致其引用计数一直不为0

    return 0;
}

解决方法：

（1）使用weak_ptr打破循环引用： 将A类和B类中的shared_ptr改为weak_ptr，将对象引用改为弱引用，这样不会增加对象的引用计数，从而避免循环引用导致的内存泄漏。在需要使用对象的地方，可以通过lock()方法将weak_ptr转换为shared_ptr来进行使用，如果对象已被释放，则返回空shared_ptr。

#include <memory>

class B; //前向声明

class A {
public:
    std::weak_ptr<B> b_ptr; // A类持有B类的weak_ptr

    ~A() {
        std::cout << "A destructor" << std::endl;
    }
};

class B {
public:
    std::weak_ptr<A> a_ptr; // B类持有A类的weak_ptr

    ~B() {
        std::cout << "B destructor" << std::endl;
    }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    
    a->b_ptr = b;
    b->a_ptr = a;
    
    // 此时a和b之间形成了循环引用，但由于使用了weak_ptr，不会形成内存泄漏

    return 0;
}

（2）修改对象的引用关系： 考虑是否需要A类和B类之间互相持有shared_ptr的引用关系。如果某一方只需要单向引用，可以将其引用改为裸指针或者weak_ptr。这样可以避免形成循环引用。

#include <memory>

class B; //前向声明

class A {
public:
    std::shared_ptr<B> b_ptr; // A类持有B类的shared_ptr

    ~A() {
        std::cout << "A destructor" << std::endl;
    }
};

class B {
public:
    std::weak_ptr<A> a_ptr; // B类持有A类的weak_ptr

    ~B() {
        std::cout << "B destructor" << std::endl;
    }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    
    a->b_ptr = b;
    b->a_ptr = a;
    
    // 此时a和b之间形成了循环引用，但由于a->b_ptr改为shared_ptr，b->a_ptr改为weak_ptr，不会形成内存泄漏

    return 0;
}

（3）手动析构： 如果无法修改代码结构或者无法使用前两种方法解决问题，可以使用手动析构的方式来释放对象。通过调用reset()方法手动释放shared_ptr，确保引用计数降为0，对象会被正确释放。

#include <memory>

class B; //前向声明

class A {
public:
    std::shared_ptr<B> b_ptr; // A类持有B类的shared_ptr

    ~A() {
        std::cout << "A destructor" << std::endl;
    }
};

class B {
public:
    std::shared_ptr<A> a_ptr; // B类持有A类的shared_ptr

    ~B() {
        std::cout << "B destructor" << std::endl;
    }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    
    a->b_ptr = b;
    b->a_ptr = a;
    
    a.reset(); // 手动释放A对象
    b.reset(); // 手动释放B对象

    return 0;
}

（4）使用weak_ptr和shared_ptr组合： 将两个对象的循环引用中的一个改为weak_ptr，另一个仍使用shared_ptr。这样可以避免循环引用导致的内存泄漏。

#include <memory>

class B; //前向声明

class A {
public:
    std::shared_ptr<B> b_ptr; // A类持有B类的shared_ptr

    ~A() {
        std::cout << "A destructor" << std::endl;
    }
};

class B {
public:
    std::weak_ptr<A> a_ptr; // B类持有A类的weak_ptr

    ~B() {
        std::cout << "B destructor" << std::endl;
    }
};

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

    a->b_ptr = b;
    b->a_ptr = a;
    
    // 此时a和b之间形成了循环引用，但由于a->b_ptr使用shared_ptr，b->a_ptr使用weak_ptr，不会形成内存泄漏

    return 0;
}

总结

智能指针是C++中一种重要的语言机制，其中shared_ptr是最常用和最经典的智能指针之一。

  1. shared_ptr是一种引用计数的智能指针，可以共享同一个对象。

  2. 使用shared_ptr时，需要包含头文件< memory >。

  3. 创建shared_ptr对象时，可以直接将原始指针作为参数传递给构造函数，也可以使用make_shared函数进行创建。

  4. 对象的引用计数会在shared_ptr对象初始化、复制、释放时自动更新。

  5. 当某个shared_ptr对象被销毁时，它所指向的对象的引用计数会减少，如果引用计数为0，则该对象会被自动删除。

  6. 通过get函数可以获取shared_ptr对象所管理的原始指针。

  7. 通过reset函数可以重新绑定shared_ptr对象所管理的原始指针。

  8. 可以使用unique函数判断shared_ptr对象是否唯一拥有原始指针。

  9. 通常情况下，shared_ptr对象应该在栈上创建，而不是使用new运算符在堆上创建。

  10. 在多线程环境下使用shared_ptr时需要注意，需要采取线程安全措施，比如使用锁来保证引用计数的正确性。

  11. shared_ptr是C++11中STL的一部分，它是一个模板类，用于管理动态地分配对象的内存。shared_ptr可以自动完成内存管理，确保内存被正确释放，并且非常易于使用。

  12. shared_ptr是一个强大的智能指针类，它利用引用计数技术来管理动态分配的对象的内存。shared_ptr可以避免循环引用和内存泄漏等问题，并且易于使用，是C++程序员必不可少的工具之一。

C++智能指针shared_ptr详解文章来源地址https://www.toymoban.com/news/detail-420881.html

到了这里，关于C++智能指针shared_ptr详解的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • C++之weak_ptr与shared_ptr智能指针实例(一百九十五)

    C++之weak_ptr与shared_ptr智能指针实例(一百九十五)

    简介： CSDN博客专家，专注Android/Linux系统，分享多mic语音方案、音视频、编解码等技术，与大家一起成长！ 优质专栏： Audio工程师进阶系列 【 原创干货持续更新中…… 】🚀 人生格言： 人生从来没有捷径，只有行动才是治疗恐惧和懒惰的唯一良药. 更多原创,欢迎关注：An

    2024年02月09日
    浏览(62)
  • C++11中的智能指针unique_ptr、shared_ptr和weak_ptr详解

    C++11中的智能指针unique_ptr、shared_ptr和weak_ptr详解

    目录 1、引言 2、什么是智能指针？ 3、在Visual Studio中查看智能指针的源码实现 4、独占式指针unique_ptr 4.1、查看unique_ptr的源码实现片段 4.2、为什么unique_ptr的拷贝构造函数和复制函数被delete了？（面试题） 4.3、使用unique_ptr独占式智能指针的实例 5、共享式指针shared_ptr  5.1、查

    2024年02月08日
    浏览(44)

  • 智能指针shared_ptr

    shared_ptr共享它指向的对象，内部采用计数机制来实现。当新的shared_ptr与对象关联时，引用计数加1；当shared_ptr超出作用域时，引用计数减1；当引用计数为0时，释放该对象； shared_ptrA p0 = std::make_sharedA(\\\"西红柿\\\");//C++11提供 重载了*和-操作符，可以像使用指针一样使用shared_ptr

    2023年04月23日
    浏览(39)

  • C++11 新特性 ⑥ | 智能指针 unique_ptr、shared_ptr 和 weak_ptr

    目录 1、引言 2、unique_ptr 3、shared_ptr 4、weak_ptr 5、shared_ptr循环引用问题（面试题）

    2024年02月09日
    浏览(48)

  • 深入理解和应用C++ std::shared_ptr别名构造函数

    在现代C++中，智能指针是一个极为重要的工具，尤其std::shared_ptr以其自动内存管理、引用计数和多线程安全性等特性深受开发者喜爱。其中一个不太常用但功能强大的构造方式是 别名构造函数 ，它允许我们创建一个共享相同底层对象但是指向其内部不同数据成员或子对象的

    2024年01月16日
    浏览(46)
  • 【C++入门到精通】智能指针 auto_ptr、unique_ptr简介及C++模拟实现 [ C++入门 ]

    【C++入门到精通】智能指针 auto_ptr、unique_ptr简介及C++模拟实现 [ C++入门 ]

    在 C++ 中，智能指针是一种非常重要的概念，它能够帮助我们自动管理动态分配的内存，避免出现内存泄漏等问题。在上一篇文章中，我们了解了智能指针的基本概念和原理， 本篇文章将继续介绍 auto_ptr 和 unique_ptr 两种智能指针的概念及其在 C++ 中的模拟实现 。通过学习这些

    2024年01月19日
    浏览(62)

  • shared_ptr和unique_ptr主动释放

    shared_ptr和unique_ptr均可以采用reset()来进行释放，unique_ptr调用了reset之后就会直接释放掉，shared_ptr则会在所有引用计数变为0的时候才会释放申请的内存。 注意unique_ptr的release()方法，并不会释放资源，只会把unique_ptr置为空指针，原来那个资源可以继续调用 reset 结果： 在reset之

    2024年02月14日
    浏览(39)

  • 论 shared_ptr的线程安全

    今天有同事问我shared_ptr是线程更安全的吗？我当时脑子一懵，有点不确定。 但回过神来仔细一想这什么鸟问题，c++ stl里有线程安全的吗，shared_ptr 也不是针对线程安全而设计出来的呀，八竿子打不着的东西为什么会凑在一起问。 好像也就一个atmoic引用计数可以沾上边。 首先

    2024年02月08日
    浏览(38)

  • 面试之快速学习C++11-完美转发，nullptr, shared_ptr,unique_ptr,weak_ptr,shared_from_this

    函数模版可以将自己的参数完美地转发给内部调用的其他函数。所谓完美，即不仅能准确地转发参数的值，还能保证被转发参数的左右值属性不变 引用折叠：如果任一引用为左值引用，则结果为左值引用，否则为右值引用。 上述 T 为int 。 那么整个为 int - int 回到完美转发，

    2024年02月12日
    浏览(36)
  • 【cmu15445c++入门】(8)C++ 智能指针unique_ptr

    【cmu15445c++入门】(8)C++ 智能指针unique_ptr

    智能指针是一种数据结构，用于没有内置内存管理的语言（例如 C++）中的内存管理（有时还有其他功能）。内置内存管理的语言的指的是具有垃圾回收功能的语言，如Java、Python。 现代C++标准库的两个智能指针（以及您将在类中使用的智能指针）是 std::unique_ptr 和 std::shared_

    2024年02月20日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包