钻石问题| Parmeterized构造函数不是祖父级类

Question

有人可以解释下面的多重继承，为什么即使使用参数化构造函数构造车辆类，也不会调用d类的参数化构造函数。

#include<iostream>

using namespace std;

class d{
    public:
    d()
    {
        cout<<"in default constructor of d"<<endl;
    }
    d(int x)
    {
        cout<<"in parametrized constructor of d"<<endl;
    }
    void a()
    {
        cout<<"a function of d";
    }
};
class Vehical:virtual public d
{
    public:
    Vehical(int x):d(x)
    {
     cout<<"In paramterized constructor of Vehical"  <<endl;
    }
    void a()
    {
        cout <<"a function of Vehical class"<<endl;
    }
    Vehical()
    {
     cout<<"default constructor of Vehical"<<endl;   
    }
};
class now: virtual  public d
{
public:
void a()
{
    cout <<"a function of now "<<endl;
}
    now()
{
  cout<<"Default constructor of now" <<endl; 
}
};
class car :public  Vehical, public now
{
    public:
    car();
    car(int y):Vehical(y)
    {

    };
     //using d::a;
       using Vehical::a;

};
int main()
{
 car ob(1);
  ob.a();
 return 0;
}

输出：

in default constructor of d
In paramterized constructor of Vehical
Default constructor of now

期望：它应该调用D的paremterized构造函数而不是默认值，因为我们通过传递参数来构造车辆，这确实调用了D类的参数化构造函数。

另外，如果我们删除一个类的虚拟，我们又有钻石问题吗？为什么这样？

场景1）：如果我们从车辆类中删除虚拟，我们有以下输出

in default constructor of d
in parametrized constructor of d
In paramterized constructor of Vehical
Default constructor of now
a function of Vehical class

同样在上面的输出中为什么首先调用默认构造函数然后再调用d类的参数？还在输出中为什么d的构造函数首先被调用然后是vehicle和现在的类构造函数。

期望：它应该调用d的第一个参数化构造函数然后参数化车辆构造函数然后默认构造函数为d然后默认构造函数

场景2）现在我们从现在的类中删除虚拟，我们有输出，其中调用d的默认构造函数而不是paramterize？

in default constructor of d
In paramterized constructor of Vehical
in default constructor of d
Default constructor of now
a function of Vehical class

期望：它应该为第一行调用D的参数化构造函数而不是默认值。

Answer 1

在可怕的死亡钻石中有两个问题：

1.基类的不变性 - 在引用这个“祖父”类时，应该选择哪个基类的基类。

2.显式调用基类构造函数时，祖父类的构造函数是否使用。想象一下以下示例：

class foo{
    public:
    foo() { }
    foo(int x) {  }
};
class bar : virtual public foo
{
    public:
    using foo::foo;
};
class baz: virtual  public foo
{
public:
    using foo::foo;
};
class clazz :public  bar, public baz
{
public:
    clazz(int i) : bar(i), baz(i+1){}
};

foo的哪个构造函数是编译器应该选择的，因为只创建一个祖父？好吧，任何选择都意味着解决冲突的foo构造函数调用之间的竞争（通过冲突我的意思是不同的参数）。 C ++中的语言设计选择是 - 不要试图解决竞争，只是将程序员初始化祖父类的责任放回去。这是有道理的，因为钻石继承是一个极端情况，可能需要特殊的初始化方法。

你必须在孙子类构造函数中显式调用d构造函数：

#include<iostream>

using namespace std;

class d{
    public:
    d()
    {
        cout<<"in default constructor of d"<<endl;
    }
    d(int x)
    {
        cout<<"in parametrized constructor of d"<<endl;
    }
    void a()
    {
        cout<<"a function of d";
    }
};
class Vehical:virtual public d
{
    public:
    Vehical(int x):d(x)
    {
     cout<<"In paramterized constructor of Vehical"  <<endl;
    }
    void a()
    {
        cout <<"a function of Vehical class"<<endl;
    }
    Vehical()
    {
     cout<<"default constructor of Vehical"<<endl;   
    }
};
class now: virtual  public d
{
public:
void a()
{
    cout <<"a function of now "<<endl;
}
    now()
{
  cout<<"Default constructor of now" <<endl; 
}
};
class car :public  Vehical, public now
{
    public:
    car();
    car(int y):Vehical(y), d(y)
    {

    };
     //using d::a;
       using Vehical::a;

};
int main()
{
 car ob(1);
  ob.a();
 return 0;
}