C++ 11的继承构造函数

1.概述

C++是面向对象的基石，类具有可派生性。派生类可以自动获得基类的成员变量和接口，不过基类的非虚函数则无法再被派生类使用了。如果派生类要使用基类的构造函数，通常需要在构造函数中显示声明。

例如：

struct A
{
	A(int i){}	
};

struct B : A 
{
	B(int i) : A(i) {}
};

B派生于A，B又在构造函数中调用A的构造函数，从而完成了构造函数的"传递"。

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

上面代码中，派生于结构体A的结构体B拥有一个成员变量d,那么在B的构造函数B(int i)中，我们可以在初始化其基类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(double f, int i, const char* c) : A(f, i, c){}
	virtual void ExtraInterface(){}
};

上面的代码中，我们可以看到，基类A中的构造函数又很多个版本，而继承A的派生类B中实际上只添加了一个ExtraInterface接口，那么如果我们在B中要想拥有A这样多的构造方法的话，就必须一一"透传"各个接口，这是很不方便的。

从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;

	//假设派生类只是添加了一个普通的函数
	void display()
	{
//dosomething		
	}
};

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

2.注意事项

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

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

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

	//假设派生类只是添加了一个普通的函数
	void display()
	{
//dosomething		
	}
private:
//派生类新增数据成员
double m_double{0.0};
};

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

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

	//新增派生类构造函数
	Derived(int a,double b):Base(a),m_double(b){}

	//假设派生类只是添加了一个普通的函数
	void display()
	{
		//dosomething		
	}
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)
};

A和B的构造函数会导致C中重复定义相同类型的继承构造函数。这种情况下，可以通过显式定义继承类的冲突的构造函数，阻止隐式生成相应的继承构造函数来解决冲突。比如

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){}
};

为避免继承构造函数冲突，可以通过显示定义来阻止隐式生成的继承构造函数。
另外我们还需要了解的一些规则是，如果基类的构造函数被声明为私有成员函数，或者派生类是从基类中虚继承的，那么就不能够在派生类中声明继承构造函数。此外，如果一旦使用了继承构造函数，编译器就不会再为派生类生成默认构造函数了。

参考文献

[1] Michael Wong, IBM XL编译器中国开发团队.深入理解C++11[M].C3.1 继承构造函数.P57-P62
转载 https://blog.csdn.net/jiang_xinxing/article/details/78477134
转载 https://blog.csdn.net/K346K346/article/details/81703914