C++11 智能指针之shared_from_this

shared_ptr 作用：

• C++中采用new和delete来申请和释放内存，如果管理不当，很容易出现内存泄露；
• std::shared_ptr,std::unique_ptr,std::weak_ptr，三种智能指针类，可以自动管理内存

使用示例：

智能指针对象和一般的指针用法几乎完全相同

#include <iostream>
#include  <memory> // 需要包含这个头文件

int main()
{
	std::shared_ptr<int> p1 = std::make_shared<int>();
	*p1 = 78;
	std::cout << "p1 = " << *p1 << std::endl; // 输出78
	return 0;
}

原理：

• 只能指针包含两个成员变量：引用计数指针，管理对象的指针
• 当引用计数为0时，释放内存，否则不处理
• 重载和使用相关的所有操作符等，比如赋值运算符会将引用计数+1
• 重载*操作符，可获得管理对象的指针

demo：

#include<bits/stdc++.h>
using namespace std;

template <typename MyStruct>
class SharedPtr {
public:
    SharedPtr(MyStruct* a) 
    : a_(a) {
        cout << "SharedPtr()" << endl;
        b_ = new atomic<int>(1);
    }
    ~SharedPtr() {
        cout << "~SharedPtr()" << endl;
        if (!(--*b_)) {
            cout << "delete real ptr" << endl;
            ToStirng();
            delete a_;
            a_ = NULL;
            delete b_;
            b_ = NULL;
        }
    }
    SharedPtr<MyStruct>& operator =(const SharedPtr<MyStruct>& another) {
        cout << "operator =" << endl;
        if (this != &another) {
           if (this->a_) {
                if (!(--*this->b_)) {
                    cout << "delete real ptr" << endl;
                    ToStirng();
                    delete this->a_;
                    this->a_ = NULL;
                    delete this->b_;
                    this->b_ = NULL;
                }
           }
           if (another.a_) {
                 this->a_ = another.a_;
                 this->b_ = another.b_;
                 *this->b_ ++ ;
           }
        }
        return *this;
    }

MyStruct operator *() {
    cout << "operator *" << endl;
    return *a_;
}

private:
    void ToStirng() {
        cout << *a_ << endl;
    }
    MyStruct* a_;
    atomic<int>* b_;  
};

int main() {
    string* my_struct = new string("str1");
    SharedPtr<string> a(my_struct);
    string* my_struct2 = new string("str2");
    SharedPtr<string> b(my_struct2);
    b = a;
    cout << *b << endl;
    return 0;
}

cpp reference 中概述:

C++11开始时支持 enable_shared_from_this，它一个模板类，定义在头文件<memory>，其原型为： template< class T > class enable_shared_from_this; 。std::enable_shared_from_this 能让其一个对象（假设其名为 t ，且已被一个 std::shared_ptr 对象 pt 管理）安全地生成其他额外的 std::shared_ptr 实例（假设名为 pt1, pt2, … ） ，它们与 pt 共享对象 t 的所有权。若一个类 T 继承 std::enable_shared_from_this ，则会为该类 T 提供成员函数： shared_from_this 。 当 T 类型对象 t 被一个为名为 pt 的 std::shared_ptr 类对象管理时，调用 T::shared_from_this 成员函数，将会返回一个新的 std::shared_ptr 对象，它与 pt 共享 t 的所有权。

shared_from_this()实现原理

总结一下shared_from_this()使用场景

• 当类被share_ptr管理
• 调用类的成员函数时
• 需要把当前对象指针作为参数传给其他函数时
• 需要传递一个指向自身的share_ptr

使用前提：

• 继承enable_shared_from_this

使用示例：

struct EnableSharedPtr : enable_shared_from_this<EnableSharedPtr> {
public:
    shared_ptr<EnableSharedPtr> getptr() {
        return shared_from_this();
    }
    ~EnableSharedPtr() { 
        cout << "~EnableSharedPtr() called" << endl; 
    }
};

int main()
{
    shared_ptr<EnableSharedPtr> gp1(new EnableSharedPtr());
    // 注意不能使用raw 指针
    // EnableSharedPtr* gp1 = new EnableSharedPtr();
    shared_ptr<EnableSharedPtr> gp2 = gp1->getptr();
    cout << "gp1.use_count() = " << gp1.use_count() << endl;
    cout << "gp2.use_count() = " << gp2.use_count() << endl;
    return 0;
}

原理

boost精简代码如下：

class enable_shared_from_this
{
    shared_ptr<const _Tp> shared_from_this() const
    {
        return shared_ptr<const _Tp>(this->_M_weak_this);
    }

    mutable weak_ptr<_Tp> _M_weak_this;
};

• 可理解为enable_shared_from_this包含引用计数指针
• 所有与该对象相关的操作都与该引用计数指针相关
• 因为类内部，如果不包含引用计数指针，不能直接生成shared_ptr

注意：

• 只有智能指针管理的对象，才能使用shared_from_this，因为普通对象不包含引用计数指针
• 构造函数内不能使用shared_from_this()，因为智能指针在构造函数后生成，构造函数时不存在引用计数指针。