C++11之后出現(xiàn)了 shared_ptr 和 unique_ptr，這兩個類都是基于RAII技術(shù)進(jìn)行設(shè)計(jì)的

RAII

????????利用對象生命周期來控制程序資源（如內(nèi)存，文件句柄，網(wǎng)絡(luò)連接，互斥量等資源）的技術(shù)，具體地說，就是通過構(gòu)造函數(shù)獲得資源，通過析構(gòu)函數(shù)釋放資源。

RAII的思想需要考慮到一個事實(shí)：一個資源不能被釋放兩次，那么此時如果有兩個對象管理同一塊資源，這兩個對象前后銷毀，分別調(diào)用析構(gòu)函數(shù)，將導(dǎo)致運(yùn)行錯誤。

針對上述可能出現(xiàn)的錯誤，C++11中有兩種方案

方案一

unique_ptr 不允許拷貝或賦值，設(shè)計(jì)時直接禁用拷貝構(gòu)造函數(shù)和賦值重載函數(shù)

unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;

方案二

在有一些場景中，兩個智能指針需要管理同一個資源，此時是通過 shared_ptr 進(jìn)行實(shí)現(xiàn)的

shared_ptr 通過引用計(jì)數(shù)確定管理一塊資源的實(shí)例化對象的個數(shù)。

引用計(jì)數(shù)達(dá)到的效果：只讓最后一個管理資源的對象執(zhí)行釋放資源的邏輯

但是，引用計(jì)數(shù)帶來了很多問題，下面將把這些問題提出，并給出shared_ptr解決問題的設(shè)計(jì)方案

引用計(jì)數(shù)的設(shè)計(jì)方案思考

首先，引用計(jì)數(shù)不能設(shè)計(jì)成 shared_ptr 的局部私有成員。如果設(shè)計(jì)成私有成員，拷貝構(gòu)造和賦值重載改變的時，無法保證舊對象和新對象同時改變引用計(jì)數(shù)。

其次，引用計(jì)數(shù)不能設(shè)計(jì)成全局變量或者靜態(tài)bianilin，否則在如下場景中 sp1的_pcount和sp2的_pcount的有著相同地址，這是錯誤的

class A{
public:A(int a1):_a1(a1){}int _a1 = 1;
};int main(){shared_ptr<A> sp1(new A(1));shared_ptr<A> sp2(new A(2));
}

最后，應(yīng)該設(shè)計(jì)一個整型指針變量作為引用計(jì)數(shù)的變量，而且應(yīng)該在堆上開辟一塊空間，不然這個變量的初始化很麻煩

引用計(jì)數(shù)帶來的問題

記 shared_ptr 中引用計(jì)數(shù)這個成員變量的名稱為 _pcount, 即 int* _pcount;

問題一

在多線程場景下，_pcount 作為一個臨界資源，應(yīng)該如何考慮其線程安全問題？

_pcount作為臨界資源的場景：

void func(std::shared_ptr<list<int>> sp, int n){for (int i = 0; i < n; i++){std::shared_ptr<list<int>> copy(sp);sp->emplace_back(i);}
}int main(){std::shared_ptr<list<int>> sp1(new list<int>);thread t1(func, sp1, 1000000);thread t2(func, sp1, 2000000);t1.join();t2.join();
}

從如上代碼可以看到，t1 和 t2 這兩個線程同時進(jìn)行同時對 sp 進(jìn)行尾插，

問題二

在調(diào)用賦值重載時，應(yīng)該如何改變舊對象和新對象中的引用計(jì)數(shù)?(注意需考慮到如下場景)

class A{
public:A(int a):_a(a){}int _a;
};int main(){std::shared_ptr<A> sp1(new A(1));sp1 = sp1;
}

問題三

循環(huán)引用場景應(yīng)該怎么處理？

循環(huán)引用場景如下：

struct Node{std::shared_ptr<Node> _next;std::shared_ptr<Node> _prev;int _val;~Node(){/*析構(gòu)函數(shù)調(diào)用時的邏輯*/}
};int main(){std::shared_ptr<Node> p1(new Node);std::shared_ptr<Node> p2(new Node);p1->_next = p2;p2->_next = p1;
}

該場景帶來的問題描述：

?????由于p1->_next的存在，p2 這個對象想要析構(gòu)，起碼要等到 p1 的生命周期結(jié)束，因?yàn)橹挥衟1的生命周期結(jié)束，才會調(diào)用其析構(gòu)函數(shù)來釋放p1->_next，讓引用計(jì)數(shù)做減減，而由于p2->_next的存在，p1 這個對象想要析構(gòu)，起碼要等到 p2 的生命周期結(jié)束，因?yàn)橹挥衟2的生命周期結(jié)束，才會調(diào)用其析構(gòu)函數(shù)來釋放p2->_next，
?? ? 由此看來，p1 和 p2 都只能等對方先析構(gòu)才能析構(gòu)，那么最終的結(jié)果會導(dǎo)致這兩者都不析構(gòu)

問題四

shared_ptr所管理的資源釋放的方式不同，應(yīng)該怎么設(shè)計(jì)，使得不同類型的被管理資源都可以通過對應(yīng)的釋放方式進(jìn)行釋放？

考慮如上問題之后，可以設(shè)計(jì)出如下的 sharedPtr類

#pragma once
#include <atomic>
#include <functional>
using namespace std;template<class T>
class sharedPtr{
public:sharedPtr(T* sharedptr):_shared_ptr(sharedptr),_pcount(new atomic<int>(1)) // 問題一{}template<class D> // 問題四sharedPtr(T* sharedptr, D delMethod):_shared_ptr(sharedptr),_pcount(new atomic<int>(1)) // 問題一,_del(delMethod){}sharedPtr(const sharedPtr<T>& sp):_shared_ptr(sp._shared_ptr),_pcount(sp._pcount){++(*_pcount);}// 問題二，只有左操作數(shù)和右操作數(shù)的管理的指針不同才進(jìn)行引用計(jì)數(shù)的更改// 舊對象的引用計(jì)數(shù)減一，減到零就釋放sharedPtr<T>& operator=(const sharedPtr<T>& sp) {if (_shared_ptr != sp._shared_ptr) {this->release();_shared_ptr = sp._shared_ptr;_pcount = sp._pcount;++(*_pcount);}return *this;}void release() {if (--(*_pcount) == 0) {_del(_shared_ptr); // 問題四delete _pcount;}}int use_count() {return *_pcount;}T* operator->() {return _shared_ptr;}T& operator*() {return *_shared_ptr;}~sharedPtr() {release();}
private:T* _shared_ptr;atomic<int>* _pcount;// 問題四function<void(T*)> _del = [](T* ptr) {delete ptr; };
};

循環(huán)引用的解決方案

從以上的分析可以發(fā)現(xiàn)，問題三并沒有解決，只能通過weak_ptr進(jìn)行解決，weak_ptr 不屬于RAII技術(shù)，創(chuàng)建時不會增加引用計(jì)數(shù)

make_shared解決的問題

當(dāng)調(diào)用以下代碼時

auto ptr = std::shared_ptr<MyClass>(new MyClass(args...));

可能會引起內(nèi)存碎片，中途異常等問題，因?yàn)檫@句代碼會被拆成兩句話

MyClass* rawPtr = new MyClass(args...);
auto ptr = std::shared_ptr<MyClass> (rawPtr);

由于引用計(jì)數(shù)和 MyClass 對象在棧上申請的空間不連續(xù)，可能引起內(nèi)存碎片問題，而MyClass在調(diào)用構(gòu)造函數(shù)先開辟空間，開辟空間成功但執(zhí)行邏輯的過程中如果拋異常，將會導(dǎo)致內(nèi)存泄漏，make_shared 就解決了這個問題

智能指針的應(yīng)用

如果出現(xiàn)以下場景，則可以使用智能指針：

需要在棧上開辟一段空間，存放一個自定義類型的結(jié)構(gòu)體

注意：這里不考慮這個自定義類型在調(diào)用構(gòu)造函數(shù)時是否需要再在棧上申請一段空間

以下是工廠模式的樣例代碼

#include <iostream>
#include <string>
#include <memory>class Fruit{
public:Fruit(){}virtual void name() = 0;
};class Apple : public Fruit{
public:Apple(){}void name() override{std::cout << "我是蘋果！" << std::endl;}
};class Banana : public Fruit{
public:Banana(){}void name() override{std::cout << "我是香蕉！" << std::endl;}
};class FruitFactory{
public:virtual std::shared_ptr<Fruit> create() = 0;
};class AppleFactory : public FruitFactory{
public:std::shared_ptr<Fruit> create() override{return std::make_shared<Apple>();}
};class BananaFactory : public FruitFactory{
public:std::shared_ptr<Fruit> create() override{return std::make_shared<Banana>();}
};int main(){// 先創(chuàng)建一個一個指向FruitFactory的指針// 雖然這里不能創(chuàng)建抽象類的實(shí)例，但是可以創(chuàng)建指向抽象類的指針// 這里創(chuàng)建的是一個指向AppleFactory類型的實(shí)例的智能指針對象，這個智能指針的類型是FruitFactory// tmp作為一個類型為FruitFactory的指針，可以觸發(fā)多態(tài)，// 不同類中的create將創(chuàng)建出指向不同類型對象的fruitstd::shared_ptr<FruitFactory> tmp(new AppleFactory());std::shared_ptr<Fruit> fruit = tmp->create();fruit->name();tmp.reset(new BananaFactory());fruit = tmp->create();fruit->name();
}