深入理解C++中的shared_from_this：原理、应用与陷阱

最新推荐文章于 2026-06-22 11:15:11 发布
原创 最新推荐文章于 2026-06-22 11:15:11 发布 · 956 阅读 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
cknow-ai 栖林_

cknow-ai 关注

标签
#c++ #开发语言
分类 编程语言理论
cknow-ai 代码可运行

文章目录

C++ shared_from_this深度解析：安全共享对象所有权的关键机制

std::enable_shared_from_this是C++11引入的关键工具类，用于解决对象在需要安全共享自身所有权时的复杂问题。本文将全面解析其工作原理、正确使用方法和常见陷阱。

shared_from_this的核心目的

问题场景：无效的this指针

class Controller {
public:
    void registerCallback() {
        // 危险：捕获原始指针
        dispatcher.registerHandler([this]() { 
            this->handleEvent(); 
        });
    }
    
    void handleEvent() { /* ... */ }
};

解决方案：安全共享所有权

class Controller : public std::enable_shared_from_this<Controller> {
public:
    void registerCallback() {
        auto self = shared_from_this();
        dispatcher.registerHandler([self]() { 
            self->handleEvent(); 
        });
    }
};

实现原理深度剖析

enable_shared_from_this的内部机制

template<class T>
class enable_shared_from_this {
protected:
    constexpr enable_shared_from_this() noexcept {
        // 构造函数不初始化weak_this
    }
    
    // 拷贝构造函数保持weak_this为空
    enable_shared_from_this(enable_shared_from_this const&) noexcept {}
    
public:
    shared_ptr<T> shared_from_this() {
        if (weak_this.expired()) {
            throw std::bad_weak_ptr();
        }
        return shared_ptr<T>(weak_this);
    }
    
    shared_ptr<T const> shared_from_this() const {
        if (weak_this.expired()) {
            throw std::bad_weak_ptr();
        }
        return shared_ptr<T const>(weak_this);
    }
    
private:
    mutable weak_ptr<T> weak_this;
    
    // shared_ptr构造函数通过此方法初始化weak_this
    template<typename U>
    void _internal_accept_owner(shared_ptr<U> const* sp) const {
        if (weak_this.expired()) {
            weak_this = shared_ptr<T>(*sp, static_cast<T*>(this));
        }
    }
    
    template<class U>
    friend class shared_ptr;
};

关键点：控制块唯一性

enable_shared_from_this的核心是确保同一对象的所有shared_ptr共享同一个控制块。当第一个shared_ptr被创建时（通常通过std::make_shared或std::shared_ptr构造函数），它会初始化内部weak_this，将其绑定到该控制块。

template<typename T>
shared_ptr<T>::shared_ptr(T* ptr) {
    // 创建控制块
    control_block* cb = new control_block(ptr);
    
    // 如果T继承enable_shared_from_this
    if constexpr (std::is_base_of_v<enable_shared_from_this<T>, T>) {
        ptr->_internal_accept_owner(this);
    }
}

构造过程的内存布局
weak_ptr
Controller
+ data members
enable_shared_from_this
- weak_ptr<Controller> weak_this
+_internal_accept_owner()
shared_ptr
- Controller* ptr
- control_block*
control_block
- reference_count : 1
- weak_count : 1
- ptr : Controller*

增强使用模式

工厂方法改进

class SafeObject : public std::enable_shared_from_this<SafeObject> {
public:
    // C++17后使用静态create方法
    template<typename... Args>
    static std::shared_ptr<SafeObject> create(Args&&... args) {
        // 使用std::make_shared确保异常安全
        auto ptr = std::make_shared<SafeObject>(std::forward<Args>(args)...);
        // C++17及以上自动初始化weak_this
        return ptr;
    }
    
private:
    SafeObject() = default; // 必须私有
    SafeObject(const SafeObject&) = delete;
    SafeObject& operator=(const SafeObject&) = delete;
};

跨线程安全使用

class ThreadSafeObject : public std::enable_shared_from_this<ThreadSafeObject> {
public:
    void performAsync() {
        // 获取当前线程的副本
        auto self = shared_from_this();
        
        std::thread([self = std::move(self)] {
            // 安全访问对象状态
            self->process();
        }).detach();
    }
    
    // 使用weak_ptr中断长时间操作
    void interruptibleWork() {
        std::weak_ptr<ThreadSafeObject> weak_self = weak_from_this();
        
        worker_thread = std::thread([weak_self] {
            while (auto self = weak_self.lock()) {
                if (self->shouldStop) break;
                self->doWork();
            }
        });
    }
};

正确使用模式

基本使用规范

class SafeObject : public std::enable_shared_from_this<SafeObject> {
public:
    void start() {
        // 必须通过shared_ptr调用
        auto ptr = shared_from_this();
        // ...
    }
    
    static std::shared_ptr<SafeObject> create() {
        // 工厂方法确保对象由shared_ptr管理
        return std::shared_ptr<SafeObject>(new SafeObject());
    }
    
private:
    SafeObject() {} // 私有构造函数
};

异步操作中的使用

class AsyncWorker : public std::enable_shared_from_this<AsyncWorker> {
public:
    void performTask() {
        auto self = shared_from_this();
        
        async_task([self] {
            // 安全访问对象成员
            self->processResult();
        });
    }
};

常见陷阱与解决方案

陷阱1：构造函数中调用shared_from_this

class BadExample : public std::enable_shared_from_this<BadExample> {
public:
    BadExample() {
        // 错误：weak_this尚未初始化
        auto ptr = shared_from_this(); // 抛出std::bad_weak_ptr
    }
};

解决方案：

  1. 使用工厂方法确保对象完全构造
  2. 延迟初始化回调
class GoodExample : public std::enable_shared_from_this<GoodExample> {
public:
    void init() {
        // 安全：在构造后调用
        auto self = shared_from_this();
        setupCallback(self);
    }
};

陷阱2：栈对象使用shared_from_this

void dangerousCall() {
    StackObject obj;
    obj.doSomething(); // 内部调用shared_from_this()会崩溃
}

解决方案：

  1. 始终使用shared_ptr管理对象生命周期
  2. 使用工厂方法禁止栈对象创建
class SafeDesign {
public:
    static std::shared_ptr<SafeDesign> create() {
        return std::shared_ptr<SafeDesign>(new SafeDesign());
    }
    
private:
    SafeDesign() {} // 私有构造函数
};

陷阱3：多继承问题

class BaseA : public std::enable_shared_from_this<BaseA> {};
class BaseB : public std::enable_shared_from_this<BaseB> {};

class Derived : public BaseA, public BaseB {
    // 调用shared_from_this()会歧义
};

解决方案1： 虚继承

class Base : public std::enable_shared_from_this<Base> {};
class Derived : public virtual Base {};

解决方案2： 自定义转换

class Derived : public BaseA, public BaseB {
public:
    std::shared_ptr<Derived> derived_from_this() {
        return std::static_pointer_cast<Derived>(BaseA::shared_from_this());
    }
};

陷阱4：循环引用未被打破

class Node : public enable_shared_from_this<Node> {
public:
    void addChild(shared_ptr<Node> child) {
        children.push_back(child);
        child->parent = shared_from_this(); // 循环引用!
    }
    
private:
    vector<shared_ptr<Node>> children;
    shared_ptr<Node> parent; // 应改为weak_ptr
};

解决方案：

  1. 将parent改为weak_ptr
  2. 使用weak_ptr打破循环
weak_ptr<Node> parent; // 正确

陷阱5：线程竞争条件

class RaceCondition : public enable_shared_from_this<RaceCondition> {
public:
    void unsafeCall() {
        // 多线程下可能同时创建多个shared_ptr
        auto self = shared_from_this();
        // ...
    }
};

解决方案：

  1. 使用互斥锁保护
  2. 提前获取并存储shared_ptr
class ThreadSafe {
    shared_ptr<ThreadSafe> safe_ref;
public:
    ThreadSafe() : safe_ref(shared_from_this()) {}
    
    void safeMethod() {
        auto self = safe_ref; // 线程安全访问
    }
};

高级应用场景

实现观察者模式

class Observable : public std::enable_shared_from_this<Observable> {
public:
    void addObserver(std::weak_ptr<Observer> obs) {
        observers.push_back(obs);
    }
    
    void notifyAll() {
        auto self = shared_from_this();
        for (auto& weak_obs : observers) {
            if (auto obs = weak_obs.lock()) {
                obs->update(self);
            }
        }
    }
};

链式调用支持

class Chainable : public std::enable_shared_from_this<Chainable> {
public:
    std::shared_ptr<Chainable> nextStep() {
        // 返回新的共享指针
        return std::make_shared<NextStep>(shared_from_this());
    }
};

性能与内存考量

开销分析

操作开销类型开销大小说明
对象大小内存sizeof(weak_ptr)每个对象增加weak_ptr大小
shared_from_this调用CPU2原子操作weak_ptr::lock()包含引用计数操作
构造开销CPU额外1次赋值shared_ptr构造函数初始化weak_this
析构开销CPU无额外开销与普通shared_ptr相同

性能优化技巧

  1. 缓存shared_ptr：对于高频访问对象

    class CachedRef {
    shared_ptr<CachedRef> cached_ref;
public:
    CachedRef() : cached_ref(shared_from_this()) {}
    
    void fastMethod() {
        // 直接使用cached_ref，避免lock开销
        cached_ref->doWork();
    }
};

  2. 避免深层嵌套：减少shared_ptr传递层级

  3. 使用weak_ptr存储长期引用

  4. 对象池模式：重用对象减少分配开销

class ObjectPool {
    static vector<shared_ptr<MyObject>> pool;
public:
    static shared_ptr<MyObject> acquire() {
        if (!pool.empty()) {
            auto obj = pool.back();
            pool.pop_back();
            return obj;
        }
        return make_shared<MyObject>();
    }
    
    static void release(shared_ptr<MyObject> obj) {
        obj->reset();
        pool.push_back(obj);
    }
};

内存布局优化

使用std::make_shared合并分配：

auto obj = std::make_shared<MyObject>(); // 单次分配

vs

auto obj = std::shared_ptr<MyObject>(new MyObject()); // 两次分配

替代方案

原始指针+显式生命周期管理

class RawPointerHandler {
public:
    ~RawPointerHandler() {
        dispatcher.unregisterAll(this);
    }
};

唯一所有权模式

class OwnedObject {
public:
    explicit OwnedObject(std::shared_ptr<Controller> owner)
        : owner_(std::move(owner)) {}
private:
    std::shared_ptr<Controller> owner_;
};

调试与检测工具

ASAN地址检测器

clang++ -fsanitize=address -g your_program.cpp

weak_ptr有效性检查

void safeCall() {
    auto self = weak_from_this(); // C++17引入
    if (!self.expired()) {
        auto ptr = self.lock();
        ptr->doWork();
    }
}

结论与最佳实践

  1. 使用场景：当对象需要将自己的所有权传递给其他组件时
  2. 构造要求：对象必须由shared_ptr管理
  3. 初始化时机：避免在构造函数中调用
  4. 继承规范：public继承enable_shared_from_this
  5. 多线程安全：shared_from_this本身是线程安全的
// 推荐的安全使用模式
class SafeObject : public std::enable_shared_from_this<SafeObject> {
public:
    static std::shared_ptr<SafeObject> create() {
        auto ptr = std::shared_ptr<SafeObject>(new SafeObject());
        // C++17后自动初始化weak_this
        return ptr;
    }
    
    void safeMethod() {
        auto self = shared_from_this();
        // 使用self而非this
    }
    
private:
    SafeObject() = default; // 强制使用工厂方法
};
点赞 点赞 29
评论 0
书签 书签 20
深入理解Modern C++智能指针std::shared_ptr
qls315的博客
06-02 2649
现代C++为了解决内存泄露以及资源回收等问题，引入了智能指针的概念。在日常的C++实践中也是高频使用。本文是在实践过程中，对现代C++中的智能指针进行的一个稍微全面的总结。本文主要讲解std::shared_ptr的相关内容。std::shared_ptr也即智能指针，采用RAII手法，是一个模版对象。std::shared_ptr表示某一个资源的共享所有权。可以通过如下两种方式创建std::shared_ptr对象 2 实现原理 此处以如下代码为例，讲解std::shared_ptr的实现原理
深入理解 shared_ptr 与 enable_shared_from_this
h a 6 6 6 c k 为 你解决复杂难题！
06-01 297
是一个模板类，用于协助派生类安全地生成指向自身的shared_ptr。这些函数返回一个指向当前对象的shared_ptr，前提是该对象已经被至少一个shared_ptr所管理。特性描述shared_ptr共享所有权的智能指针，自动管理对象生命周期协助类，提供方法优势安全地从对象内部获取shared_ptr，避免重复管理限制必须已被shared_ptr管理；不能在构造函数中调用应用场景异步回调、观察者模式、资源管理等。
C++之shared_from_this用法以及类自引用this指针陷阱
weixin_44834554的博客
07-09 2496
C++之shared_from_this用法以及类自引用this指针陷阱
(C++) 内类生成智能指针shared_from_this介绍
cuber-lotus的博客
04-24 1645
unique_ptrshared_ptrweak_ptr都是内存管理中的非常重要的一部分动态内存管理 - cppreference.com。其中shared_ptr在实际应用中具有非常广泛的应用。而拷贝操作也是非常常见和重要的操作。在类外可以直接使用默认的拷贝构造和拷贝赋值，而类内呢？显然这两种默认的拷贝操作均不适用。本文就是讲解使用来处理该问题。
C++：智能指针(5)——enable_shared_from_this工作原理、源码分析
weixin_41442027的博客
04-19 3187
文章目录enable_shared_from_this的作用用法问题1分析问题2分析enable_shared_from_this源码分析、工作原理enable_shared_from_this与shared_ptr的耦合关系总结 enable_shared_from_this的作用 在C++：智能指针(3)——无法通过原指针增加共享指针shared_ptr的计数，enable_shared_fr...
shared_from_this用法，以及shared_ptr陷阱
凌云天空的博客
07-03 7615
c++11中的智能指针源于boost，所以也将 类enable_shared_from_this 和 及其成员函数shared_from_this()也给收编了。 通过模板方式继承enable_shared_from_this<T> 然后调用shared_from_this()函数返回对象T的shared_ptr指针，非常方便。使用时需要引用头文件 ：#include <memory> 用例： #include <stdio.h> ...
shared_from_this()
飞信天下专栏
08-10 3275
shared_from_this()使用场合
【C++ 实用教程】深入理解C++构造函数：构造完成后才能安全执行的关键行为与最佳实践
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
10-22 4206
C++语言以其强大的功能和灵活性著称，但这也意味着开发者需要对其复杂性有深入的理解。特别是在对象的构造过程中，有一些行为只有在构造函数完成后才能安全地使用。不了解这些限制可能会导致程序出现未定义行为、崩溃甚至安全漏洞。
Boost.Asio实战：如何避免shared_from_this导致的崩溃（附Chat服务改造案例）
weixin_29007809的博客
02-21 317
本文深入探讨了在Boost.Asio网络编程中，因误用std::enable_shared_from_this而导致的std::bad_weak_ptr崩溃问题。通过分析常见陷阱（如在构造函数中过早调用shared_from_this）并结合一个完整的聊天服务器改造案例，提供了使用weak_ptr、工厂模式及正确lambda捕获等安全实践方案，帮助开发者构建稳定、高性能的C++网络服务。
【性能与安全并重】：详解C++11中lambda如何安全捕获this指针
PixelFlow的博客
11-10 430
掌握C++11 lambda的捕获this技巧，解决成员函数中lambda生命周期与对象安全访问难题。适用于回调函数、异步编程等场景，通过值捕获或智能指针确保对象存活，避免悬空引用。性能与安全性兼备，值得收藏。
【高级C++陷阱揭秘】：当lambda捕获this时，对象销毁顺序决定程序生死
FastCompile的博客
11-18 351
掌握lambda捕获this的生命周期难题，避免对象销毁引发的程序崩溃。详解C++中lambda与成员函数结合的陷阱场景，揭示正确管理对象生命周期的核心方法，提升代码稳定性，值得收藏。
《深入理解 C++ 智能指针：unique_ptr、shared_ptr 与 weak_ptr 全解析》
郭小明的专栏
03-20 130
代码语言：javascriptAI代码解释cpp复制编辑structFileCloser {代码语言：javascriptAI代码解释cpp复制编辑classWeapon {public:private:public:智能指针是现代 C++ 编程中不可或缺的工具。掌握其用法不仅可以避免内存泄漏，更是实现高质量代码的基础。开发者应根据场景选择最合适的指针类型，避免过度使用 shared_ptr，在设计阶段就思考生命周期与所有权关系。
从内存泄漏案例学习：shared_ptr循环引用的5种常见场景及weak_ptr修复方法
weixin_28025327的博客
03-01 268
本文深入剖析了C++中shared_ptr智能指针因循环引用导致内存泄漏的五大典型场景，包括双向关联、缓存模式、Lambda捕获、复杂数据结构及自定义删除器误用。针对每种场景，文章详细阐述了其成因，并提供了使用weak_ptr进行修复的标准方案与代码示例，帮助开发者从根本上预防和解决内存泄漏问题，提升代码健壮性。
揭秘weak_ptr的lock机制：为什么90%的开发者都忽略了这一步？
CodeTrick的博客
11-10 622
掌握C++ weak_ptr的lock方法，有效避免资源泄漏与悬空指针。详解其在多线程环境和观察者模式中的典型应用，揭示加锁检查的必要性及性能优势，理解智能指针协作机制的关键一步，值得收藏。
深入解析C/C++编译器错误：从指针到模板的编程核心原理
最新发布
weixin_30787531的博客
06-22 287
在C/C++编程中，编译器错误信息是理解语言底层机制的重要窗口。类型系统和内存模型构成了程序安全性的基础，编译器通过严格的类型检查确保操作符与操作数的匹配，防止未定义行为。指针作为直接操作内存的工具，其地址合法性、类型匹配和边界检查是避免程序崩溃的关键。模板作为泛型编程的核心，通过编译时多态实现代码复用，但参数推导和实例化规则需要精确掌握。这些原理在高性能计算和嵌入式系统等场景中尤为重要，能帮助开发者写出更健壮的代码。本文以C1833、C1854等典型错误为例，系统剖析从指针操作到模板实例化的核心思想，提升
HIP协作组编程终极指南：从硬件原理到高性能实践
gitblog_01119的博客
06-12 676
在异构计算领域，HIP（Heterogeneous-Compute Interface for Portability）作为AMD ROCm平台的核心编程模型，为开发者提供了跨平台的GPU编程能力。其中，协作组（Cooperative Groups）功能是HIP编程模型中最为强大的线程组织机制之一，它打破了传统线程块的限制，为复杂并行算法提供了更灵活的线程协作方式。本文将深入探索HIP协作组的核心
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

栖林_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值