Участник виртуального базового класса

Question

Я знаю, что этот код не будет работать, и я также знаю, почему, но есть ли альтернатива?

class A 
{ 
public: 
    A(void){} 
    virtual ~A(void){} 
protected: 
    A* parent; 
    int a; 
}; 

class B : public virtual A 
{ 
public: 
    B(void){} 
    virtual ~B(void){} 
protected: 
    void f(){ ((B*)parent)->a; } 
}; 

Это не представляется возможным бросить parent к B*, поскольку A является виртуальным базовым классом. Не литье parent также дает ошибку. Надеюсь, мне не нужно публиковать всех участников. У кого-то есть идея, как получить доступ к A :: a?

Редактировать

Использование друзей не работает, так как классы, полученные из B не имеют доступа к A::a.

Answer 1

class B : public virtual A 
{ 
public: 
    B(void){} 
    virtual ~B(void){} 
protected: 
    void f(){ this->a; } 
}; 

Вы можете получить доступ к защищенному члену из родительского класса (материнский класс B).

Answer 2

Ответ на мой комментарий выше, потому что я тестировал его, и он компилируется отлично.

без броска, он, вероятно, не удается, потому что вы пытаетесь получить доступ к защищенному поле A в B. Можно просто добавить публичный геттер и удалить бросок к B *

class A 
{ 
public: 
    A(void){} 
    virtual ~A(void){} 
    int getA() { return a; } 
protected: 
    A* parent; 
    int a; 
}; 

class B : public virtual A 
{ 
public: 
    B(void){} 
    virtual ~B(void){} 
protected: 
    void f(){ (parent)->getA(); } 
}; 

Answer 3

Некоторые варианты:

1. Сделать a общественного
2. Создание/геттер общественности сеттера для a -
3. марка B друг класса А (или просто функция f())

3-й вариант его работы лучше, чем другие 2, если вы хотите разрешить только A (или функция), чтобы иметь доступ к членам от A. С другой стороны, с другими 2 вариантами вы можете сделать только этого участника публичным (но он будет общедоступным для всех)

Answer 4

Я думаю, что проблема здесь заключается не столько в том, как получить доступ к элементу a, но зачем вам нужен дерева бриллиантов в вашем дизайне. Сначала вы должны отступить и оценить, действительно ли вам нужно дерево бриллиантов.

Если вы сделать, то вместо ваш текущий подход, обеспечивает A с хорошим соответствующим (общественным) абстрактным интерфейсом, который может быть вызван из B. Когда вы начинаете напрямую обращаться к родительским защищенным атрибутам, вы плотно соединяете компоненты, что позволяет легко разбить ваш код и сделать его очень сложным для изменения дизайна позже в течение срока действия приложения.

Answer 5

Это работает:

class A { 
public: 
    A(void){} 
    virtual ~A(void){} 
protected: 
    A* parent; 
    int a; 
    int parent_a(){ return parent->a;} 
}; 

class B : public virtual A 
{ 
public: 
    B(void){} 
    virtual ~B(void){} 
protected: 
    void f(){ A::parent_a(); } 
}; 

Обратите внимание, что:

• a не получить воздействие внешнего мира,
• извлеченного a необходимо правильный, поскольку B наследует практически от A, поэтому успешный динамический бросок parent до B перед тем, как получить его a fie ld должен возвращать то же самое, что и предлагаемое выше решение.

Почему выполняет эту работу?

Потому что класс является неявным другом самого себя.

Answer 6

Это то, что dynamic_cast для. Если вы не хотите, чтобы перестроить свой код, просто замените бросок C-стиле с dynamic_cast:

void f() { dynamic_cast<B*>(parent)->a; } 

Для этого, чтобы правильно работать, A должны иметь по крайней мере одну виртуальную функцию (как это делает). Кроме того, литой будет вызывать нулевой указатель, если parent не указывает на объект типа B.

Answer 7

Спасибо всем, некоторые полезные возможности были упомянуты, как использование друзей и создание дополнительных функций для каждой переменной. Это может работать в некоторых сценариях, но не в моем случае. Добавление каждого производного класса в качестве друга имеет проблему, заключающуюся в том, что он делает библиотеку менее удобной для пользователей, когда они хотят добавить класс. Добавление функций для каждой переменной добавит более ста дополнительных функций для некоторых классов.

То, что я сделал в качестве своего окончательного решения, заключалось в создании копии вместо трансляции. Хотя он будет работать немного медленнее, код останется чистым. Чтобы противостоять проблеме скорости. Доступ к локальным переменным намного быстрее, чем доступ к глобальным переменным.

Вот как это выглядит сейчас:

class A 
{ 
public: 
    A* parent; 
    virtual ~A(void){} 
    virtual A & operator = (const A & x) 
    { 
     a = x.a; 
     parent = x.parent; 
     return *this; 
    } 
protected: 
    int a; 
}; 

class B : public virtual A 
{ 
public: 
    B(void){} 
    virtual ~B(void){} 
    using A::operator =; 
    virtual B & operator = (const B & x) 
    { 
     A::operator = (x); 
     return *this; 
    } 
    void f(void) 
    { 
     B p; 
     p = *parent; 
     int x = p.a;//Allowed. 
    } 
}; 

Если у вас есть лучшее решение, пожалуйста, бесплатный почтовый его.