reinterpret_cast vector of class A to vector of class B

Question

Say I have two classes A and B , and a vector of class A as below:

class A {
    int foo;
    int bar;
    void someMethod();
};
class B {
    uint foo;
    uint bar;
    void someOtherMethod();
};
std::vector<A>  va;

and I want to interpret va as a vector of B, since int and uint are re-interpretable.

What is the best practice to do the re-interpretation? For example, if I want to invoke someOtherMethod() on va , I can do ((std::vector<B> *)(&va))->someOtherMethod() . But is it the best practice?

It seems to me that reinterpret_cast<std::vector<B> >(va).someOtherMethod() does NOT work.

In addition, I am working on C++03.

-- UPDATE --

Sorry for my misinterpret of my own question. Yet my question will be a lot different than this one. So I created another question here .

I will close this question soon: This question can be seen as an independent question, and I think one of the answers below is good enough to be accepted.

Answer 1

Don't. Any way you think you can do it results in undefined behaviour. Create a new vector and copy over the values.

Answer 2

The program behaviour is undefined since the types are unrelated.

One solution is to write a cast operator to copy a class B instance to a class A instance. In class B , write

operator A() const
{
    A a;
    a.foo = this->foo; // ToDo - check `this->foo` is an appropriate size
    a.bar = this->bar; // ToDo - check `this->bar` is an appropriate size
    return a; // compiler will elide the value copy
}

Answer 3

You might be able to get away with making a union type C which can be read as int or uint and making a vector of that instead.

union C {
    int s;
    uint u;
};

std::vector<C> va;

But that won't work if you need to pass it into a method that expects a vector<uint> .

In my opinion the right way to fix this is to make the method that expects a vector into a template so that it can accept any container type. Even better, make it like the STL methods and take an iterator or iterator pair.