智能指针梳理

RAII

RAII（Resource Acquisition Is Initialization）资源获取即初始化。

它是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。至此我们可以看到实际上就是把一份资源的责任托管给了一个对象。

这种做法有两大好处：

1. 不需要显式释放资源。析构时自动调用。

2. 采用这种方式，对象所需的资源在其生命期内始终保持有效。

智能指针是RAII思想的一种具像

c++里面的四个智能指针: auto_ptr, shared_ptr, weak_ptr, unique_ptr 其中后三个是c++11支持，并且第一个已经被c++11弃用

一、shared_ptr

std::shared_ptr也即智能指针，采用RAII手法，是一个模版对象。std::shared_ptr表示某一个资源的共享所有权。

线程安全

shared_ptr指针类有两个成员变量，一个是指向变量的指针；一个是资源被引用的次数，引用次数加减操作内部自动加锁解锁，是线程安全的。

指针和引用计数是线程安全的，但指针所指对象中的操作就需要自己做控制，并不是线程安全的。因为shared_ptr 有两个数据成员（指向被管理对象的指针，和指向控制块的指针），读写操作不能原子化。

线程安全case1

多线程读写shared_ptr所指向的同一个对象，不管是相同的shared_ptr对象，还是不同的shared_ptr对象，也需要加锁保护

shared_ptr<long> global_instance = make_shared<long>(0);
std::mutex g_i_mutex;
 
void thread_fcn()
{
    //std::lock_guard lock(g_i_mutex);
 
    //shared_ptr local = global_instance;
 
    for(int i = 0; i < 100000000; i++)
    {
        *global_instance = *global_instance + 1;
        //*local = *local + 1;
    }
}
 
int main(int argc, char** argv)
{
    thread thread1(thread_fcn);
    thread thread2(thread_fcn);
 
    thread1.join();
    thread2.join();
 
    cout << "*global_instance is " << *global_instance << endl;
 
    return 0;
}

在线程函数thread_fcn的for循环中，2个线程同时对*global_instance进行加1的操作。这就是典型的非线程安全的场景，最后的结果是未定的，运行结果如下：

*global_instance is 197240539

如果使用的是每个线程的局部shared_ptr对象local，因为这些local指向相同的对象，因此结果也是未定的，运行结果如下：

*global_instance is 160285803

因此，这种情况下必须加锁，将thread_fcn中的第一行代码的注释去掉之后，不管是使用global_instance，还是使用local，得到的结果都是：

*global_instance is 200000000

线程安全case 2

• 一个 shared_ptr 对象实体可被多个线程同时读取（文档例1）；

• 两个 shared_ptr 对象实体可以被两个线程同时写入（例2），“析构”算写操作；

• 如果要从多个线程读写同一个 shared_ptr 对象，那么需要加锁（例3~5）。

请注意，以上是 shared_ptr 对象本身的线程安全级别，不是它管理的对象的线程安全级别。

shared_ptr g(new Foo); // 线程之间共享的 shared_ptr

shared_ptr x; // 线程 A 的局部变量

shared_ptr n(new Foo); // 线程 B 的局部变量

C++ shared_ptr的线程安全问题_c++ shared_ptr 线程安全-CSDN博客

https://www.cnblogs.com/gqtcgq/p/7492772.html

shared_ptr的API使用

可以通过如下两种方式创建std::shared_ptr对象

auto p = std::shared_ptr(new T);
auto p = std::make_shared(T{});

shared_ptr的拷贝构造函数会增加引用计数，而移动构造函数不会增加引用计数。

别名构造函数

template shared_ptr (const shared_ptr& x, element_type* p) noexcept;  除了存储的指针是p。该对象不拥有 p，也不会管理其存储。相反，它共同拥有 x 的托管对象并算作 x 的一种额外使用。它还将在发布时删除 x 的指针（而不是 p）。它可以用来指向已经被管理的对象的成员。

int main() 
{
    // 创建一个unique_ptr实例
    unique_ptr<int> pInt(new int(5));
    unique_ptr<int> pInt2(pInt);    // 报错
    unique_ptr<int> pInt3 = pInt;   // 报错
}
 
int main() 
{
    unique_ptr<int> pInt(new int(5));
    unique_ptr<int> pInt2 = std::move(pInt);    // 转移所有权
    //cout << *pInt << endl; // 出错，pInt为空
    cout << *pInt2 << endl;
    unique_ptr<int> pInt3(std::move(pInt2));
}
 
 
unique_ptr<int> clone(int p)
{
    unique_ptr<int> pInt(new int(p));
    return pInt;    // 返回unique_ptr
}
 
int main() {
    int p = 5;
    unique_ptr<int> ret = clone(p);
    cout << *ret << endl;
}