第23课 优先选用make系列函数

#include <iostream>
#include <memory> //for smart pointer
#include <vector>

using namespace std;

class Widget
{
public:
    Widget(){}
    Widget(int x, int y){ cout << "Widget(int x, int y)" << endl; }
    Widget(const std::initializer_list<int> li) { cout << "Widget(std::initializer_list<int> li)"<< endl; }
};

void processWidget(std::shared_ptr<Widget> spw, int priority){}
int computePriority() { /*throw 1;*/ return 0; }//假设该函数会抛出异常

class ReallyBigType {};//大对象

int main()
{
    //1. make系列函数的优势
    //1.1 避免代码冗余，减少重复书写类型
    auto upw1(std::make_unique<Widget>());    //使用make系列函数，Widget只需写一次
    std::unique_ptr<Widget> upw2(new Widget); //使用new，Widget需写二次。

    //1.2 make系统异常安全性更高
    //在将实参传递processWidget前，各个参数时必须先被计算出来，假设顺序如下（因编译器和调用约定而异）
    //A. 先new Widget，即一个Widget对象在堆上创建。
    //B. 执行computePriority，但假设此时该函数产生异常，那上面的堆对象就会泄漏。
    //C. 正常流程下，应执行shared_ptr构造函数，但由于第2步的异常，使得第1步分配的堆对象永远不会被这个
    //   shared_ptr接管（实际上该shared_ptr自己都没有机会创建），于是资源泄漏！
    processWidget(shared_ptr<Widget>(new Widget), computePriority());//潜在资源泄漏！
    
    //异常安全！
    processWidget(make_shared<Widget>(), computePriority()); //如果make_shared首先被调用当computePriority
                                                             //发生异常时，则之前的shared_ptr会被释放，
                                                             //从而释放Widget对象。如果computePriority先
                                                             //调用，则make_shared没有机会被调用，也就不会
                                                             //有资源泄漏！
    //1.3 make_shared一次性分配内存
    auto spw1 = std::make_shared<Widget>(); //一次性分配一个内存单块，可容纳Widget对象和控制块内存
    std::shared_ptr<Widget> spw2(new Widget); //2次分配：new和分配控制块各一次。

    //2. make系列函数的局限性
    //2.1 make不能自定义删除器
    auto widgetDeleter = [](Widget* pw) {delete pw; };
    std::unique_ptr<Widget, decltype(widgetDeleter)> upw3(new Widget, widgetDeleter);
    std::shared_ptr<Widget> spw3(new Widget, widgetDeleter);

    //2.2 make系列函数不能接受{}初始化
    auto upv = std::make_unique<std::vector<int>>(10, 20); //10个元素，每个都是20。而不是只有两个元素
    auto spv = std::make_shared<std::vector<int>>(10, 20); //同上

    auto pw1 = new Widget(10, 20);   //使用圆括号，匹配Widget(int x, int y)
    auto pw2 = new Widget{ 10, 20 }; //使用大括号，匹配Widget(initializer_list)
    delete pw1;
    delete pw2;

    auto spw = std::make_shared<Widget>(10, 20); //使用圆括号，匹配Widget中非initializer_list形参的构造函数
    //auto spw = std::make_shared<Widget>({10,20}); //error，make无法转发大括号初始化列表（原因见《完美转发》一课）
    auto initList = { 10, 20 }; //initList推导为initializer_list<int>
    auto splst = std::make_shared<Widget>(initList); //ok，匹配Widget(const std::initializer_list<int> li) 

    //2.3 对象的内存可能无法及时回收
    auto pBigObj = std::make_shared<ReallyBigType>(); //通过make_shared创建大对象
    //...   //创建指向大对象的多个std::shared_ptr和std::weak_ptr，并使用这些智能指针来操作对象
    //...   //最后一个指向大对象的shard_ptr在此析构，但若干weak_ptr仍然存在
    //...   //此时，内存块只析构，还没回收。因为weak_ptr还共享着内存块中的控制块
    //...   //最后一个指向大对象的weak_ptr析构，内存块（托管对象+控制块）才被回收。由于weak_ptr的生命期比shared_ptr长，
            //出现了内存块延迟回收的现象。

    //使用new方法则不会出现上述现象
    shared_ptr<ReallyBigType> pBigObj2(new ReallyBigType); //通过new，而不是make_shared创建
    //...   //同前，创建指向多个指向大对象的shared_ptr和weak_ptr。
    //...   //最后一个指向大对象的shard_ptr在此析构，但若干weak_ptr仍然存在。此时大对象的内存由于强引用为0，被回收。
    //...   //此阶段，仅控制块占用的内存处于未回收状态。
    //...   //最后一个指向该对象的weak_ptr析构，控制块被回收。

    return 0;
}