#include <iostream>

using namespace std;

class Widget

{

private:

    int data;

public:

    Widget() = default;  //指示编译器提供默认版本（不影响POD特质）

    Widget(int i):data(i){}

    Widget(double d) = delete; //删除double版本

    explicit Widget(char c) = delete; //注意，这里explicit与deltete混用，将产生一些混乱。

    Widget(const Widget&) = delete;

    Widget& operator=(const Widget&);//这里没使用default，本例将在类外定义

private:

    //2.3.2 特化版本

    //Widget 类中声明了一个模板函数，当进行模板特化时，要求禁止参数为 void* 的函数调用。

    //本意是按照 C++98 的“私有不实现”思路，将特例化的函数声明为private。但模板特化不能放在

    //类作用域中定义，它必须放在命名空间作用域中定义。见后面类外定义部分

    //template<>

    //void processPointer<void>(void*);  //编译失败

public:

    //2.3 delete在模板特化中的作用

    //2.3.1 泛化版本

    template<typename T>

    void proccessPointer(T* ptr){}

};

//在类外使用“=default”来指明使用默认版本

inline Widget& Widget::operator=(const Widget&) = default;

//2. delete重载函数

template<>

void Widget::proccessPointer<void>(void*) = delete; // 仍然是public, 但被delete

void Func(Widget w){}

void overloadFunc(int i) {};

void overloadFunc(char c) = delete; //显式删除char版本

//4. delete妙用

//4.1 禁止在堆上创建类对象！

class NoHeapAlloc

{

public:

    void* operator new(std::size_t) = delete; //注意这里！

};

//4.2 禁止在栈上创建类对象！

class NoStackAlloc

{

public:

    NoStackAlloc()

    {

        cout <<"NoStackAlloc()" << endl;

    }

    ~NoStackAlloc() = delete; //注意这里，将导致无法自动析构函数。

};

int main()

{

    cout <<is_pod<Widget>::value << endl;  //0

    //1. 测试default与delete

    Widget w;  //ok，调用无参构造函数，己被声明为default;

    Widget w1;

    //Widget w2(w1);   //无法编译通过，因为Widget(const Widget&)己被delete

    //Widget w3 = w1;  //无法编译通过，因为Widget(const Widget&)己被delete

    Widget w4;

    w4 = w1;  //ok，operator=被指显式定为的默认函数

    //2. delete重载函数

    //2.1 delete成员函数

    Widget w5();

    //Widget w6(1.0);   //error, double版本的构造函数被delete

    Func();

    //Func(1.0);        //error， 1.0转为Widget需要调用double版本的构造函数，但该函数己delete。

    //2.2 delete普通函数

    overloadFunc();

    //overloadFunc('a'); //编译失败，char版本被delete。同时'a'也就没就机会隐式转为int。

    //2.3 delete特化的模板函数

    int* pi = nullptr;

    void* pv = nullptr;

    w5.proccessPointer(pi); //ok;

    //w5.proccessPointer(pv); //error，void*版本的特化函数被delete

    //3. explicit与delete的冲突

    //Widget w6('a');    //error，char版本的构造函数被delete

    Func('a');           //编译通过！！！由于char版本的构造函数被声明为explicit，'a'将无法再隐式转为Widget，但

                         //可以隐式转为int，于是调用Widget(int)版本。这与Widget(char)声明为delete的初衷不符！！！

    //4. delete的妙用！

    //4.1 仅限在栈上创建对象

    NoHeapAlloc nh;

    //NoHeapAlloc* pnh = new NoHeapAlloc; //编译失败，因为operator new己被delete

    //4.2 仅限在堆上创建对象

    void* p = malloc(sizeof(NoStackAlloc));

    //NoStackAlloc nsa;  //编译失败！栈对象，会被自动析构，但析构函数己被delete。

    new (p) NoStackAlloc(); //placement new构造的对象(仍会调用构造函数来初始化对象)，但编译器不会为

                            //其调用析构函数（可用于单例模式）。

    return ;

}

/*输出结果

0

NoStackAlloc()

*/

#include <iostream>

#include <vector>

#include <boost/type_index.hpp>

using namespace std;

using boost::typeindex::type_id_with_cvr;

//辅助类模板，用于打印T的类型

template <typename T>

void printType(string s)

{

    cout << s << " = " << type_id_with_cvr<T>().pretty_name() << endl;

}

//1. 重写（override）的条件

class Base

{

public:

    virtual void f1() const {};

    virtual void f2(int x) {}

    virtual void f3() & {};

    void f4() const {};

};

//class Derived : public Base

//{

//public:

//    virtual void f1() override {};  //error，const常量性不同！基类为void f1() const

//    virtual void f2(unsigned int x) override{} //error，函数形参类型不同（基类为void f2(int x)）

//    virtual void f3()&& override{}  //error，引用饰词不同(基类为void f3() & ）

//    virtual f4() const override{}   //error，非虚函数，不能override

//};

//2. final用于类和虚函数

class MathObject  //数学类（接口类）

{

public:

    virtual double Arith() = ; //算术运算

    virtual void Print() = ;   //打印

};

class Printable : public MathObject

{

public:

    void Print() final //为了保证打印风格统一，加final以阻止在子类中被重写

    {

        cout << "Output is : " << Arith() << endl;

    }

};

class Add final: public Printable  //在类上加final表示该类不再被继承

{

    double x, y;

public:

    Add(double a, double b):x(a),y(b){}

    double Arith() { return x + y; }

};

//class Add3 : public Add  //Add被声明为final，无法作为基类

//{

//};

//3. 左值 /右值引用类型的重载函数

class Widget

{

public:

    using DataType = std::vector<double>;

    //左值引用类型版本

    DataType& data() & //对于*this为左值时，调用该函数。注意返回引用

    {

        cout <<"invoke DataType& data() & " << endl;

        return values;

    }

    //右值引用类型版本

    DataType data() && //对于*this为右值时，调用该函数。注意返回右值

    {

        cout << "invoke DataType data() && " << endl;

        return std::move(values);

    }

private:

    DataType values;

};

//工厂函数

Widget makeWidget()

{

    return Widget();

}

int main()

{

    //左值/右值引用类型的重载函数

    Widget w;

    decltype(auto) vals1 = w.data();           //由于w是左值，会调用DataType& data() &

    decltype(auto) vals2 = makeWidget().data();//由于makeWidget()返回临时对象(是个右值)，会调用DataType data() &&

    printType<decltype(vals1)>("vals1");

    printType<decltype(vals2)>("vals2");

    return ;

}

/*输出结果

invoke DataType& data() &

invoke DataType data() &&

vals1 = class std::vector<double,class std::allocator<double> > &

vals2 = class std::vector<double,class std::allocator<double> >

*/