Блог

У меня есть базовый класс A, 2 дочерних класса B и C, которые оба наследуются от A, и у меня есть класс D, который наследуется как от B, так и от C, в котором я хочу взять _a из B и _b из C без необходимости выполнять виртуальный метод для print_a и print_b, если это возможно

 # include <iostream>

class A
{
    public:

    A(void) : { }
    ~A(void) { }

    inline void print_a(void) { std::cout << _a << std::endl; }
    inline void print_b(void) { std::cout << _b << std::endl; }


    protected:

    int _a;
    int _b;
};

class B : virtual A
{
    public:

    B(int a) : A() { _a = a, _b = 0; }
    ~B(void) { }

    protected:

    using A::_a;
    using A::_b;
};

class C : virtual A
{
    public:

    C(int b) : A() { _a = 0, _b = b; }
    ~C(void) { }

    protected:

    using A::_a;
    using A::_b;
};

class D : virtual public A, private B, private C
{
    public:

    D(void) : A(), B(5), C(5) { }
    ~D(void) { }


    private:

    using B::_a;
    using C::_b;
};

int main(void)
{
    D foo;

    foo.print_a();
    foo.print_b();
    return (0);
}
 

Мой общий класс наследует методы print_a и print_b от A, и я хочу, чтобы он наследовал _a = 5 от B и _b = 5 от C, но он не работает, он выводит:

 0
5
 

Вместо:

 5
5
 

Поскольку вы используете virtual для всех базовых классов, в итоге у вас D будет только один A (а не один как базовый D , один как базовый B и один как базовый C ).

Проблема в ваших конструкторах.

Конструктор производного класса вызывает конструкторы всех базовых классов в том порядке, в котором они указаны в списке базовых классов, поэтому в вашем случае D::D вызывает:

 A::A() -> _a and _b uninitialized
B::B(5)
  _a = 5
  _b = 0
C::C(5)
  _a = 0
  _b = 5
 

Непонятно, почему вы устанавливаете _a and _b несколько раз в разных конструкторах. Было бы лучше инициализировать элементы в списке инициализаторов элементов конструктора, а не назначать его в теле конструктора. Вы могли бы, например, написать

 A(int a, int b) : _a(a), _b(b) {}
B(int a) : A(a, 0) {}
C(int b) : A(0, b) {}
D() : A(5, 5), B(5), C(5) {}
 

Это D::D() приведет к

 A(5, 5) -> _a initialized to 5, _b initialized to 5
B(5) -> no effect (on A/_a/_b)
C(5) -> no effect (on A/_a/_b)
 

Если вы хотите придерживаться своего дизайна и инициализировать переменные в телах конструктора, вы можете просто добавить код D::D , чтобы перезаписать все, что задают конструкторы базового класса:

 D() : A(), B(5), C(5) { _a=5; _b=5; }