Защо static_cast не може да се използва за прехвърляне надолу, когато е включено виртуално наследяване?

Техническият проблем е, че няма начин да се разбере от Base* какво е отместването между началото на подобекта Base и началото на обекта Derived.

Във вашия пример изглежда добре, защото има само един клас в полезрението с база Base и затова изглежда без значение, че наследяването е виртуално. Но компилаторът не знае дали някой е дефинирал друг class Derived2 : public virtual Base, public Derived {} и прехвърля Base*, сочещ към Base подобекта на това. Като цяло [*] отместването между подобекта Base и подобекта Derived в рамките на Derived2 може да не е същото като отместването между подобекта Base и пълния обект Derived на обект, чийто най-изведен тип е Derived, точно защото Base е практически наследени.

Така че няма начин да разберете динамичния тип на пълния обект и различните отмествания между указателя, който сте дали на каста, и необходимия резултат, в зависимост от това какъв е този динамичен тип. Следователно актьорският състав е невъзможен.

Вашият Base няма виртуални функции и следователно няма RTTI, така че със сигурност няма начин да разберете типа на целия обект. Актьорският състав все още е забранен, дори ако Base има RTTI (не знам веднага защо), но предполагам, че без проверка е възможен dynamic_cast в този случай.

[*] с което имам предвид, че ако този пример не докаже мисълта, продължете да добавяте повече виртуално наследяване, докато не намерите случай, в който отместванията са различни ;-)

static_cast може да изпълнява само тези прехвърляния, при които разположението на паметта между класовете е известно по време на компилиране. dynamic_cast може да проверява информация по време на изпълнение, което позволява по-прецизна проверка за коректност на предаването, както и да чете информация по време на изпълнение относно оформлението на паметта.

Виртуалното наследяване поставя информация за времето на изпълнение във всеки обект, която указва какво е оформлението на паметта между Base и Derived. Един след друг ли е или има допълнителна празнина? Тъй като static_cast няма достъп до такава информация, компилаторът ще действа консервативно и просто ще даде грешка на компилатора.

По-подробно:

Помислете за сложна структура на наследяване, където - поради множествено наследяване - има множество копия на Base. Най-типичният сценарий е диамантено наследство:

class Base {...};
class Left : public Base {...};
class Right : public Base {...};
class Bottom : public Left, public Right {...};

В този сценарий Bottom се състои от Left и Right, където всеки има собствено копие на Base. Структурата на паметта на всички горепосочени класове е известна по време на компилиране и static_cast може да се използва без проблем.

Нека сега разгледаме подобна структура, но с виртуално наследяване на Base:

class Base {...};
class Left : public virtual Base {...};
class Right : public virtual Base {...};
class Bottom : public Left, public Right {...};

Използването на виртуалното наследяване гарантира, че когато Bottom е създадено, то съдържа само едно копие на Base, което е споделено между частите на обекта Left и Right. Оформлението на обект Bottom може да бъде например:

Base part
Left part
Right part
Bottom part

Сега помислете, че сте задали Bottom на Right (това е валидно замяна). Получавате Right указател към обект, който е на две части: Base и Right имат празнина в паметта между тях, съдържаща (сега неуместната) Left част. Информацията за тази празнина се съхранява по време на изпълнение в скрито поле на Right (обикновено наричано vbase_offset). Можете да прочетете подробностите например тук.

Пропускът обаче няма да съществува, ако просто създадете самостоятелен Right обект.

Така че, ако ви дам само указател към Right, вие не знаете по време на компилиране дали е самостоятелен обект или част от нещо по-голямо (напр. Bottom). Трябва да проверите информацията по време на изпълнение, за да прехвърляте правилно от Right към Base. Ето защо static_cast ще се провали, а dynamic_cast няма.

Забележка относно dynamic_cast:

Докато static_cast не използва информация за обекта по време на изпълнение, dynamic_cast го използва и изисква той да съществува! По този начин последното преобразуване може да се използва само в тези класове, които съдържат поне една виртуална функция (напр. виртуален деструктор)

Разгледайте следната функция foo:

#include <iostream>

struct A
{
    int Ax;
};

struct B : virtual A
{
    int Bx;
};

struct C : B, virtual A
{
    int Cx;
};


void foo( const B& b )
{
    const B* pb = &b;
    const A* pa = &b;

    std::cout << (void*)pb << ", " << (void*)pa << "\n";

    const char* ca = reinterpret_cast<const char*>(pa);
    const char* cb = reinterpret_cast<const char*>(pb);

    std::cout << "diff " << (cb-ca) << "\n";
}

int main(int argc, const char *argv[])
{
    C c;
    foo(c);

    B b;
    foo(b);
}

Въпреки че не е наистина преносима, тази функция ни показва "отместването" на A и B. Тъй като компилаторът може да бъде доста либерален при поставянето на подобект A в случай на наследяване (също така не забравяйте, че най-производният обект извиква виртуалния базов ctor!), реалното разположение зависи от "реалния" тип на обекта. Но тъй като foo получава само реф към B, всяко static_cast (което работи по време на компилиране, като най-много прилага някакво отместване) е обвързано с неуспех.

ideone.com (http://ideone.com/2qzQu) извежда за това:

0xbfa64ab4, 0xbfa64ac0
diff -12
0xbfa64ac4, 0xbfa64acc
diff -8

По принцип няма истинска причина, но намерението е static_cast да бъде много евтино, включващо най-много добавяне или изваждане на константа към указателя. И няма начин да внедрите актьорския състав, който искате, толкова евтино; основно, тъй като относителните позиции на Derived и Base в рамките на обекта могат да се променят, ако има допълнително наследяване, преобразуването ще изисква голяма част от режийните разходи на dynamic_cast; членовете на комисията вероятно са смятали, че това отменя причините за използването на static_cast вместо dynamic_cast.

static_cast е конструкция по време на компилация. той проверява валидността на cast по време на компилиране и дава грешка при компилация, ако е невалидно cast.

virtualism е явление по време на изпълнение.

И двете не могат да вървят заедно.

C++03 Standard §5.2.9/2 и §5.2.9/9 са подходящи в този случай.

Rvalue от тип „указател към cv1 B“, където B е тип клас, може да се преобразува в rvalue от тип „указател към cv2 D“, където D е клас, получен (клауза 10) от B, ако валиден стандарт съществува преобразуване от „указател към D“ в „указател към B“ (4.10), cv2 е същата cv-квалификация като, или по-голяма cv-квалификация от cv1, и B не е виртуален базов клас на D< /силен>. Стойността на нулевия указател (4.10) се преобразува в стойността на нулевия указател на типа дестинация. Ако rvalue от тип „указател към cv1 B“ сочи към B, което всъщност е под-обект на обект от тип D, полученият указател сочи към обхващащия обект от тип D. В противен случай резултатът от преобразуването е недефиниран .