第20课 unique_ptr独占型智能指针

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

using namespace std;

class Widget {};

//返回值RVO优化：
unique_ptr<int> func()
{
    unique_ptr<int> up(new int(100));
    return  up; //up是个左值，调用拷贝构造给返回值？ No。
                //C++标准要求当RVO被允许时，要么消除拷贝，要么隐式地把std::move用在要返回的局部
                //对象上去。这里编译器会直接在返回值位置创建up对象。因此根本不会发生拷贝构造，
                //unique_ptr本身也不能被拷贝构造。

    //return unique_ptr<int>(new int(100)); //右值，被移动构造。
}

void foo(std::unique_ptr<int> ptr)
{
}

void myDeleter(int* p)
{
    cout << "invoke deleter(void* p)"<< endl;
    delete p;
}

int main()
{
    //1. unique_ptr的初始化
    //1.1 通过裸指针创建unique_ptr（由于unique_ptr的构造函数是explicit的，必须使用直接初始化，不能做隐式类型转换）
    std::unique_ptr<Widget> ptr1(new Widget);      //ok; 直接初始化
    //std::unique_ptr<Widget> ptr1 = new Widget(); //error。不能隐式将Widget*转换为unqiue_ptr<Widget>类型。

    std::unique_ptr<int[]> ptr2(new int[10]); //指向数组

    //1.2 通过移动构造
    //std::unique_ptr<Widget> ptr3 = ptr1;    //error，unique_ptr是独占型，不能复制构造
    std::unique_ptr<Widget> ptr3 = std::move(ptr1);  //ok，unique_ptr是个只移动类型，可以移动构造
    auto ptr4 = std::move(ptr3);     //ok， ptr4为unique_ptr<Widget>类型

    //1.3 通过std::make_unique来创建
    auto ptr5 = std::make_unique<int>(10);

    //auto ptr6 = std::make_unique<vector<int>>({1,2,3,4,5}); //error，make_unique不支持初始化列表
    auto initList = { 1,2,3,4,5 };
    auto ptr6 = std::make_unique<vector<int>>(initList);

    //2. 传参和返回值
    int* px = new int(0);
    //foo(px); //error，px无法隐式转为unique_ptr。可防止foo函数执行完毕后，px会自动释放。
    //foo(ptr5); //error，智能指针不能被拷贝。因此，可以将foo的形参声明为引用，以避免所有权转移
    foo(std::move(ptr5)); //ok，通过移动构造

    auto ptr7 = func(); //移动构造

    //3.常用操作
    std::unique_ptr<Widget> upw1; //空的unique_ptr
    upw1.reset(new Widget);
    std::unique_ptr<Widget> upw2(new Widget);

    cout <<"before swap..." << endl;
    cout << "upw1.get() = " << hex << upw1.get() << endl;

    cout << "upw2.get() = " << hex << upw2.get() << endl;

    cout << "after swap..." << endl;
    upw1.swap(upw2); //交换指针所指的对象
    cout << "upw1.get() = " << hex << upw1.get() << endl;
    cout << "upw2.get() = " << hex << upw2.get() << endl;

    //upw1.release(); //release放弃了控制权不会释放内存，丢失了指针
    Widget* pw = upw1.release();//放弃对指针的控制
    delete pw; //需手动删除

    if (upw1) {  //unique_ptr重载了operator bool()
        cout << "upw1 owns resourse" << endl;
    }else {
        cout << "upw1 lost resourse" << endl;
    }

    upw1.reset(upw2.release()); //转移所有权
    cout << "upw1.get() = " << hex << upw1.get() << endl;
    cout << "upw2.get() = " << hex << upw2.get() << endl;

    //upw1 = nullptr; //释放upw1指向的对象，并将upw1置空
    //upw1.reset(nullptr);

    //4.unique_ptr的大小
    std::unique_ptr<int,decltype(&myDeleter)> upd1(new int(0), myDeleter); //自定义删除器
    auto del = [](auto* p) {delete p; };
    std::unique_ptr<int, decltype(del)> upd2(new int(0), del); 
    cout << sizeof(upw1) << endl; //4字节，默认删除器
    cout << sizeof(upd1) << endl; //8字节
    cout << sizeof(upd2) << endl; //4字节

    return 0;
}

#include "Widget.h"

//将对string和vector和Gadget头文件的依赖从Wigdget.h转移动Wigdget.cpp文件中。如此，Widget类的使用者
//只需依赖Widget.h，而把复杂的依赖关系留给Widget的实现者(Widget.cpp)去处理
#include <string>
#include <vector>
class Gadget {}; //本应#include "Gardget.h"，但为了简明起见，就直接在这里声明该类

//Widget::Impl的实现(包括此前在Widget中的数据成员)
struct Widget::Impl
{
    std::string name;
    std::vector<double> data;
    Gadget g1, g2, g3;
};

Widget::Widget():pImpl(std::make_unique<Impl>())
{}

//注意：析构函数必须在Widget::Impl类之后定义。因为此时调用~Widget时，会调用unique_ptr的析构函数
//而unique_ptr中会调用delete删除其指向的对象，由于~Widget定义在Widget::Impl之后，因此这时看到的
//Impl是个完整的类，delete前通过了unique_ptr内部完整类型的判断！
Widget::~Widget() {}//或Widget::~Widget = default;

Widget::Widget(Widget&& rhs) = default;
Widget& Widget::operator=(Widget&& rhs) = default;

//make_unique(Ts&&... params)== std::unique_ptr<T>(new T(std::forward<Ts>(params)...));
Widget::Widget(const Widget& rhs):pImpl(std::make_unique<Impl>(*rhs.pImpl))//深拷贝！
{
}

Widget& Widget::operator=(const Widget& rhs)
{
    *pImpl = *rhs.pImpl; //深拷贝！复制两个指针所指向的内容。pImpl本身是只移动类型
    return *this;
}

#include <iostream>
#include <memory>
#include <functional>
#include "Widget.h"
using namespace std;

enum class InvestmentType {itSock, itBond, itRealEstate};
class Investment//投资
{
public:
    virtual ~Investment() {} //声明为virtual,以便正确释放子类对象
};

class Stock : public Investment {};//股票
class Bond : public Investment {};  //债券
class RealEstate : public Investment {}; //不动产

void makeLogEntry(Investment* pInvmt) {}

//工厂函数
template<typename... Ts>
auto makeInvestment(Ts&&... params) //返回unique_ptr智能指针
{
    //自定义deleter
    auto delInvmt = [](Investment* pInvmt) //父类指针
    {
        makeLogEntry(pInvmt);
        delete pInvmt; //delete父类指针，所有析构函数须声明为virtual
    };

    std::unique_ptr<Investment, decltype(delInvmt)> pInv(nullptr, delInvmt);

    if (1/*a Stock Object should be created*/) {
        pInv.reset(new Stock(std::forward<Ts>(params)...)); //原始指针无法隐式转为unique_ptr，使用reset重置所有权
    }
    else if (0/*a Bond Object should be created*/)
    {
        pInv.reset(new Bond(std::forward<Ts>(params)...));
    }
    else if (0/*a RealEstate should be created*/)
    {
        pInv.reset(new RealEstate(std::forward<Ts>(params)...));
    }

    return pInv;
}


int main()
{
    //1. unique_ptr作为工厂函数的返回值。
    std::shared_ptr<Investment> sp =  makeInvestment();  //从std::unique_ptr转换到std::shared_ptr（从独占到共享的
                                                         //转换简单而高效） 

    //2. PImpl手法的测试
    Widget w;  //注意Widget的析构函数必须手动实现。否则，则当w析构时编译器会将默认的析构函数inline
               //到这里来，但由于include widget.h在inline动作之前，此时编译器看到的是非完整类型的
               //Impl类。因此Widget类中的unique_ptr析构时，delete前检查出是个非完整类指针，从而报错。
}