文章目录
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);
}
}
构造过程的内存布局
增强使用模式
工厂方法改进
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
}
};
解决方案：
- 使用工厂方法确保对象完全构造
- 延迟初始化回调
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()会崩溃
}
解决方案：
- 始终使用shared_ptr管理对象生命周期
- 使用工厂方法禁止栈对象创建
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
};
解决方案：
- 将parent改为weak_ptr
- 使用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();
// ...
}
};
解决方案：
- 使用互斥锁保护
- 提前获取并存储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调用 | CPU | 2原子操作 | weak_ptr::lock()包含引用计数操作 |
| 构造开销 | CPU | 额外1次赋值 | shared_ptr构造函数初始化weak_this |
| 析构开销 | CPU | 无额外开销 | 与普通shared_ptr相同 |
性能优化技巧
-
缓存shared_ptr：对于高频访问对象
class CachedRef { shared_ptr<CachedRef> cached_ref; public: CachedRef() : cached_ref(shared_from_this()) {} void fastMethod() { // 直接使用cached_ref，避免lock开销 cached_ref->doWork(); } }; -
避免深层嵌套：减少shared_ptr传递层级
-
使用weak_ptr存储长期引用
-
对象池模式：重用对象减少分配开销
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();
}
}
结论与最佳实践
- 使用场景：当对象需要将自己的所有权传递给其他组件时
- 构造要求：对象必须由shared_ptr管理
- 初始化时机：避免在构造函数中调用
- 继承规范：public继承enable_shared_from_this
- 多线程安全：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; // 强制使用工厂方法
};
扫一扫
45
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
