使用虚基类时，虚基类时被共享的，也就是在继承体系中无论被继承多少次，对象内存模型中均只会出现一个虚基类的子对象，即使共享虚基类。但是必须要有一个类来完成基类的初始化，同时还不能够重复进行初始化。C++标准中选择在每一次继承子类中都必须书写初始化语句，但是虚基类的初始化是由最后的子类完成，其他的初始化语句都不会调用。
 
class animal
 {
 public:
 void printanimal()
 {
 cout << "class animal" << endl;
 }
 animal(int age)
 {
 this->age = age;
 }
 int age;
 };
 //每一个继承子类中，都必须写初始化语句
 class horse:virtual public animal
 {
 public:
 horse():animal(1){}//不调用
 };
 class donkey:virtual public animal
 {
 public:
 donkey() :animal(2) {}//不调用
 };
 class mule:public horse,public donkey
 {
 public:
 mule() :animal(3) {}//调用
 };
 void test()
 {
 mule m1;
 cout << m1.age << endl;//输出3 
 }
 

如果一个派生类有多个基类，而这些直接基类又有一个共同的基类，则在最终的派生类中会保留该间接数据成员的多份同名成员。
 
使用虚基类可使最终的派生类只保留共同基类的一份同名成员。
 
一般情况下，派生类的构造函数只需负责对其直接基类初始化，再由直接基类负责对间接基类初始化。
 
对虚基类的派生类：在最后的派生类中不仅要负责对其直接基类进行初始化，还要对虚基类初始化。
 
 

 
 
代码一：
 
 
#include <iostream>
using namespace std;

class A
{
	public:
	A(){cout<< 'a';}
	int a;
};

class B: public A
{
	public:
	B(){cout<< 'b';}
	int b;
};


class C: public A
{
	public:
	C(){cout<< 'c';}
	int c;	
};

class D: public B, public C
{
	public:
		D(){cout<< 'd';};
	int d;	
};

int main()
{
	D d;
	return 0;
}
//abacd 

 程序输出abacd，调用类D的构造函数会先调用类D的直接基类的构造函数，因为按基类出现的顺序调用构成函数，所以先调用类B的构造函数，同理：调用类B的构造函数，先调用类A的构造函数，所以输出abacd 
 

 
 
代码二：
 
 
<pre name="code" class="cpp">#include <iostream>
using namespace std;

int t= 0;

class A
{
	public:
	A(){cout<< 'a'; t++;}
	int a;
};

class B: virtual public A
{
	public:
	B(){cout<< 'b';}
	int b;
};


class C: virtual public A
{
	public:
	C(){cout<< 'c';}
	int c;	
};

class D: public B, public C
{
	public:
		D(){cout<< 'd';};
	int d;	
};

int main()
{
	D d;
	cout<< t;
	return 0;
}
//abcd1

 

 
 

 类D的构造函数通过初始化调用了虚基类的构造函数A，然后再调用类B和类C的构造函数。 
 
那么这里类B和类C的构造函数会不会调用虚基类的构造函数A呢？
 
不会， 因为C++编译相同只执行最后的派生类对虚基类的构造函数的调用，而忽略基类的其他派生类对虚基类的构造函数的调用

运行环境：macOS shell 
 代码：
 
#include <iostream>
#include <iomanip>
#include <string>
using namespace std;

class base
{
protected:
    int x;
public:
    base(int x1)
    {
        x = x1;
        cout<<"constructing base, x = "<<x<<endl;
    }
};

class base1 :  virtual public base
{
    int y;
public:
    base1(int x1, int y1):base(x1)
    {
        y = y1;
        cout<<"constructing base1, y = "<<y<<endl;
    }
};

class base2 : virtual public base
{
    int z;
public:
    base2(int x1, int z1):base(x1)
    {
        z = z1;
        cout<<"constructing base2, z = "<<z<<endl;
    }
};

class derived:public base1, public base2
{
    int xyz;
public:
    derived(int x1, int y1, int z1, int xyz1):base(x1),base1(x1,y1),base2(x1,z1)
    {
        xyz = xyz1;
        cout<<"constructing derived, xyz = "<<xyz<<endl;
    }
};

int main ()
{
    derived obj(1,2,3,4);
    return 0;
}
 
运行结果： 
 

C++ 成员和基类的初始化
 
 
class Club
{
    struct Date
    {
        int year;
        int month;
        int day;
        Date(int y, int m, int d);
    }

    string name;
    vector<string> members;
    vector<string> officers;
    Date founded;
public:
    Club(const string& n, Date fd);
};
 
 
1. 成员初始化
 
Club的构造函数接收两个参数。在构造函数的定义中，通过成员初始化列表给出成员的构造函数的参数：
 
Club::Club(const string& n, Date fd)
    :name{n},founded{fd}
{
    // ...
}
 
如果一个成员的构造函数不需要参数，就不必在成员初始化列表中提及此成员。
 
类自身的构造函数在其构造函数体执行之前会先调用成员的构造函数。成员的构造函数按成员在类中的声明顺序调用，而不是按成员在初始化列表中出现的顺序。成员之间存在初始化依赖的时候需要注意成员的声明顺序
内置类型成员需要显式初始化，隐式初始化的内置类型成员实际上是未初始化的
一个构造函数可以初始化其类的成员和基类，但不会初始化 其成员或基类 的 成员或基类。也就是说类的成员初始化过程只会初始化一层成员（调用自己成员的构造函数），不会初始化成员的成员（不会调用自己成员的成员的构造函数）
引用成员或者const成员必须初始化
 
 
2.基类初始化器
 
如果基类要求一个初始化器，就必须在构造函数中提供相应的基类的初始化器。如果希望进行默认构造，可以显式指出。
 
class B1{ B1(); };        // 具有默认构造函数
class B2{ B2(int); };     // 无默认构造函数

struct D1 : B1,B2
{
    D1(int i) : B2{i}{}   // 隐式使用B1{}
};

struct D2 : B1,B2
{
    D2(int i){}           // 错误：B2没有默认构造，要求有一个int初始化器
};
 
基类按声明顺序进行初始化，建议按此顺序指定基类的初始化器。 
 基类的初始化在成员之前，销毁在成员之后。
 
 
3.委托构造函数
 
class X
{
    int a;
public:
    X(int x){ if (0<x && x<=max) a=x; else throw Bad_X(x); }
    X() : X{42} {}
    X(string s) : X{to<int>(s)} {}
    // ......
};
 
使用一个成员风格的初始化器，但用的是类自身的名字（也是构造函数名），它会调用另一个构造函数，作为这个构造过程的一部分。 
 如果一个构造函数在初始化列表中委托了其他构造函数，则该函数不能在初始化列表中出现任何成员初始化器
 
 
4.类内初始化器
 
可以在类声明中为非static数据成员指定初始化器：
 
class A
{
public:
    int a{7};
    int b=77;
};
 
{}和=语法能用于类内成员初始化器，但()语法就不行
 
默认情况下，构造函数会使用这种类内初始化器。 
 与上面的代码效果等价如下：
 
class A
{
public:
    int a;
    int b;
    A() : a{7},b{77} {}
};
 
类内初始化器的这种用法可以节省一些输入工作量，但真正的收益是在用于具有多个构造函数的复杂的类时，对同一个成员，多个构造函通常使用相同的初始化器。 
 如果一个成员既被类内初始化器初始化，又被构造函数初始化，则只执行只执行后者的初始化操作
 
 
5.static成员初始化
 
一般来说，static成员声明充当类外定义的声明：
 
class Node
{
    //......
    static int node_count;    // 声明
}

int Node::node_count = 0;     // 定义
 
但是，在少数简单的特殊情况下，在类内声明中初始化static成员也是可能的。条件是static成员必须是整型或枚举类型的const，或字面值类型的constexpr，且初始化器必须是一个常量表达式：
 
class Curious
{
public:
    static const int c1 = 7;        // 正确
    static int c2 = 11;             // 错误：非const
    const int c3 = 13;              // 正确，但非static
    static const int c4 = sqrt(9);  // 错误：类内初始化器不是常量
    static const float c5 = 7.0;    // 错误：类内初始化成员不是整型（应使用constexpr而非const）
}
 
当（且仅当）使用一个已初始化成员的方式要求它像对象一样在内存中存储时，该成员必须在某处（唯一）定义，初始化器不能重复。