=default, =delete

=default, =delete

=default

如果自己定义了一个ctor,那么编译器就不会再合成一个default ctor
如果强制加上=default, 编译器就会合成一个default ctor

=delete

禁止编译器合成

当被需要时c++编译器能合成的四类函数

构造，拷贝构造，拷贝赋值，析构函数

class Test {
public:
    Test(int i, int j):d1(i), d2(j) {}          //默认构造函数
    Test(const Test& t) = delete;               //拷贝构造
    Test(Test&&) = default;                     
    Test& operator=(const Test&) = default;     //拷贝赋值
    Test& operator=(const Test&&) = delete;
    virtual ~Test() {}                         //析构
private:
    int d1, d2;
}

构造函数可以有多个版本，拷贝构造，拷贝赋值，析构只能有一个版本
下述打//的会编译出错

class Foo {
public:
    Foo(int i): num(i){}
    Foo() = default;

    Foo(const Foo& x):num(x.num) {}
    //Foo(const Foo&) =default;         //不能重载
    //Foo(const Foo&) =delete;          //已经写了，不能delete

    Foo& operator=(const Foo& x) {
        num = x.num;
        return *this;
    }
    //Foo& operator=(const Foo& x) =default;   //不能重载
    //Foo& operator=(const Foo& x) =delete;    //已经写了，不能delete

    //void func1() = default;   //普通函数不能default，可以delete（没意义）
    void fun2() = delete;

    //~Foo() = delete;
    ~Foo() =default;

private:
    int num;
}

实现不可拷贝的类

只要与拷贝有关的构造函数不存在即可

class Nocopy {
public:
    Nocopy() = default;
    Nocopy(const Nocopy&) = delete;
    Nocopy& operator=(const Nocopy&) = delete;
    ~Nocopy() = default;
    //......
}

设计成友元能拷贝

class uncopyable {
protected:
    uncopyable() {}
    ~uncopyable() {}
private:
    uncopyable(const uncopyable&);
    const uncopyable& operator=(const uncopyable&);
}