enable_from_this方法的使用与陷阱

最新推荐文章于 2025-06-01 16:40:41 发布
最新推荐文章于 2025-06-01 16:40:41 发布
阅读量3.5k 收藏 4
点赞数
分类专栏： boost
enable_from_this 的使用与实现原理说明：

shared_from_this()是enable_shared_from_this的成员函数，返回shared_ptr;
注意的是，这个函数仅在shared_ptr的构造函数被调用之后才能使用。
原因是enable_shared_from_this::weak_ptr并不在构造函数中设置，而是在shared_ptr的构造函数中设置。

使用场合：当前类A的实例对象正被share_ptr管理，且在类A的成员函数里需要把当前类对象作为参数传给其他函数时，就需要传递一个指向此类A的实例对象自身的share_ptr。

错误的使用代码一：

#include<boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>

#include <iostream>
using namespace std;

class D: public boost::enable_shared_from_this<D>
{
public:
    D()
    {
        cout<<"D::D()"<<endl;
        boost::shared_ptr<D> p= shared_from_this();
    }    
};

int main()
{
    boost::shared_ptr<D> a(new D);
    return 0;    
}


程序编译通过，执行结果如下：
D::D()
terminate called after throwing an instance of 'boost::exception_detail::clone_impl >'
  what():  tr1::bad_weak_ptr
Aborted

说明在D的构造函数中调用shared_from_this(), 此时D的实例本身尚未构造成功，weak_ptr也就尚未设置,所以程序抛出tr1::bad_weak_ptr异常。


错误的使用代码二：


#include<boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>

#include <iostream>
using namespace std;

class D: public boost::enable_shared_from_this<D>
{
public:
    D()
    {
        cout<<"D::D()"<<endl;
    }
    
    void func()
    {
        cout<<"D::func()"<<endl;
        boost::shared_ptr<D> p= shared_from_this();
    }    
};

int main()
{
    D d;
    d.func();
    return 0;    
}


程序编译通过，执行结果如下：
D::D()
D::func()
terminate called after throwing an instance of 'boost::exception_detail::clone_impl >'
  what():  tr1::bad_weak_ptr
Aborted

失败原因分析：

在主函数main中，D的实例是在栈上构造，没有使用boost::shared_ptr 的构造方式，
所以boost::enable_shared_from_this中的weak_ptr所指的函数对象也就没有被赋值，
在调用d.func()中使用shared_from_this()函数时

----注：shared_from_this的函数实现 ------
    shared_ptr shared_from_this()
    {
        shared_ptr p( weak_this_ );
        BOOST_ASSERT( p.get() == this );
        return p;
    }
----注：shared_from_this的函数实现 ------

调用BOOST_ASSERT( p.get() == this );  失败，抛出以上异常。


最后，我们给出share_from_this()的正确使用例子:



#include<boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>

#include <iostream>
using namespace std;

class D: public boost::enable_shared_from_this<D>
{
public:
    D()
    {
        cout<<"D::D()"<<endl;
    }
    
    void func()
    {
        cout<<"D::func()"<<endl;
        boost::shared_ptr<D> p= shared_from_this();
    }    
};

int main()
{
    boost::shared_ptr<D> p(new D);
    p->func();
    return 0;    
}    


执行结果:
D::D()
D::func()
enable_shared_from_this
突围
11-03 352
enable_shared_from_this是一个模板类，让子类拥有一个shared_from_this成员方法。 应用于shared_ptr的共享对象中，对于类型T的共享对象tt，会生成一个shared_from_this方法， 与共享对象分享tt的所有权。 Enable shared_from_this Base class that enables the shared_from_this member function in derived classes. The class provi.
C++11新特性之十：enable_shared_from_this
热门推荐
草上爬的博客
02-27 10万+
enable_shared_from_this是一个模板类，定义于头文件&lt;memory&gt;，其原型为：template&lt; class T &gt; class enable_shared_from_this;       std::enable_shared_from_this 能让一个对象（假设其名为 t ，且已被一个 std::shared_ptr 对象 pt 管...
详解shared_from_this
m0_53518956的博客
03-30 543
是 C++ 标准库 () 提供的一个机制，允许类在不创建新的的情况下，获取指向自身的，从而安全地管理对象的共享所有权。避免引发。确保对象生命周期，在回调、事件管理等场景中常用。必须确保对象已由管理，否则调用会导致运行时错误。在 C++ 中，是一个强大而易踩坑的工具，正确使用它可以防止内存泄漏和未定义行为。
(转)enable_from_this方法的使用与陷阱
weixin_34149796的博客
03-17 209
转自http://blog.chinaunix.net/uid-442138-id-2122464.html enable_from_this 的使用与实现原理说明： shared_from_this()是enable_shared_from_this的成员函数，返回shared_ptr; 注意的是，这个函数仅在shared_ptr的构造函数被调用之后才能使用。 原因是en...
C++ 中 enable_shared_from_this 的使用总结
编程猿来如此
07-19 2021
C++ 中 enable_shared_from_this 的使用总结
深入理解 shared_ptr 与 enable_shared_from_this
最新发布
h a 6 6 6 c k 为 你解决复杂难题！
06-01 75
是一个模板类，用于协助派生类安全地生成指向自身的shared_ptr。这些函数返回一个指向当前对象的shared_ptr，前提是该对象已经被至少一个shared_ptr所管理。特性描述shared_ptr共享所有权的智能指针，自动管理对象生命周期协助类，提供方法优势安全地从对象内部获取shared_ptr，避免重复管理限制必须已被shared_ptr管理；不能在构造函数中调用应用场景异步回调、观察者模式、资源管理等。
C++智能指针使用陷阱、shared_ptr实现
lmy347771232的博客
07-02 522
智能指针的使用陷阱
C++11智能指针( shared_ptr，unique_ptr，weak_ptr 的使用方法与注意事项)
LearningMegan
04-26 1695
智能指针是存储指向动态分配（堆）对象的类，用于生存期控制，能够确保在离开指针所在作用域时，自动正确地销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是使用引用计数。每使用它一次，内部的引用计数加1，每析构一次，内部引用计数减1，减为0时，删除所指向的堆内存。 C++11 提供了 3 种智能指针：std::shared_ptr，std::uniq_ptr，std::weak_ptr，使用时需要引用头文件<memory>。 ...
shared_ptr使用时的陷阱
程序猿的博客
07-24 638
1：不要把一个原生指针给多个shared_ptr管理 int* ptr = new int; shared_ptr<int> p1(ptr); shared_ptr<int> p2(ptr); //logic error ptr对象被删除了2次 这种问题比喻成“二龙治水”，在原生指针中也同样可能发生。 2：不要把this指针给shared_ptr class Test{ public: void Do(){ m_sp = shared_ptr<Test>(t
【C++智能指针的陷阱与解决方案】：std::shared_ptr常见问题深度解析
[【C++智能指针的陷阱与解决方案】：std::shared_ptr常见问题深度解析](https://media.geeksforgeeks.org/wp-content/uploads/20191202231341/shared_ptr.png) # 1. C++智能指针概述与std::shared_ptr简介 在现代...
enable_shared_from_this实现原理
weixin_43599089的博客
09-23 1807
如果需要使用this指针构造，T 必须public 继承，且 T 的构造需要通过，否则毫无意义。也就是说如果你不打算用智能指针管理你的实例，你压根不需要考虑这些。类成员shared_ptr构造函数->->
浅析shared_ptr的enable_shared_from_this
dahaiI0的专栏
02-18 707
浅析shared_ptr的enable_shared_from_this背景解决方法原理 背景 考虑以下场景，当一个对象被shared_ptr托管时，怎么从自身返回一个shared_ptr对象 struct A { public: std::shared_ptr<A> GetSharedPtrFromThis() { return std::shared_ptr<A>(this); } }; class B { public: void SetCallback(cons
std::enable_shared_from_this作用
davidhopper的博客
12-10 1157
这个类有什么用呢？很多文章讲得云里雾里，不知所以然。其实他的作用很简单。之类的指针）时，经常需要返回一个类对象自身的指针，也步是。朴素的想法应该类似如下示例（文件命名为。来替换原生指针，那么如何返回一个原生指针。从上述调用堆栈可看出，C++11及之后的标准推出了一个类。对象内存在在双重释放，程序崩溃。现在，我们使用智能指针。进入GDB界面后，按下。
shared_from_this 几个值得注意的地方
weixin_34127717的博客
09-09 363
shared_from_this()是enable_shared_from_this&lt;T&gt;的成员 函数，返回shared_ptr&lt;T&gt;。首先需要注意的是，这个函数仅在shared_ptr&lt;T&gt;的构造函数被调用之后才能使 用。原因是enable_shared_from_this::weak_ptr并不在构造函数中设置，而是在shared_ptr&lt;T&gt;的...
C++ 的shared_ptr指针深度介绍一下
03-08
<think>好的，我现在需要详细介绍一下C++中的shared_ptr智能指针。首先，我应该从基本概念开始，解释什么是shared_ptr，它的作用和设计目的。然后，需要讨论它的核心机制，比如引用计数，所有权共享，以及如何避免内存泄漏。 接下来，我应该考虑构造和初始化的方法，比如直接构造、使用make_shared，或者通过其他指针或已有的shared_ptr来创建。这里要注意到make_shared的优势，比如内存分配效率。 然后，需要覆盖常用的成员函数，如use_count()、reset()、get()等，说明它们各自的用途和注意事项。特别是要强调不要轻易使用get()获取裸指针，以免引发悬挂指针的问题。 另外，自定义删除器的部分也很重要，说明为什么需要自定义删除器，以及如何使用它来处理特殊资源，比如文件指针或者malloc分配的内存。这里可能需要举例说明，比如传入一个lambda表达式作为删除器。 循环引用的问题必须提到，因为这是shared_ptr的常见陷阱。要解释循环引用是如何导致内存泄漏的，以及如何通过weak_ptr来打破循环。这部分需要结构清晰，可能用代码示例来演示问题及解决方案。 比较shared_ptr与其他智能指针，比如unique_ptr和weak_ptr的区别，帮助用户理解何时选择哪种指针。要强调所有权模型的不同，unique_ptr的独占性，而shared_ptr的共享性。 还需要注意线程安全的问题，说明shared_ptr的引用计数操作是原子性的，但指向的对象本身并不是线程安全的。这部分可能需要更详细的解释，或者举例说明在多线程环境下如何正确使用。 最后，总结最佳实践，比如优先使用make_shared，避免循环引用，不要混合使用裸指针和智能指针等。同时，可以提到一些常见的错误用法，帮助用户避免陷阱。 在组织内容时，要确保结构清晰，分点阐述，每个部分有明确的标题，便于用户理解。同时，要注意语言的口语化，避免过于技术性的术语，必要时用例子辅助说明。另外，检查是否有遗漏的重要点，比如shared_ptr的性能开销，或者与enable_shared_from_this的关系，如果有必要的话也应该简要提及。 现在，需要将这些内容整合成一个连贯的回答，确保覆盖所有关键点，同时保持逻辑流畅。可能需要先概述，再分章节详细说明，最后总结。注意用户要求用中文回答，所以术语要准确，但表达要自然易懂。</think>以下是对C++中`shared_ptr`智能指针的深度介绍，分模块逐步说明： --- ### 一、基本概念 `shared_ptr`是C++11引入的**共享所有权智能指针**，用于管理动态分配的内存。 - **核心特性**：通过引用计数机制，允许多个`shared_ptr`实例共享同一对象的所有权。 - **核心优势**：自动释放内存，避免内存泄漏；避免悬空指针问题。 --- ### 二、底层机制 #### 1. 引用计数 - 每个`shared_ptr`维护一个**控制块**（包含引用计数、弱引用计数、删除器、分配器等）。 - **规则**： - 构造或拷贝`shared_ptr`时，引用计数`+1`。 - 析构或`reset()`时，引用计数`-1`。 - 引用计数归零时，销毁对象并释放内存。 #### 2. 内存布局 ```cpp 对象内存 ───────────────┐ ↓ 控制块 [引用计数 | 弱引用计数 | 删除器 | 分配器] ``` --- ### 三、构造与初始化 #### 1. 直接构造 ```cpp std::shared_ptr<int> p1(new int(42)); // 不推荐：可能因异常导致内存泄漏 ``` #### 2. 推荐方式：`make_shared` ```cpp auto p2 = std::make_shared<int>(42); // 推荐：单次内存分配（对象+控制块） ``` #### 3. 从其他指针构造 ```cpp std::shared_ptr<int> p3(p1); // 共享所有权，引用计数+1 ``` --- ### 四、核心成员函数 | 函数 | 功能 | 示例 | |--------------------|-----------------------------------|---------------------------| | `use_count()` | 返回当前引用计数 | `p1.use_count()` | | `reset()` | 释放所有权，引用计数-1 | `p1.reset()` | | `get()` | 返回裸指针（谨慎使用！） | `int* raw = p1.get()` | | `swap()` | 交换两个`shared_ptr`内容 | `p1.swap(p2)` | --- ### 五、自定义删除器 用于管理非`new`分配的资源（如文件句柄、`malloc`内存等）： ```cpp // 示例：管理 malloc 分配的内存 std::shared_ptr<void> p4(malloc(100), [](void* ptr) { free(ptr); std::cout << "内存已释放"; }); ``` --- ### 六、循环引用问题 #### 1. 问题场景 ```cpp class Node { public: std::shared_ptr<Node> next; }; auto a = std::make_shared<Node>(); auto b = std::make_shared<Node>(); a->next = b; b->next = a; // 循环引用，引用计数永不为0 → 内存泄漏！ ``` #### 2. 解决方案：`weak_ptr` ```cpp class Node { public: std::weak_ptr<Node> next; // 弱引用不增加计数 }; ``` --- ### 七、与其他智能指针对比 | 类型 | 所有权模型 | 性能开销 | 适用场景 | |---------------|------------------|----------|------------------------| | `unique_ptr` | 独占所有权 | 无 | 单一所有者，资源转移 | | `shared_ptr` | 共享所有权 | 较高 | 多所有者共享资源 | | `weak_ptr` | 无所有权（观察） | 低 | 解决循环引用 | --- ### 八、线程安全性 - **引用计数操作**：原子操作，线程安全。 - **对象访问**：需手动加锁（与裸指针相同）。 --- ### 九、最佳实践 1. **优先使用`make_shared`**：减少内存分配次数，避免异常安全问题。 2. **避免循环引用**：用`weak_ptr`打破循环。 3. **不要混用裸指针**： ```cpp int* raw = new int(10); std::shared_ptr<int> p5(raw); std::shared_ptr<int> p6(raw); // 错误！双重释放！ ``` 4. **谨慎使用`get()`**：避免通过裸指针修改资源或延长生命周期。 --- ### 十、高级用法 #### 1. 别名构造（Alias Constructor） 允许`shared_ptr`指向某个对象的子部分，但共享整个对象的生命周期： ```cpp struct Data { int x, y; }; auto p7 = std::make_shared<Data>(); std::shared_ptr<int> p8(p7, &p7->x); // p8管理p7的x成员，但共享p7的控制块 ``` #### 2. `enable_shared_from_this` 在类的成员函数中安全获取自身的`shared_ptr`： ```cpp class MyClass : public std::enable_shared_from_this<MyClass> { public: void func() { auto self = shared_from_this(); // 正确获取shared_ptr } }; ``` --- ### 总结 `shared_ptr`通过引用计数实现自动内存管理，是C++中解决资源泄漏的核心工具之一。使用时需注意循环引用、线程安全和性能开销，合理结合`weak_ptr`和`unique_ptr`可构建高效、安全的内存管理体系。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值