C++ не может преобразовать базу A в производный тип B через виртуальную базу A.

Чтобы понять систему приведения, вам нужно погрузиться в объектную модель.

Классическим представлением простой иерархической модели является включение: если B происходит от A, то объект B фактически будет содержать подобъект A наряду со своими собственными атрибутами.

В этой модели понижение приведения представляет собой простую манипуляцию указателем со смещением, известным во время компиляции, которое зависит от схемы памяти B.

Это то, что делает static_cast: статическое приведение называется статическим, потому что вычисление того, что необходимо для приведения, выполняется во время компиляции, будь то арифметика указателя или преобразования (*).

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

Следовательно, во время компиляции невозможно вывести необходимую арифметику указателя: это зависит от типа объекта во время выполнения.

Всякий раз, когда есть зависимость от типа среды выполнения, вам нужна RTTI (информация о типе среды выполнения), а использование RTTI для приведения — это задача dynamic_cast.

В итоге:

• понижение времени компиляции: static_cast
• пониженное время выполнения: dynamic_cast

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

(*) Как заметил @curiousguy в комментариях, это справедливо только для понижения. static_cast позволяет повышать приведение независимо от виртуального или простого наследования, хотя в этом случае приведение также не требуется.

Насколько я знаю, вам нужно использовать dynamic_cast, потому что наследование virtual и вы понижаете.

Вы не можете использовать static_cast в этой ситуации, потому что компилятор не знает смещения B относительно A во время компиляции. Смещение должно вычисляться во время выполнения на основе точного типа самого производного объекта. Поэтому вы должны использовать dynamic_cast.

Да, вам нужно использовать dynamic_cast, но вам нужно будет сделать базовый класс A полиморфным, например. добавив виртуальный dtor.

Согласно стандартным документам,

Раздел 5.2.9–9, для Статической трансляции,

Значение r типа «указатель на cv1 B», где B — тип класса, может быть преобразовано в значение r типа «указатель на cv2 D», где D — класс, производный (раздел 10) от B, если действующий стандарт существует преобразование из «указателя на D» в «указатель на B» (4.10), cv2 — это та же cv-квалификация, что и cv1, или более высокая cv-квалификация, чем cv1, и B не является ни виртуальным базовым классом D, ни базовый класс виртуального базового класса D.

Следовательно, это невозможно, и вы должны использовать dynamic_cast...

$5.2.9/2- «Выражение e может быть явно преобразовано в тип T с использованием static_cast формы static_cast(e), если объявление «T t(e);» корректно для некоторой выдуманной временной переменной t (8.5)».

В вашем коде вы пытаетесь использовать static_cast с «T = B*» и «e = A*»

Теперь «B * t (A *)» неправильно сформирован в C ++ (но «A * t (B *)» потому, что «A» является виртуальной однозначной и доступной базой «B». Поэтому код дает ошибку .

Не знаю, "безопасно" ли это, но.

Предполагая

B получен из A (и A чисто виртуальный)

Поскольку я ЗНАЮ, что указатель на B все еще остается указателем на B.

    class A
    {
            virtual void doSomething(const void* p) const =0;
    };

    class B
    {
    public:
            int value;
            virtual void doSomething(const void*p)const
            {
            const B * other = reinterpret_cast<const B*>(p);
            cout<<"hello!"<< other->value <<endl;
            }
    };

    int main()
    {
            B  foo(1),bar(2);
            A * p = &foo, q=&bar;
            p->doSomething(q);
            return 0;
    }

эта программа выполняется и корректно возвращает вывод "hello!" и значение другого объекта (в данном случае «2»).

кстати, то, что я делаю, очень небезопасно (лично я даю разные идентификаторы каждому классу и утверждаю после переинтерпретации приведения, что текущий идентификатор равен другому идентификатору, чтобы быть уверенным, что мы делаем что-то с двумя одинаковыми классами) и как видите ли, я ограничился "константными" методами. Таким образом, это будет работать с "неконстантными" методами, но если вы сделаете что-то не так, отлов ошибки будет практически невозможен. И даже с утверждением есть 1 шанс из 4 миллиардов добиться успеха утверждения, даже если оно должно потерпеть неудачу (assert(ID== other->ID);)

Между прочим... Хороший объектно-ориентированный дизайн не должен требовать такого рода вещей, но в моем случае я попытался реорганизовать/перепроектировать код, не имея возможности отказаться от повторного приведения. вообще говоря, вы МОЖЕТЕ избежать такого рода вещей.