std::enable_shared_from_this 简析

文章介绍了std::enable_shared_from_this的作用,如何通过std::shared_ptr构造时自动指向自身,以及为何选择这种方式而非std::shared_ptr直接指向自己以避免循环引用的问题。
摘要由CSDN通过智能技术生成

序言

最近在看C++很少用到的知识,学到这遇到和大家一样的问题,std::enable_shared_from_this到底是怎么指向自己的?看别人说的云里雾里的,我来简单通俗解释下。
.

为什么要用std::enable_shared_from_this

看个例子

void main()
{
	AA *a = new AA;
	std::shared_ptr< AA > ptr1(a);
	std::shared_ptr< AA > ptr2(a);
	std::cout << ptr1.use_count() << " " << ptr2.use_count() << std::endl;	// 1 1
	return 0;
}

a是个裸指针,给ptr1和ptr2两个智能指针赋值时,智能指针是不知道裸指针被别的指向过,所以这两个的use_count()都会是1。

a被释放了两次!所以,为了避免这个情况,就可以用std::enable_shared_from_this

.

memory部分源码

这是我电脑上std::enable_shared_from_this 的版本,各自的版本或许不同,但是大致相信是相同的。

template <class _Ty>
class enable_shared_from_this { // provide member functions that create shared_ptr to this
public:
    using _Esft_type = enable_shared_from_this;
    
    _NODISCARD shared_ptr<_Ty> shared_from_this() {
        return shared_ptr<_Ty>(_Wptr);
    }
    
    _NODISCARD shared_ptr<const _Ty> shared_from_this() const {
        return shared_ptr<const _Ty>(_Wptr);
    }
    
    _NODISCARD weak_ptr<_Ty> weak_from_this() noexcept {
        return _Wptr;
    }
    
    _NODISCARD weak_ptr<const _Ty> weak_from_this() const noexcept {
        return _Wptr;
    }
    
protected:
    constexpr enable_shared_from_this() noexcept : _Wptr() {}
    
    enable_shared_from_this(const enable_shared_from_this&) noexcept : _Wptr() {
        // construct (must value-initialize _Wptr)
    }
    
    enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept { // assign (must not change _Wptr)
        return *this;
    }
    
    ~enable_shared_from_this() = default;
    
private:
    template <class _Yty>
    friend class shared_ptr;
    
    mutable weak_ptr<_Ty> _Wptr;
};

我想大家看到这里时都很迷惑,_Wptr不是个弱类型智能指针吗?它也没有指向任何东西呀。

我也陷入了和大家一样的境地,但是这时,我将_Wptr搜索看看,发现上边std::shared_ptr的类里用到了!

	template <class _Ux,
        enable_if_t<conjunction_v<conditional_t<is_array_v<_Ty>, _Can_array_delete<_Ux>, _Can_scalar_delete<_Ux>>,
                        _SP_convertible<_Ux, _Ty>>,
            int> = 0>
	explicit shared_ptr(_Ux* _Px) { // construct shared_ptr object that owns _Px
        if constexpr (is_array_v<_Ty>) {
            _Setpd(_Px, default_delete<_Ux[]>{});
        } else {
            _Temporary_owner<_Ux> _Owner(_Px);
            _Set_ptr_rep_and_enable_shared(_Owner._Ptr, new _Ref_count<_Ux>(_Owner._Ptr));
            _Owner._Ptr = nullptr;
        }
    }

	...

	template <class _Ux>
    void _Set_ptr_rep_and_enable_shared(_Ux* const _Px, _Ref_count_base* const _Rx) noexcept { // take ownership of _Px
        this->_Ptr = _Px;
        this->_Rep = _Rx;
        if constexpr (conjunction_v<negation<is_array<_Ty>>, negation<is_volatile<_Ux>>, _Can_enable_shared<_Ux>>) {
            if (_Px && _Px->_Wptr.expired()) {
                _Px->_Wptr = shared_ptr<remove_cv_t<_Ux>>(*this, const_cast<remove_cv_t<_Ux>*>(_Px));
            }
        }
    }

    void _Set_ptr_rep_and_enable_shared(nullptr_t, _Ref_count_base* const _Rx) noexcept { // take ownership of nullptr
        this->_Ptr = nullptr;
        this->_Rep = _Rx;
    }

看上边_Set_ptr_rep_and_enable_shared这个是关键,这个函数里,_Can_enable_shared会判断是否是继承std::enable_shared_from_this的,是则可直接调用其的私有成员_Wptr

然后将传进来的这个实例,让自己的成员_Wptr指向自己这个实例,完成了指向自己。

enable_shared_from_this拥有代码friend class shared_ptr;,会允许shared_ptr任意调用。

说到这想必大家都差不多明白了

这就是通过std::shared_ptr< AA > (a);指向的第一个实例,也自己指向了自己。

要注意的是,因为if的第二个判断_Px->_Wptr.expired(),所以会只有第一次实例未被智能指针指向时可以使用,第二次就会正常如一个std::shared_ptr给另一个std::shared_ptr赋值的效果,计数器正常递增。
.

示例

给个例子会更容易接受

class AA : public std::enabled_shared_from_this< AA >
{
public:
	...
	std::shared_ptr< AA > GetThis()
	{
		return shared_from_this();		// 也可以用weak_from_this()弱类型的
	}
	...
}

...
	AA *a = new AA;
	std::shared_ptr< AA > ptr1(a);	// shared_ptr新建的同时,调用了上边源码写出来的shared_ptr构造,new AA的成员_Wptr
									// 指向new AA,该实例的_Wptr完成闭环指向
	std::shared_ptr< AA > ptr2 = a->GetThis();	//获取的是实例的this智能指针给第二个智能指针
	std::cout << ptr1.use_count() << " " << ptr2.use_count() << std::endl;	// 2 2
...

.

后续可能性疑问

有些人虽然看完了,知道这个怎么用,原理是什么,可是还是有很多疑问,可以看看下面,下面是我了解之后仍然会产生的疑问,和自我解答:

为什么不用std::shared_ptr而是用的std::wear_ptr指向自己?

因为如果用std::shared_ptr指向自己的话,就会导致被管理对象持有对象自身,这会导致什么?

1.释放自身
2.释放成员std::shared_ptr
3.std::shared_ptr释放持有的自身
4.释放自身
5.释放成员std::shared_ptr
6.std::shared_ptr释放持有的自身

懂了吧?

那么又可能有疑问,那不指向自己,指向新的实例不就好了?

std::shared_ptr不指向自己,指向新的实例

要实现这个疑问,就有些问题,你怎么new新的呢?
首先排除在构造里new,这会导致重复构造,构造循环。

其他的诸如放函数里,放静态函数里,或者说自己可以规范一点不出现开头的问题。
都可以。

只是,如果需要避免这种情况,std::enabled_shared_from_this就是目前知道最简便,性能开销最少,抽象最少的方法了。

(截止参考自C++11及之前的版本)

  • 21
    点赞
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
`std::enable_shared_from_this` 是一个模板类,其目的是为了解决在一个对象中保存 shared_ptr 的问题。它是 C++11 引入的一个特性。 在使用 `std::shared_ptr` 时,我们往往需要在对象中保存一个 `std::shared_ptr` 的副本,这样才能确保对象在使用完毕后不会被提前销毁。但是这种方式会导致一些问题,比如我们无法防止用户直接使用裸指针来操作对象,从而导致对象被提前销毁等问题。 这时候,我们可以使用 `std::enable_shared_from_this` 来解决这些问题。具体而言,我们需要继承 `std::enable_shared_from_this`,然后在对象中使用 `shared_from_this()` 方法来获取一个指向当前对象的 `std::shared_ptr`。 下面是一个示例代码: ```c++ #include <iostream> #include <memory> class MyClass : public std::enable_shared_from_this<MyClass> { public: std::shared_ptr<MyClass> get_shared_ptr() { return shared_from_this(); } }; int main() { std::shared_ptr<MyClass> p(new MyClass); std::shared_ptr<MyClass> q = p->get_shared_ptr(); std::cout << "p.use_count() = " << p.use_count() << std::endl; std::cout << "q.use_count() = " << q.use_count() << std::endl; return 0; } ``` 在这个示例中,我们定义了一个名为 `MyClass` 的类,并且继承了 `std::enable_shared_from_this`。然后,我们在类中定义了一个名为 `get_shared_ptr()` 的方法,该方法使用了 `shared_from_this()` 方法来获取一个指向当前对象的 `std::shared_ptr`。在 `main()` 函数中,我们先创建了一个 `std::shared_ptr` 对象 `p`,然后通过 `p` 调用 `get_shared_ptr()` 方法获取了一个指向同一个对象的 `std::shared_ptr` 对象 `q`。最后,我们输出了 `p` 和 `q` 的引用计数,可以看到它们的引用计数都是 2。 需要注意的是,在使用 `std::enable_shared_from_this` 时,我们需要确保对象已经被一个 `std::shared_ptr` 管理,否则使用 `shared_from_this()` 方法会导致程序崩溃。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

溪渣渣_梁世华

打赏?我甚至没有任何收费的章节

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

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

打赏作者

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

抵扣说明:

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

余额充值