Inheritance C+中的多重继承和默认值+；

我想使用多重继承在对象实例化时创建一组默认值

这个概念非常简单，它基于子类定义中父类的顺序。在实例化过程中，我希望child将使用子类定义中使用的最后一个父类的默认值来完成

现在我知道我的假设是不正确的，因为输出结果与预期不同。C++编译器返回C285错误：“成员”的模糊访问。 问题：

我是否有机会对编译器说，让它按照我的预期或预期行事

如果没有，还有其他“容易”的机会吗

在我的概念中，我想使用自动分派来生成一个具有一组默认值的对象。在C++实例化中，当子类只有一个父类时，我希望C++编译器自己解决冲突。 在下面的代码中，我期望

ch

值为

n1=3，o1=5

当子类被这样定义时：

class-Child:public-Mother，public-Mother

和

ch

值为

n1=1，o1=1

当Cild类被这样定义时：

class-Child:public-Mother，public-Mother

#include "stdafx.h"
using namespace System;

class Mother
{
    public: int n1=1;
    public: int o1=1;
};

class Father
{
    public: int n1 = 3;
    public: int o1 = 5;
};

class Child : public Mother, public Father
{
    //public: int n1 = 2;
    //public: int o1 = 4;
};

int main(array<System::String ^> ^args)
{
Mother mt = Mother();
Father ft = Father();
Child ch = Child();

Console::WriteLine(L"Mother n1: " + mt.n1);
Console::WriteLine(L"Mother o1: " + mt.o1);
Console::WriteLine(L"Father n1: " + ft.n1);
Console::WriteLine(L"Father o1: " + ft.o1);
Console::WriteLine(L"Child n1: " + ch.n1);
Console::WriteLine(L"Child o1: " + ch.o1);
Console::ReadKey();
return 0;
}

#包括“stdafx.h”
使用名称空间系统；
班主任
{
公共：int n1=1；
公共：INTO1=1；
};
班长
{
公共：int n1=3；
公共：INTO1=5；
};
班级儿童：公共母亲、公共父亲
{
//公共：int n1=2；
//公共：INTO1=4；
};
int main（数组^args）
{
母亲mt=母亲（）；
父ft=父（）；
Child ch=Child（）；
控制台：：写线（L“母亲n1:+mt.n1）；
控制台：：写线（L“o1母亲：”+mt.o1）；
控制台：：写线（L“父n1:+ft.n1）；
控制台：：写线（L“父o1:+ft.o1）；
控制台：：写线（L“Child n1:+ch.n1）；
控制台：：写线（L“Child o1:+ch.o1）；
控制台：：ReadKey（）；
返回0；
}

类中名称的成员查找规则基本上是：要么类具有该名称（在这种情况下，查找停止），要么它的一个基类正好具有该名称。如果多个基类具有相同的名称，则查找会因不明确而失败

在本例中，

Child

没有名为

n1

的成员，但它有两个基类（

Mother

和

Father

）-因此，您所指的

n1

是不明确的

在下面的代码中，我希望ch值为

n1=3

，

o1=5

这里基类的顺序是不相关的。如果您希望实现这一点，您需要明确说明您引入了哪些价值观：

class Child : public Mother, public Father
{
    using Father::n1;
    using Father::o1;
};

---

现在，查找将在

Child

中找到

n1

和

o1

，它们将分别为3和5

类中名称的成员查找规则基本上是：要么类具有该名称（在这种情况下，查找停止），要么它的一个基类具有该名称。如果多个基类具有相同的名称，则查找会因不明确而失败

在本例中，

Child

没有名为

n1

的成员，但它有两个基类（

Mother

和

Father

）-因此，您所指的

n1

是不明确的

在下面的代码中，我希望ch值为

n1=3

，

o1=5

这里基类的顺序是不相关的。如果您希望实现这一点，您需要明确说明您引入了哪些价值观：

class Child : public Mother, public Father
{
    using Father::n1;
    using Father::o1;
};

---

现在，查找将在

Child

中找到

n1

和

o1

，它们将分别为3和5

类中名称的成员查找规则基本上是：要么类具有该名称（在这种情况下，查找停止），要么它的一个基类具有该名称。如果多个基类具有相同的名称，则查找会因不明确而失败

在本例中，

Child

没有名为

n1

的成员，但它有两个基类（

Mother

和

Father

）-因此，您所指的

n1

是不明确的

在下面的代码中，我希望ch值为

n1=3

，

o1=5

这里基类的顺序是不相关的。如果您希望实现这一点，您需要明确说明您引入了哪些价值观：

class Child : public Mother, public Father
{
    using Father::n1;
    using Father::o1;
};

---

现在，查找将在

Child

中找到

n1

和

o1

，它们将分别为3和5

类中名称的成员查找规则基本上是：要么类具有该名称（在这种情况下，查找停止），要么它的一个基类具有该名称。如果多个基类具有相同的名称，则查找会因不明确而失败

在本例中，

Child

没有名为

n1

的成员，但它有两个基类（

Mother

和

Father

）-因此，您所指的

n1

是不明确的

在下面的代码中，我希望ch值为

n1=3

，

o1=5

这里基类的顺序是不相关的。如果您希望实现这一点，您需要明确说明您引入了哪些价值观：

class Child : public Mother, public Father
{
    using Father::n1;
    using Father::o1;
};

---

现在，查找将在

Child

中找到

n1

和

o1

，它们将分别为3和5

您可能应该停止重新声明相同的变量名，从而使先前声明的变量名变得模棱两可或无用。我不知道其他语言是怎么做的，但是C++不是它们。 如果需要“默认”值，只需继承相同的成员变量，但通过构造函数为它们提供不同的值。派生类可以调用基构造函数，以便在构造过程中传回它们自己的值

struct Base
{
    int m_number;

    Base(int n): m_number{n} {} // parameterised ctor for Derived, etc.
    Base(): m_number{42} {} // default ctor
};

struct Derived
{
    Derived(): Base{64} {} // override Base default value
};

Base myBase{}; // m_number == 42
Derived myDerived{}; // m_number == 64

---

诸如此类。

您可能应该停止重新声明相同的变量名，从而使先前声明的变量名变得模棱两可或无用。我不知道怎么做