C++11构造与禁用默认函数

C++11（五）继承构造

在继承体系中，假设派生类想要使用基类的构造函数，必须要在构造函数中显式声明。

举个小例子：

class Base {
public:int value1;int value2;Base() {value1 = 1;}Base(int value) : Base() { // 委托 Base() 构造函数value2 = value;}
};
class Subclass : public Base {
public:using Base::Base; // 继承构造
};

那么它解决了什么问题呢？

下面参考了：https://www.runoob.com/w3cnote/cpp11-inheritance-constructor.htm

看看下面的小问题：

struct A{   A(int i){}};struct B:A{  B(int i):A(i){}};在这里，B派生于A，B

又在构造函数中调用A的构造函数。从而完毕构造函数的传递。

又比方例如以下。当B中存在成员变量时：

struct A{A(int i){}
};
struct B:A{B(int i)：A(i),d(i){}int d;
};

如今派生于A的结构体B包括一个成员变量，我们在初始化基类A的同一时候也初始化成员d。如今的问题是：假若基类用于拥有为数众多的不同版本号的构造函数。这样，在派生类中按上面的思维还得写非常多相应的"透传"构造函数。例如以下：

struct A{A(int i) {}A(double d,int i){}A(float f,int i,const char* c){}//...等等系列的构造函数版本号
};
struct B:A{B(int i):A(i){}B(double d,int i):A(d,i){}B(folat f,int i,const char* c):A(f,i,e){}//......等等好多个和基类构造函数相应的构造函数
};

非常明显当基类构造函数一多，派生类构造函数的写法就显得非常累赘，相当不方便。

问题的解决

我们能够通过using声明来完毕这个问题的简化，看一个样例

struct Base{void f(double i){cout<<"Base:"<<i<<endl;}
};
struct Drived:Base{using Base::f;void f(int i){cout<<"Drived:"<<i<<endl;}
};

代码中基类和派生类都声明了同名的函数f。但派生类中办法和基类的版本号不同，这里使用using声明，说明派生类中也使用基类版本号的函数f。这样派生类中就拥有两个f函数的版本号了。在这里必须要说明的是，假设没有使用using声明继承父类同名函数，那么派生类中定义的f函数将会屏蔽父类的f函数，当然若派生类根本就未定义这个f同名函数。还会选择用基类的f函数。

这样的方法，我们一样可迁移到构造函数的继承上。即派生类能够通过using语句声明要在子类中继承基类的全部构造函数。例如以下：

struct A
{A(int i) {}A(double d,int i){}A(float f,int i,const char* c){}//...等等系列的构造函数版本号
};
struct B:A
{using A::A;//关于基类各构造函数的继承一句话搞定//......
};

如今，通过using A::A的声明。将基类中的构造函数全继承到派生类中，更巧妙的是，这是隐式声明继承的。即假设一个继承构造函数不被相关的代码使用，编译器不会为之产生真正的函数代码，这样比透传基类各种构造函数更加节省目标代码空间。但此时另一个问题：

当使用using语句继承基类构造函数时。派生类无法对类自身定义的新的类成员进行初始化，我们可使用类成员的初始化表达式，为派生类成员设定一个默认初始值。比方：

struct A
{A(int i) {}A(double d,int i){}A(float f,int i,const char* c){}//...等等系列的构造函数版本号
};
struct B:A
{using A::A;int d{0};
};

注意：

1.对于继承构造函数来说，參数的默认值是不会被继承的，并且，默认值会导致基类产生多个构造函数版本号（即參数从后一直往前面减。直到包括无參构造函数，当然假设是默认复制构造函数也包括在内），这些函数版本号都会被派生类继承。

2.继承构造函数中的冲突处理：当派生类拥有多个基类时，多个基类中的部分构造函数可能导致派生类中的继承构造函数的函数参数都同样，那么继承类中的继承构造函数将导致不合法的派生类代码，比方：

struct A{A(int){}
};
struct B{B(int){}
};
struct C:A,B{using A::A;using B::B;
};

在这里将导致派生类中的继承构造函数发生冲突，一个解决的办法就是显式指定继承类的冲突构造函数。阻止隐式生成对应的继承构造函数，以免发生冲突。

struct C:A,B{using A::A;using B::B;C(int){}
};

3.假设基类的构造函数被声明为私有构造函数或者派生类是从基类虚继承的，那么就不能在派生类中声明继承构造函数。

4.假设一旦使用了继承构造函数，编译器就不会为派生类生成默认构造函数。这样，我们得注意继承构造函数无参版本号是不是有必要。

C++11（六）委托构造

《C++Primer》一书中关于委托构造函数是这样描述的：

一个委托构造函数使用它所属的类的其他构造函数执行自己的初始化过程，或者说它把自己的一些（或者全部）职责委托给了其他构造函数。和其他构造函数一样，一个委托构造函数也有一个成员初始值的列表和一个函数体。在委托构造函数内，成员的初始值列表只有一个唯一的入口，就是类名本身。和其他成员初始值一样，类名后面紧跟圆括号括起来的参数列表，参数列表必须与类中另外一个构造函数匹配。

概念比较难懂，下面举个小例子：

class Base {public:int value1;int value2;Base() {value1 = 1;}Base(int value) : Base() { // 委托Base() 构造函数value2 = value;}
};

why？

在C++98中，如果你想让两个构造函数完成相似的事情，可以写两个大段代码相同的构造函数，或者是另外定义一个init()函数，让两个构造函数都调用这个init()函数。例如：

class X {int a;// 实现一个初始化函数init(int x) {if (0<x && x<=max) a=x; else throw bad_X(x);}public:// 三个构造函数都调用validate()，完成初始化工作X(int x) { init(x); }X() { init(42); }
};

这样的实现方式重复罗嗦，并且容易出错。并且，这两种方式的可维护性都很差。所以，在C++0x中，我们可以在定义一个构造函数时调用另外一个构造函数：

class X {int a;public:X(int x) { if (0<x && x<=max) a=x; else throw bad_X(x); }// 构造函数X()调用构造函数X(int x)X() :X{42} { }
};

一个构造函数想要委托另一个构造函数，那么被委托的构造函数应该包含较大数量的参数，初始化较多的成员变量。而且在委托其他构造函数后，不能再进行成员列表初始化，而只能在函数体内进行初始化其他成员变量。

C++11（七）禁用默认函数

在传统C++中，若用户没有提供，则编译器会自动为对象生成默认构造函数(default constructor)、复制构造函数(copy constructor)，赋值运算符(copy assignment operator operator=) 以及析构式(destructor)。另外，C++也为所有的类定义了数个全局运算符(如operator delete及operator new)。当用户有需要时，也可以提供自定义的版本改写上述的函数。

问题在于原先的c++无法精确地控制这些默认函数的生成。比方说，要让类型不能被拷贝，必须将复制构造函数与赋值运算符声明为private，并不去定义它们。尝试使用这些未定义的函数会导致编译期或链接期的错误。但这种手法并不是一个理想的解决方案。

此外，编译器产生的默认构造函数与用户定义的构造函数无法同时存在。若用户定义了任何构造函数，编译器便不会生成默认构造函数；但有时同时带有上述两者提供的构造函数也是很有用的。目前并没有显式指定编译器产生默认构造函数的方法。

C++11 允许显式地表明采用或拒用编译器提供的自带函数。例如要求类型带有默认构造函数，可以用以下的语法：

class Magic
{public:Magic() = default; // 显式声明使用编译器生成的构造Magic &operator=(const Magic &) = delete; // 显式声明拒绝编译器生成构造Magic(int magic_number);
}

显式地使用default关键字声明使用类的默认行为，对于编译器来说明显是多余的，但是对于代码的阅读者来说，使用default显式地定义复制操作，则意味着这个复制操作就是一个普通的默认的复制操作。将默认的操作留给编译器去实现将更加简单，更少的错误发生，并且通常会产生更好的目标代码。

“default”关键字可以用在任何的默认函数中，而“delete”则可以用于修饰任何函数。例如，我们可以通过下面的方式排除一个不想要的函数参数类型转换：

    struct Z {// …Z(long long);     // 可以通过long long初始化Z(long) = delete; // 但是不能将long long转换为long进行初始化(?)};

移动构造和移动赋值

在C++98中，我们自定义的类，会默认生成拷贝赋值操作符函数和拷贝赋值函数以及析构函数；
在C++11中，依赖于新增的move语义，默认生成的函数多了2个移动相关的：移动赋值操作符（ move assignment ）和移动构造函数（ move constructor ）；

BS建议，如果你显式声明了上述 5 个函数或操作符中的任何一个，你必须考虑其余的 4 个，并且显式地定义你需要的操作，或者使用这个操作的默认行为。

一旦我们显式地指明（声明 , 定义 , =default , 或者 =delete ）了上述五个函数之中的任意一个，编译器将不会默认自动生成move操作。
一旦我们显式地指明（声明 , 定义 , =default , 或者 =delete ）了上述五个函数之中的任意一个，编译器将默认自动生成所有的拷贝操作。但是，我们应该尽量避免这种情况的发生，不要依赖于编译器的默认动作。

如果你声明了上述 5 个默认函数中的任何一个，强烈建议你显式地声明所有这 5 个默认函数。例如：

template<class T>
class Handle {T* p;
public:Handle(T* pp) : p{pp} {}// 用户定义构造函数： 没有隐式的拷贝和移动操作~Handle() { delete p; }Handle(Handle&& h) :p{h.p}{ h.p=nullptr; }; // transfer ownershipHandle& operator=(Handle&& h){ delete p; p=h.p; h.p=nullptr; } // 传递所有权Handle(const Handle&) = delete;  // 禁用拷贝构造函数Handle& operator=(const Handle&) = delete;// ...
};