наследование — c ++ опасный код приведения

Я уверен, что это опасный код. Тем не менее, я хотел проверить, есть ли у кого-нибудь идея какие точно пойдет не так.

Предположим, у меня есть структура этого класса:

class A {
protected:
int a;
public:
A() { a = 0; }
int getA() { return a; }
void setA(int v) { a = v; }
};

class B: public A {
protected:
int b;
public:
B() { b = 0; }
};

И затем предположим, что я хочу иметь способ автоматического расширения класса следующим образом:

class Base {
public:
virtual ~Base() {}
};

template <typename T>
class Test: public T, public Base {};

Один действительно важная гарантия того, что я не могу дать Base ни Test будет иметь любые другие переменные-члены или методы. Это по сути пустые классы.

(Потенциально) опасный код ниже:

int main() {
B *b = new B();

// dangerous part?
// forcing Test<B> to point to to an address of type B
Test<B> *test = static_cast<Test<B> *>(b);

//
A *a = dynamic_cast<A *>(test);
a->setA(10);
std::cout << "result: " << a->getA() << std::endl;
}

Обоснование для того, чтобы сделать что-то вроде этого, заключается в том, что я использую класс, похожий на Test, но для того, чтобы он работал в настоящее время, обязательно нужно создать новый экземпляр T (т.е. Test), а также скопировать переданный экземпляр. Было бы здорово, если бы я мог просто указать Test на адрес памяти T.

Если бы Base не добавил виртуальный деструктор, а так как Test ничего не добавил, я бы подумал, что этот код на самом деле в порядке. Однако добавление виртуального деструктора заставляет меня беспокоиться, что информация о типе может быть добавлена ​​в класс. Если это так, то это может привести к нарушениям доступа к памяти.

Наконец, я могу сказать, что этот код отлично работает на моем компьютере / компиляторе (clang), хотя это, конечно, не является гарантией того, что он не делает плохих вещей с памятью и / или не потерпит неудачу на другом компиляторе / машине.