Множественное наследование
#include<iostream>
using namespace std;
class A
{
int a;
int b;
public:
void eat()
{
cout<<"A::eat()"<<endl;
}
};
class B: public A
{
public:
void eat()
{
cout<<"B::eat()"<<endl;
}
};
class C: public A
{
public:
void eat()
{
cout<<"C::eat()"<<endl;
}
};
class D: public B, C
{
};
int foo(A *ptr)
{
ptr->eat();
}
main()
{
D obj;
foo(&(obj.B)); //error. How do i call with D's B part.
}
Вышеупомянутый вызов foo - ошибка времени компиляции. Я хочу вызвать foo с частью B obj без использования виртуального наследования. Как мне это сделать.
Кроме того, в случае виртуального наследования, почему информация о смещении должна храниться в vtable. Это можно определить во время самой компиляции. В приведенном выше случае, если мы передаем foo с объектом D, только во время компиляции мы можем вычислить смещение части A.
Выберите код и нажмите кнопку с цифрами 1 и 0.
Поскольку foo не является виртуальным, вы получите тот же результат, вызвав foo с B, C или A частью obj. «A :: eat ()» будет напечатан во всех случаях.
Люк, ты прав; Я забыл добавить это.
class D: public B, C. Вы действительно хотите, чтобы режим видимости класса B был приватным? Отсутствие упоминания приведет к тому, что он будет унаследован в режиме видимости private.
Ответы 4
Используйте приведение - здесь требуется static_cast для построения иерархии.
main()
{
D obj;
foo(static_cast<B*>(&obj));
}
Прежде всего, obj не имеет члена с именем B. Он наследуется от B, что означает, что он наследует все члены B как свои собственные.
Ты можешь вызвать:
foo(static_cast<B*>(&obj));Наследование дважды
С двойным наследованием возникает двусмысленность - компилятор не может знать, какую из двух баз A вы хотите использовать. Если вы хотите иметь две базы A (иногда вы можете захотеть это сделать), вы можете выбрать между ними, приведя к B или C. Наиболее подходящим из приведенных по умолчанию является static_cast (как самый слабый из доступных), однако он на самом деле не требуется (он по-прежнему сильнее, чем требуется в вашем случае), поскольку вы не выполняете приведение к производному типу. Пользовательский шаблон safe_cast должен выполнить эту работу:
/// cast using implicit conversions only
template <class To,class From>
inline To safe_cast( const From &from ) {return from;}
main()
{
D obj;
foo(safe_cast<B *>(&obj)); //error. How do i call with D's B part.
}
Типы времени компиляции - используйте шаблоны
Also, in case of virtual inheritance, why the offset information need to be stored in the vtable. This can be determined at the compile time itself. In the above case, if we pass foo with D's object, at compile time only we can calculate the offset of D's A part.
Это заблуждение. Функция foo в том виде, в котором она написана, теперь не имеет информации о типе компиляции для типа ptr, кроме A *, даже если вы передадите B * или C *. Если вы хотите, чтобы foo мог действовать на основе прошедшего времени компиляции типа, вам нужно использовать шаблоны:
template <class TypeDerivedFromA>
int foo(TypeDerivedFromA *ptr)
{
ptr->eat();
}
Виртуальное наследование
В ваших вопросах упоминается виртуальное наследование. Если вы хотите использовать виртуальное наследование, вам нужно указать так:
class B: public virtual A ...
class C: public virtual A ...
При этом код будет компилироваться, но с этим решением вы не сможете выбрать между B :: A или C :: A (есть только один A), поэтому, вероятно, это не то, о чем вы.
Виртуальные функции
Кроме того, ваши вопросы, похоже, сбивают с толку две разные концепции: виртуальное наследование (что означает совместное использование одного базового класса между двумя промежуточными базовыми классами) и виртуальные функции (что означает разрешение вызова функции производного класса через указатель базового класса). Если вы хотите, чтобы B :: eat вызывалась с использованием указателя A, вы можете сделать это без виртуального наследования (на самом деле виртуальное наследование помешает вам сделать это, как описано выше), используя виртуальные функции:
class A
{
int a;
int b;
public:
virtual void eat()
{
cout<<"A::eat()"<<endl;
}
};
Если виртуальные функции для вас неприемлемы, механизмом компиляции для этого являются шаблоны, как описано выше.
Suma, vtable для виртуальных функций и виртуального наследования одно и то же? Если нет, то что содержит таблица виртуального наследования.
При использовании виртуального наследования структура виртуальной таблицы (и механизм вызова виртуальных функций) несколько сложнее. См. en.wikipedia.org/wiki/Virtual_inheritance - но будьте готовы, это сложная тема, и ее понимание требует усилий и терпения.
Не думаю, что static_cast сработает.
Когда вы используете функцию foo, все, что знает компилятор, - это то, что у вас есть указатель на A, независимо от того, какой тип вы передали в качестве параметра.
Если вы не используете виртуальное наследование, я думаю, что нет способа вызвать функцию B из указателя на A.
Хо я делаю это. В режиме редактирования он отображается правильно.