第12课 特殊成员函数的生成机制

#include <iostream>
#include <map>

using namespace std;

//1. 演示特殊成员函数之间的抑制关系
//1.1 自定义析构函数会阻止默认移动操作（含移动构造和移动赋值）
class Foo
{
private:
    int i;
public:
    Foo() = default;
    Foo(const Foo& f) = delete;    //删除复制构造函数！让移动操作只会去找移动操作的函数，而不是被复制取代！
    Foo& operator=(const Foo&) = delete; //理由同上！

    ~Foo() {};  //这里自定义析构函数！
};

//1.2 自定义析构函数使“移动操作”变为“复制操作”！
class StringTable
{
    std::map<int, std::string> values;
    
    void makeLogEntry(std::string s){}; //日志记录
public:
    StringTable()
    {
        makeLogEntry("Creating StringTable Object");    
    }
    
    ~StringTable()   //注意，这里自定义了析构函数，会产生副作用！
    {
        makeLogEntry("Destroying StringTable Object");
    }
};

//2. 大三律
class Bar
{
public:
    virtual ~Bar() = default;  //自定义了析构函数，则应同时提供复制和移动操作！
    Bar(Bar&&) = default;     //提供移动操作的支持
    Bar& operator=(Bar&&) = default;

    Bar(const Bar&) = default;//提供移动操作的支持
    Bar& operator=(const Bar&) = default;
};

//3. 特种成员函数模板
class Widget
{
public:
    template<typename T>
    Widget(const T& rhs) { cout <<"Widget(const T& rhs)" << endl; }

    template<typename T>
    Widget& operator=(const T& rhs) 
    { 
        cout << "Widget& operator=(const T& rhs)" << endl;
        return *this; 
    }
    
public:
    Widget() = default;    
};

int main()
{
    //1. 自定义析构函数，会阻止移动操作
    Foo f;
    //Foo f1 = std::move(f);   //编译失败！ 由于自定义了析构函数，默认移动操作被删除。
    //f1 = std::move(w);       //编译失败！ 原因同上。
    
    StringTable st1;
    StringTable st2 = std::move(st1); //这里本意是调用移动构造函数，但因该类的析构函数阻止生成
                                      //默认的移动操作，转而变为复制操作。而对于values对象的复
                                      //制，而td::map<int, std::string>的复制往往比移动慢很多！

    //3. 特种成员函数模板不会抑制编译器生成默认的特殊成员函数
    Widget w;
    Widget w1 = w; //调用编译器生成的默认复制构造函数
    Widget w2 = 2; //调用函数模板：Widget(const T& rhs)
    
    w1 = w2; //调用编译器生成的默认复制赋值函数
    w1 = 2;  //调用函数模板：Widget& operator=(const T& rhs)

    return 0;
}
/*输出结果
Widget(const T& rhs)
Widget& operator=(const T& rhs)
*/