【C++ 继承】继承的构造函数
继承的构造函数
子类为完成基类初始化，在C++11之前，需要在初始化列表调用基类的构造函数，从而完成构造函数的传递。如果基类拥有多个构造函数，那么子类也需要实现多个与基类构造函数对应的构造函数。
1 class Base 2 { 3 public: 4 Base(int va) : m_value(va), m_c(‘0’) {} 5 Base(char c) : m_c(c), m_value(0) {} 6 private: 7 int m_value; 8 char m_c; 9 }; 10 11 class Derived : public Base 12 { 13 public: 14 // 初始化基类需要透传基类的各个构造函数，那么这是很麻烦的 15 Derived(int va) : Base(va) {} 16 Derived(char c) : Base(c) {} 17 void display() { /* dosomething */ } //假设派生类只是添加了一个普通的函数 18 };
书写多个派生类构造函数只为传递参数完成基类的初始化，这种方式无疑给开发人员带来麻烦，降低了编码效率。从C++11开始，推出了继承构造函数（Inheriting Constructor），使用using来声明继承基类的构造函数，我们可以这样书写。
1 class Base { 2 public: 3 Base(int va) : m_value(va), m_c('0') {} 4 Base(char c) : m_c(c), m_value(0) {} 5 private: 6 int m_value; 7 char m_c; 8 }; 9 10 class Derived : public Base { 11 public: 12 using Base::Base; //使用继承构造函数 13 void display() { /* dosomething */ } //假设派生类只是添加了一个普通的函数 14 };
上面代码中，我们通过using Base::Base把基类构造函数继承到派生类中，不再需要书写多个派生类构造函数来完成基类的初始化。更为巧妙的是，C++11标准规定，继承构造函数与类的一些默认函数（默认构造、析构、拷贝构造函数等）一样，是隐式声明，如果一个继承构造函数不被相关代码使用，编译器不会为其产生真正的函数代码。这样比通过派生类构造函数“透传构造函数参数”来完成基类初始化的方案，总是需要定义派生类的各种构造函数更加节省目标代码空间。
1. 示例
1 #include <iostream> 2 using namespace std; 3 4 class Base 5 { 6 public: 7 Base(int va) : m_value(va), m_c('0') {} 8 Base(char c) : m_c(c), m_value(0) {} 9 int m_value; 10 char m_c; 11 }; 12 13 class Derived : public Base 14 { 15 public: 16 using Base::Base; 17 void display() { cout << m_value << " " << m_c << endl; } 18 }; 19 20 int main() 21 { 22 Derived d(5); 23 d.display(); // 5 0 24 return 0; 25 }
【注意事项】
1. 继承构造函数无法初始化派生类数据成员。
继承构造函数的功能是初始化基类，对于派生类数据成员的初始化则无能为力。解决的办法主要有两个：一是使用C++11特性就地初始化成员变量，可以通过=、{}对非静态成员快速地就地初始化，以减少多个构造函数重复初始化变量的工作，注意初始化列表会覆盖就地初始化操作。
class Derived :public Base { public: using Base::Base; //使用继承构造函数 void display() { /* dosomethin */ } //假设派生类只是添加了一个普通的函数 private: double m_double{ 0.0 }; //派生类新增数据成员 };
2. 构造函数拥有默认值会产生多个构造函数版本，且继承构造函数无法继承基类构造函数的默认参数，所以我们在使用有默认参数构造函数的基类时就必须要小心。
1 class A 2 { 3 public: 4 A(int a = 3, double b = 4) : m_a(a), m_b(b) {} 5 void display() { cout << m_a << " " << m_b << endl; } 6 7 private: 8 int m_a; 9 double m_b; 10 }; 11 12 class B : public A 13 { 14 public: 15 using A::A; 16 };
那么A中的构造函数会有下面几个版本：
A() A(int) A(int, double) A(constA&)
那么B中对应的继承构造函数将会包含如下几个版本：
B() B(int) B(int, double) B(constB&)
示例代码：
1 #include <iostream> 2 using namespace std; 3 4 class A 5 { 6 public: 7 A(int a = 3, double b = 4) : m_a(a), m_b(b) 8 { 9 std::cout << "m_a = " << m_a << " m_b = " << m_b << std::endl; 10 } 11 12 private: 13 int m_a; 14 double m_b; 15 }; 16 17 class B : public A 18 { 19 public: 20 using A::A; 21 }; 22 23 int main() 24 { 25 B b(6); //m_a = 6 m_b = 4 26 }
多继承的情况下，继承构造函数会出现“冲突”的情况，因为多个基类中的部分构造函数可能导致派生类中的继承构造函数的函数名、参数（即函数签名）相同。考察如下代码：
1 class A { 2 public: 3 A(int i) {} 4 }; 5 6 class B { 7 public: 8 B(int i) {} 9 }; 10 11 class C : public A, public B { 12 public: 13 using A::A; 14 using B::B; //编译出错，重复定义C(int) 15 16 C(int i) :A(i), B(i) {} //显示定义继承构造函数C(int) 17 };
为避免继承构造函数冲突，可以通过显示定义继承类冲突的构造函数，组织隐式生成相应的继承构造函数。
此外，使用继承构造函数时，还需要注意以下几点：
如果基类构造函数被申明为私有成员函数，或者派生类是从基类中虚继承的 ，那么就不能在派生类中申明继承构造函数；
一旦使用继承构造函数，编译器就不会再为派生类生成默认构造函数了。
