1 继承构造函数

1.1 为什么需要继承构造函数

子类为完成基类初始化，在C++11之前，需要在初始化列表调用基类的构造函数，从而完成构造函数的传递。如果基类拥有多个构造函数，那么子类也需要实现多个与基类构造函数对应的构造函数。

class Base
{
public:
    Base(int va) :m_value(va), m_c(‘0’){}
    Base(char c) :m_c(c) , m_value(0){}
private:
    int m_value;
    char m_c;
};

class Derived :public Base
{
public:
    //初始化基类需要透传基类的各个构造函数，那么这是很麻烦的
    Derived(int va) :Base(va) {}
    Derived(char c) :Base(c) {}
};

1.2 如何继承父类的构造函数

书写多个派生类构造函数只为传递参数完成基类的初始化，这种方式无疑给开发人员带来麻烦，降低了编码效率。从C++11开始，推出了继承构造函数（Inheriting Constructor），使用using来声明继承基类的构造函数。

class Base
{
public:
    Base(int va) :m_value(va), m_c('0') {}
    Base(char c) :m_c(c), m_value(0) {}
private:
    int m_value;
    char m_c;
};

class Derived :public Base
{
public:
    //使用继承构造函数
    using Base::Base;
};

通过 using Base::Base 把基类构造函数继承到派生类中，不再需要书写多个派生类构造函数来完成基类的初始化。C++11 标准规定，继承构造函数与类的一些默认函数（默认构造、析构、拷贝构造函数等）一样，是隐式声明，如果一个继承构造函数不被相关代码使用，编译器不会为其产生真正的函数代码。这样比总是需要定义派生类的各种构造函数更加节省目标代码空间。

1.3 注意事项

（1）继承构造函数无法初始化派生类数据成员，继承构造函数的功能是初始化基类，对于派生类数据成员的初始化则无能为力。解决的办法主要有两个：

• 可以通过 =、{} 对非静态成员快速地就地初始化，以减少多个构造函数重复初始化变量的工作，注意初始化列表会覆盖就地初始化操作。

class Derived :public Base
{
public:
    //使用继承构造函数
    using Base::Base;
private:
//派生类新增数据成员
    double m_double{0.0};
};

• 新增派生类构造函数，使用构造函数初始化列表初始化

class Derived :public Base
{
public:
    //使用继承构造函数
    using Base::Base;

    //新增派生类构造函数
    Derived(int a,double b):Base(a),m_double(b){}
private:
    //派生类新增数据成员
    double m_double{0.0};
};

（2）构造函数拥有默认值会产生多个构造函数版本，且继承构造函数无法继承基类构造函数的默认参数，所以我们在使用有默认参数构造函数的基类时就必须要小心。

class A
{
public:
    A(int a = 3, double b = 4):m_a(a), m_b(b){}
    void display()
    {
        cout<<m_a<<" "<<m_b<<endl;
    }

private:
    int m_a;
    double m_b;
};

class B:public A
{
    public:
    using A::A;
};

那么A中的构造函数会有下面几个版本：

A()
A(int)
A(int,double)
A(const A&)

那么B中对应的继承构造函数将会包含如下几个版本：

B()
B(int)
B(int,double)
B(const B&)

（3）多继承的情况下，继承构造函数会出现“冲突”的情况，因为多个基类中的部分构造函数可能导致派生类中的继承构造函数的函数名与参数相同，即函数签名。

class A
{
public:
    A(int i){}
};

class B
{
public:
    B(int i){}
};

class C : public A,public B
{
public:
    using A::A;
    using B::B;  //编译出错，重复定义C(int)
    
    //显示定义继承构造函数C(int)
    C(int i):A(i),B(i){}
};

为避免继承构造函数冲突，可以通过显示定义来阻止隐式生成的继承构造函数。

2 委托构造函数

2.1 为什么使用委托构造函数

委托构造函数（Delegating Constructor）由 C++11 引入，是对 C++ 构造函数的改进，允许构造函数通过初始化列表调用同一个类的其他构造函数，目的是简化构造函数的书写，提高代码的可维护性，避免代码冗余膨胀。

通俗来讲，一个委托构造函数使用它所属的类的其他构造函数执行自己的初始化过程，或者说它把自己的一些（或者全部）职责委托给了其他构造函数。和其他构造函数一样，一个委托构造函数也有一个成员初始化列表和一个函数体，成员初始化列表只能包含一个其它构造函数，不能再包含其它成员变量的初始化，且参数列表必须与构造函数匹配。

不使用委托构造函数造成代码冗余的例子

class Foo
{
public:
    Foo() :type(4), name('x') {initRest();}
    Foo(int i) : type(i), name('x') {initRest();}
    Foo(char c) :type(4), name(c) {initRest();}

private:
    void initRest() {/* init othre members */}
    int type;
    char name;
    //...
};

使用委托构造函数的例子

class Foo
{
public:
    Foo() {initRest(); }
    Foo(int i) : Foo() {type = i;}
    Foo(char e) : Foo() {name = e;}
private:
    void initRest() { /* init othre members */}
    int type{1};
    char name{'a'};
};

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

2.2 注意事项

在构造函数较多的时候，我们可能拥有多个委托构造函数，而一些目标构造函数很可能也是委托构造函数，这样依赖，我们就可能在委托构造函数中形成链状的委托构造关系，形成委托坏（Delegation Cycle）。

class Foo
{
public:
    Foo(int i) : Foo('c') { type = i; }
    Foo(char c) : Foo(1) { name = c; }
private:
    int type;
    char name;
};

参考：

https://blog.csdn.net/K346K346/article/details/81703914
https://blog.csdn.net/K346K346/article/details/8170386