一、问题描写叙述

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

例如以下：

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声明来完毕这个问题的简化，看一个样例

<pre name="code" class="cpp"><pre name="code" class="cpp">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.假设一旦使用了继承构造函数，编译器就不会为派生类生成默认构造函数。这样，我们得注意继承构造函数无參版本号是不是有须要。