множественное наследование: неожиданный результат после отливки от void * до второго базового класса

Question

Моя программа должна использовать void * для переноса данных или объектов в динамическую ситуацию вызова, чтобы она могла ссылаться на данные произвольных типов, даже примитивных типы. Тем не менее, я недавно обнаружил, что процесс сбрасывания этих void * в случае классов с несколькими базовыми классами терпит неудачу и даже сбой моей программы после вызова методов на этих скрытых указателях, даже если адреса памяти кажутся правильными. Авария происходит во время доступа к «vtable».

Таким образом, я создал небольшой тестовый случай, среда GCC 4.2 на Mac OS X:

class Shape { 
public: 
    virtual int w() = 0; 
    virtual int h() = 0; 
}; 

class Square : public Shape { 
public: 
    int l; 
    int w() {return l;} 
    int h() {return l;} 
}; 

class Decorated { 
public: 
    int padding; 
    int w() {return 2*padding;} 
    int h() {return 2*padding;} 
}; 

class DecoratedSquare : public Square, public Decorated { 
public: 
    int w() {return Square::w() + Decorated::w();} 
    int h() {return Square::h() + Decorated::h();} 
}; 


#include <iostream> 

template <class T> T shape_cast(void *vp) { 
// return dynamic_cast<T>(vp); // not possible, no pointer to class type 
// return static_cast<T>(vp); 
// return T(vp); 
// return (T)vp; 
    return reinterpret_cast<T>(vp); 
} 

int main(int argc, char *argv[]) { 
    DecoratedSquare *ds = new DecoratedSquare; 
    ds->l = 20; 
    ds->padding = 5; 
    void *dsvp = ds; 

    std::cout << "Decorated (direct)" << ds->w() << "," << ds->h() << std::endl; 

    std::cout << "Shape " << shape_cast<Shape*>(dsvp)->w() << "," << shape_cast<Shape*>(dsvp)->h() << std::endl; 
    std::cout << "Square " << shape_cast<Square*>(dsvp)->w() << "," << shape_cast<Square*>(dsvp)->h() << std::endl; 
    std::cout << "Decorated (per void*) " << shape_cast<Decorated*>(dsvp)->w() << "," << shape_cast<Decorated*>(dsvp)->h() << std::endl; 
    std::cout << "DecoratedSquare " << shape_cast<DecoratedSquare*>(dsvp)->w() << "," << shape_cast<DecoratedSquare*>(dsvp)->h() << std::endl; 
} 

производит следующий вывод:

Decorated (direct)30,30 
Shape 30,30 
Square 30,30 
Decorated (per void*) 73952,73952 
DecoratedSquare 30,30 

Как вы можете видеть, «декорирован (per void *) "результат совершенно неправильный. Он также должен быть 30,30, как в первой строке.

Независимо от метода литья, который я использую в shape_cast() Я всегда получаю такие же неожиданные результаты для Украшенной части. Что-то совершенно не так с этими пустотами *.

Из моего понимания C++ это должно быть действительно работающим. Есть ли шанс заставить это работать с void *? Может ли это быть ошибкой в ​​gcc?

Благодаря

Answer 1

Это не ошибка компилятора - это то, что reinterpret_cast делает. Объект DecoratedSquare будет выложен в памяти что-то вроде этого:

Square 
Decorated 
DecoratedSquare specific stuff 

Преобразование указателя на это void* будет дать адрес начала этих данных, не зная, какой тип есть. reinterpret_cast<Decorated*> примет этот адрес и интерпретирует все, что есть, как Decorated, - но актуальным объемом памяти являются Square. Это неправильно, поэтому вы получаете неопределенное поведение.

Вы должны получить правильные результаты, если у вас reinterpret_cast, до нужного динамического типа (то есть DecoratedSquare), а затем преобразовать в базовый класс.

Answer 2

static_cast или dynamic_cast в присутствии множественного наследования может изменить представление указателя с зачетом его так, чтобы он назначить правильный адрес. static_cast определяет правильное смещение, рассматривая информацию статического ввода. dynamic_cast делает это, проверяя динамический тип. Если вы перейдете на void *, вы потеряете всю информацию о статическом типе и возможность получать информацию о динамической типизации, поэтому используемый вами reinterpret_cast предполагает, что смещение является нулевым, а не несколько раз.

Answer 3

Повторите десять раз - единственное, что вы можете смело сделать с указателем reinterpret_cast, - это reinterpret_cast обратно к тому же типу указателя, из которого он пришел. То же самое относится и к конверсиям в void*: вы должны преобразовать обратно в исходный тип.

Итак, если вы наложили DecoratedSquare* на void*, вы должны вернуть его обратно на DecoratedSquare*. Не указано Decorated*, а не Square*, а не Shape*. Некоторые из них могут работать на вашей машине, но это сочетание удачи и поведения, характерного для конкретной реализации.Обычно он работает с одним наследованием, потому что нет очевидной причины для реализации указателей объектов таким образом, чтобы это не остановило его работу, но это не гарантировано, и оно не может работать вообще для множественного наследования.

Вы говорите, что ваш код обращается к «произвольным типам, включая примитивные типы» через void *. В этом нет ничего плохого - по-видимому, тот, кто получает данные, знает, как обрабатывать его как DecoratedSquare*, а не как, скажем, int*.

Если кто получает его знает только рассматривать его в качестве базового класса, такие как Decorated*, то тот, кто преобразует его в void* должны static_cast его базового класса, а затем к void*:

void *decorated_vp = static_cast<Decorated*>(ds); 

Теперь, когда вы добавили decorated_vp обратно в Decorated*, вы получите результат static_cast<Decorated*>(ds), который вам нужен.