智能指针shared_ptr

已于 2025-02-09 20:00:08 修改
阅读量988 收藏 16
点赞数 15
文章标签： c++ 开发语言
于 2025-02-09 19:58:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/y470990045/article/details/145536008
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

std::shared_ptr 是 C++ 标准库中用于管理动态分配对象的智能指针，它采用引用计数机制来实现多个智能指针共享同一个对象的所有权，当引用计数降为 0 时，所管理的对象会被自动释放，从而避免内存泄漏。以下是关于 std::shared_ptr 的详细用法及各个函数说明：

一、使用介绍

1. 包含头文件

要使用 std::shared_ptr，需要包含 头文件：

#include <memory>

2. 创建 std::shared_ptr

2.1 使用构造函数

#include <iostream>
#include <memory>
class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass destructor" << std::endl; }
};
int main() {
    // 使用构造函数创建 std::shared_ptr
    std::shared_ptr<MyClass> ptr1(new MyClass());
    return 0;
}

这里直接使用 new 运算符创建一个 MyClass 对象，并将其交给 std::shared_ptr 管理。

2.2 使用 std::make_shared

#include <iostream>
#include <memory>
class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass destructor" << std::endl; }
};
int main() {
    // 使用 std::make_shared 创建 std::shared_ptr
    std::shared_ptr<MyClass> ptr2 = std::make_shared<MyClass>();
    return 0;
}

std::make_shared 是 C++11 引入的一个便捷函数，它可以更高效地创建 std::shared_ptr，避免了不必要的内存分配。

3. 引用计数相关操作

3.1 use_count()

#include <iostream>
#include <memory>
class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass destructor" << std::endl; }
};
int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> ptr2 = ptr1;
    std::cout << "ptr1 use count: " << ptr1.use_count() << std::endl;
    std::cout << "ptr2 use count: " << ptr2.use_count() << std::endl;
    return 0;
}

use_count() 函数返回当前 std::shared_ptr 所管理对象的引用计数，即有多少个 std::shared_ptr 共享同一个对象。

3.2 复制和赋值操作

#include <iostream>
#include <memory>
class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass destructor" << std::endl; }
};
int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> ptr2 = ptr1;  // 复制构造
    std::shared_ptr<MyClass> ptr3;
    ptr3 = ptr1;  // 赋值操作
    std::cout << "ptr1 use count: " << ptr1.use_count() << std::endl;
    std::cout << "ptr2 use count: " << ptr2.use_count() << std::endl;
    std::cout << "ptr3 use count: " << ptr3.use_count() << std::endl;
    return 0;
}

复制构造和赋值操作会增加引用计数，当 std::shared_ptr 被销毁或重置时，引用计数会减少。

4. 访问所管理的对象

4.1 解引用运算符 *

#include <iostream>
#include <memory>
class MyClass {
public:
    void doSomething() { std::cout << "Doing something..." << std::endl; }
};
int main() {
    std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();
    (*ptr).doSomething();
    return 0;
}

使用解引用运算符 * 可以访问 std::shared_ptr 所管理的对象。

4.2 箭头运算符 ->

#include <iostream>
#include <memory>
class MyClass {
public:
    void doSomething() { std::cout << "Doing something..." << std::endl; }
};
int main() {
    std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();
    ptr->doSomething();
    return 0;
}

箭头运算符 -> 可以直接访问所管理对象的成员函数或成员变量。

5. 重置 std::shared_ptr

5.1 reset()

#include <iostream>
#include <memory>
class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass destructor" << std::endl; }
};
int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> ptr2 = ptr1;
    std::cout << "Before reset, ptr1 use count: " << ptr1.use_count() << std::endl;
    ptr1.reset();
    std::cout << "After reset, ptr1 use count: " << ptr1.use_count() << std::endl;
    std::cout << "After reset, ptr2 use count: " << ptr2.use_count() << std::endl;
    return 0;
}

reset() 函数会减少当前 std::shared_ptr 的引用计数，如果引用计数降为 0，则释放所管理的对象。调用 reset() 后，该 std::shared_ptr 会变为空指针。

5.2 reset(new T())

#include <iostream>
#include <memory>
class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass destructor" << std::endl; }
};
int main() {
    std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();
    ptr.reset(new MyClass());
    return 0;
}

reset(new T()) 会先减少当前 std::shared_ptr 的引用计数，如果引用计数降为 0，则释放所管理的对象，然后让该 std::shared_ptr 管理一个新创建的对象。

6. 获取原始指针

get()

#include <iostream>
#include <memory>
class MyClass {
public:
    void doSomething() { std::cout << "Doing something..." << std::endl; }
};
int main() {
    std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();
    MyClass* rawPtr = ptr.get();
    rawPtr->doSomething();
    return 0;
}

get() 函数返回 std::shared_ptr 所管理对象的原始指针。需要注意的是，使用原始指针时要小心，避免在 std::shared_ptr 释放对象后继续使用该指针，否则会导致未定义行为。

7. 自定义删除器

#include <iostream>
#include <memory>
class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass destructor" << std::endl; }
};
void customDeleter(MyClass* obj) {
    std::cout << "Custom deleter called" << std::endl;
    delete obj;
}
int main() {
    std::shared_ptr<MyClass> ptr(new MyClass(), customDeleter);
    return 0;
}

std::shared_ptr 允许使用自定义删除器，当引用计数降为 0 时，会调用自定义删除器来释放对象，而不是使用默认的 delete 操作符。
综上所述，std::shared_ptr 提供了方便的内存管理功能，通过引用计数机制实现多个智能指针共享同一个对象的所有权。在使用时，要注意避免循环引用问题，以免导致内存泄漏。

二、shared_ptr 如何避免循环引用

在 C++ 中，std::shared_ptr 采用引用计数的方式来管理对象的生命周期，多个 std::shared_ptr 可以共享同一个对象，当引用计数降为 0 时，对象会被自动释放。然而，循环引用会导致引用计数永远无法降为 0，从而造成内存泄漏。以下详细介绍循环引用的产生原因以及避免循环引用的方法。

1. 循环引用的产生原因

当两个或多个对象通过 std::shared_ptr 相互引用时，就会形成循环引用。例如，有两个类 A 和 B，它们各自持有对方的 std::shared_ptr，示例代码如下：

#include <iostream>
#include <memory>
class B;
class A {
public:
    std::shared_ptr<B> bPtr;
    A() { std::cout << "A constructor" << std::endl; }
    ~A() { std::cout << "A destructor" << std::endl; }
};
class B {
public:
    std::shared_ptr<A> aPtr;
    B() { std::cout << "B constructor" << std::endl; }
    ~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->bPtr = b;
    b->aPtr = a;
    return 0;
}

在上述代码中，A 对象持有一个指向 B 对象的 std::shared_ptr，B 对象也持有一个指向 A 对象的 std::shared_ptr。当 main 函数结束时，a 和 b 超出作用域，它们的引用计数减 1，但由于彼此之间的相互引用，引用计数仍然不为 0，因此 A 和 B 对象不会被销毁，从而造成内存泄漏。

2. 避免循环引用的方法

2.1 使用 std::weak_ptr

std::weak_ptr 是一种弱引用智能指针，它不拥有对象的所有权，不会增加对象的引用计数。可以将其中一个或多个 std::shared_ptr 替换为 std::weak_ptr 来打破循环引用。修改后的代码如下：

#include <iostream>
#include <memory>
class B;
class A {
public:
    std::shared_ptr<B> bPtr;
    A() { std::cout << "A constructor" << std::endl; }
    ~A() { std::cout << "A destructor" << std::endl; }
};
class B {
public:
    std::weak_ptr<A> aPtr;  // 使用 std::weak_ptr 避免循环引用
    B() { std::cout << "B constructor" << std::endl; }
    ~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->bPtr = b;
    b->aPtr = a;
    return 0;
}

在这个修改后的代码中，B 类中的 aPtr 被改为 std::weak_ptr。当 main 函数结束时，a 和 b 超出作用域，它们的引用计数减 1，由于 b->aPtr 是弱引用，不影响 A 对象的引用计数，因此 A 对象的引用计数降为 0，A 对象被销毁。A 对象销毁后，B 对象的引用计数也降为 0，B 对象也会被销毁，从而避免了内存泄漏。

2.2 std::weak_ptr 的使用方法

std::weak_ptr 不能直接访问所引用的对象，需要先将其转换为 std::shared_ptr 才能访问。可以使用 lock() 函数来实现转换，示例代码如下：

#include <iostream>
#include <memory>
class B;
class A {
public:
    std::shared_ptr<B> bPtr;
    A() { std::cout << "A constructor" << std::endl; }
    ~A() { std::cout << "A destructor" << std::endl; }
};
class B {
public:
    std::weak_ptr<A> aPtr;
    void accessA() {
        std::shared_ptr<A> sharedA = aPtr.lock();
        if (sharedA) {
            std::cout << "Accessing A from B" << std::endl;
        } else {
            std::cout << "A has been destroyed" << std::endl;
        }
    }
    B() { std::cout << "B constructor" << std::endl; }
    ~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->bPtr = b;
    b->aPtr = a;
    b->accessA();
    return 0;
}

在 B 类的 accessA() 方法中，使用 aPtr.lock() 将 std::weak_ptr 转换为 std::shared_ptr，如果所引用的对象还存在，则转换成功，可以通过返回的 std::shared_ptr 访问对象；如果对象已经被销毁，则 lock() 函数返回一个空的 std::shared_ptr。
通过使用 std::weak_ptr，可以有效地避免 std::shared_ptr 之间的循环引用问题，确保对象在不再被使用时能够正确释放内存。

三、shared_ptr 和 unique_ptr 有什么区别

std::shared_ptr 和 std::unique_ptr 都是 C++ 标准库 中用于管理动态分配内存的智能指针，它们的设计目的是帮助开发者避免手动管理内存时可能出现的内存泄漏和悬空指针等问题，但二者在所有权语义、性能、使用场景等方面存在显著区别，以下是详细对比：

1. 所有权语义

std::unique_ptr
独占所有权：std::unique_ptr 对其所指向的对象拥有独占所有权，即同一时间只能有一个 std::unique_ptr 指向该对象。当这个 std::unique_ptr 被销毁或者重置时，它所管理的对象也会被自动销毁。
示例代码：

#include <iostream>
#include <memory>
class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass destructor" << std::endl; }
};
int main() {
    std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>();
    // std::unique_ptr<MyClass> ptr2 = ptr1;  // 编译错误，不能直接拷贝
    std::unique_ptr<MyClass> ptr2 = std::move(ptr1);  // 可以通过移动语义转移所有权
    if (!ptr1) {
        std::cout << "ptr1 is now empty." << std::endl;
    }
    return 0;
}

std::shared_ptr
共享所有权：多个 std::shared_ptr 可以同时指向同一个对象，它们通过引用计数机制来管理对象的生命周期。每个 std::shared_ptr 都会维护一个引用计数，记录有多少个 std::shared_ptr 共享该对象。当引用计数变为 0 时，对象会被自动销毁。
示例代码：

#include <iostream>
#include <memory>
class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass destructor" << std::endl; }
};
int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> ptr2 = ptr1;  // 可以拷贝，引用计数加 1
    std::cout << "Reference count: " << ptr1.use_count() << std::endl;
    return 0;
}

2. 性能差异

std::unique_ptr
轻量级：由于 std::unique_ptr 是独占所有权，不需要维护引用计数，所以它的实现通常比 std::shared_ptr 更轻量级，开销更小。创建、销毁和转移所有权的操作都非常高效。
std::shared_ptr
引用计数开销：std::shared_ptr 需要维护引用计数，这涉及到额外的内存分配和原子操作（为了保证线程安全），因此在频繁进行所有权转移和共享的场景下，会带来一定的性能开销。

3. 所有权转移方式

std::unique_ptr
移动语义：std::unique_ptr 的所有权转移只能通过移动语义（std::move）来实现。移动后，原 std::unique_ptr 会失去对对象的所有权，变为空指针。
std::shared_ptr
拷贝和赋值：std::shared_ptr 可以通过拷贝构造函数和赋值运算符进行所有权共享，每次拷贝或赋值操作都会增加引用计数。

4. 使用场景

std::unique_ptr
明确独占关系：适用于对象的所有权明确，且不需要共享的场景。例如，在函数内部管理局部对象的生命周期，或者一个类独占某个资源时使用。
作为函数返回值：常用于函数返回动态分配的对象，避免内存泄漏。

#include <memory>
std::unique_ptr<int> createInt() {
    return std::make_unique<int>(42);
}

std::shared_ptr
多对象共享：适用于多个地方需要访问同一个对象，并且对象的生命周期需要由多个部分共同管理的场景。例如，在多线程环境中，多个线程可能需要同时访问同一个对象，此时可以使用 std::shared_ptr 来确保对象在所有线程都不再使用时才被释放。
容器存储：当需要将多个指向同一对象的指针存储在容器中时，std::shared_ptr 是一个合适的选择。

#include <memory>
#include <vector>
int main() {
    std::shared_ptr<int> ptr = std::make_shared<int>(42);
    std::vector<std::shared_ptr<int>> vec;
    vec.push_back(ptr);
    return 0;
}

综上所述，std::unique_ptr 和 std::shared_ptr 在不同的场景下各有优势，开发者应根据具体需求选择合适的智能指针。

总结

以上就是今天要讲的内容，本文仅仅简单介绍了智能指针share_ptr的使用，后续项目开发中可以借鉴参考。

y470990045
关注
C++11中的智能指针unique_ptr、shared_ptr和weak_ptr详解
dvlinker的技术专栏
05-28 3万+
详细讲解C++11中引入的智能指针unique_ptr、shared_ptr和weak_ptr。
shared_ptr:线程安全、循环引用
liuxuejiang158的专栏
10-23 3217
shared_ptr用来管理堆对象可以避免delete，但是注意shared_ptr本身是个对象因此其的声明周期、shared_ptr对象的读写操作非原子化那么在多线程环境下仍然存在很多问题，即shared_ptr对象本身的线程安全级别非100%。在多线程中访问同一个shared_ptr对象应该用mutex保护。    shared_ptr使用不当会延长锁管理的对象(假设为A)的生命周期，即有什
shared_ptr循环引用
chenxijie1985的专栏
03-15 4574
循环引用：两个对象相互使用shared_ptr成员变量指向对方造成循环引用，导致引用计数失效。 即A内部有指向B，B内部有指向A，这样对于A，B必定是在A析构后B才析构，对于B，A必定是B析构后才析构A，这就是循环引用的问题，违反常规，导致内存泄露。 示例代码： #include ciostream> #include<nemory> using namespace std; class BB; class AA{ public: shared_ptr<B
c++智能指针详解，如何防止循环引用
最新发布
z3363的博客
03-13 1127
智能指针是c++ 11标准，添加的用于管理内存资源的类，通过智能指针我们可以，轻松的对内存进行分配与释放，这使得我们不再需要，为手动管理内存的繁琐而烦恼了，主要有三个智能指针，分别是unique_ptrshared_ptrweak_ptr，我们下面一一介绍我们先来看看智能指针的基本使用上面这一部分代码，如果没有智能指针是不可以出现~Test析构的，而使用了智能指针后当func1函数退出时，我们创建的资源就自动被释放了，这就是智能指针的魅力，利用RAII思想完美实现资源的管理，真的非常方便且高效。
(C++) share_ptr 之循环引用
cuber-lotus的博客
04-25 2514
unique_ptrshared_ptrweak_ptr都是内存管理中的非常重要的一部分动态内存管理 - cppreference.com。其中shared_ptr在实际应用中具有非常广泛的应用。而由于其较unique_ptr的功能多，有引用计数的概念。导致存在一个名为循环引用的问题。这是一个非常经典的坑。但解决方案也不是很复杂。下面来一起看看吧。
shared_ptr-循环引用问题
m0_69597277的博客
05-28 1216
前文我们阐述了智能指针的思想和进行了简单的实现，当然最后提出了shared_ptr引用计数的线程安全问题，最简单的方式就是通过加锁来进行实现。智能指针内容：C++ 智能指针原理及简单实现那解决了引用计数的问题就可以了吗？其实不然，要使shared_ptr是线程安全的，就还得解决shared_ptr的循环引用的问题。编译环境：vs2013C++11和boost中智能指针的关系(1) C++ 98 中产生了第一个智能指针auto_ptr。
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
本文主要讨论了三种智能指针：`shared_ptr`、`unique_ptr`和`weak_ptr`。 首先，`shared_ptr`是引用计数型智能指针，它维护了一个内部的引用计数，用于跟踪有多少个`shared_ptr`实例指向同一对象。当创建一个新的`...
C++智能指针shared_ptr分析
12-26
C++智能指针shared_ptr分析 概要： shared_ptr是c++智能指针中适用场景多，功能实现较多的智能指针。它采取引用计数的方法来实现释放指针所指向的资源。下面是我代码实现的基本功能。 实例代码： template class ...
C++ 浅谈之智能指针 shared_ptr 循环引用
优质后端技术知识记录
02-02 1182
智能指针 shared_ptr 循环引用
C++11/std::shared_ptr - 循环引用问题
HW140701的博客
04-02 1360
在C++11智能指针的使用过程中，一个很大的陷阱就是陷入了循环引用问题，这个问题类似于大型项目中两个头文件互相包含的问题，而在C++11中如果因为使用智能指针而引发了循环引用问题，那么其结果会导致智能指针无法释放，导致动态内存泄漏。 下面是一个典型的循环引用示例： class B; class A { public: std::shared_ptr<B> pointer_B; ...
智能指针std::shared_ptr之循环引用
独孤过的博客
10-23 3138
类的成员变量包含共享指针，假设类的两个实例由共享指针管理，分别称为此实例与彼实例，此实例的共享指针指向彼实例，而彼实例的共享指针指向此实例。 上述情况可以视为，由共享指针管理的外层对象持有内层对象，而内层对象以共享指针形式直接或者间接引用外层对象。 销毁外层对象的前提是内层对象不再引用外层对象，而内层对象在析构之时才解除引用，即必须先销毁外层对象。似此对象之间跨层级相互引用，而无法解除引用关系，形成循环引用。
shared_ptr循环引用问题
persistence_s的博客
04-03 857
shared_ptr循环引用会造成内存泄漏如下所示#include<iostream> #include"boost\shared_ptr.hpp" #include"boost\weak_ptr.hpp" #include<stdlib.h> using namespace std; struct Node { boost::shared_ptr<Node> pNext; boos
每日C++ - shared_ptr 的循环引用问题
whose book 的博客
02-27 729
shared_ptr 的循环引用问题 在 C++ 开发过程中，面对浩繁的代码工作，不免会出现各种 bug，而在智能指针使用方面也存在一些难以察觉的坑。shared_ptr 循环引用造成内存泄漏就是一例。当两个内存对象分别拥有对方的非 nullptr 的 shared_ptr 类型的智能指针，导致 shared_ptr 引用计数无法归 0，从而造成系统内存泄漏。 我们来看下面的代码 class B; class A { public: A() = default; ~A() { std::co
C++11：shared_ptr循环引用问题
2201_75880188的博客
04-30 1035
详细介绍了引用循环出现的场景及为什么会出现引用循环，以及如何解决引用循环，引入了weak的概念。
【C++】shared_ptr中循环引用问题
horizon_ys的博客
02-08 588
shared_ptr中循环引用问题 测试代码如下： 代码中含有两个类，Parent和Child。 Parent类成员中有一个Child类的智能指针。 Child类成员中有一个Parent类的智能指针。 #include <iostream> #include <memory> ​ class Child; typedef std::shared_ptr<Child> ChildPtr; class Parent; typedef std::sha...
C++智能指针shared_ptr使用示例
### 智能指针shared_ptr的Demo知识点 #### 智能指针概念 智能指针是C++中用于管理动态内存的类模板。它能够确保当智能指针对象超出其作用域时，所指向的动态分配的内存能够自动释放，从而避免内存泄漏。智能指针是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值