C++11中的继承构造函数

时间：2014.06.19

地点：基地

-------------------------------------------------------------------------

一、问题描述

  在继承体系中，如果派生类想要使用基类的构造函数，需要在构造函数中显式声明。如下：

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.如果一旦使用了继承构造函数，编译器就不会为派生类生成默认构造函数。这样，我们得注意继承构造函数无参版本是不是有需要。