Dynamic cast, list of objects conversion, templates

Question

There are 2 classes:

class A
{
   private:
        double a1, a2;
   ...
};

class B : public A
{
   private:
        double b1, b2;
};

and a generic container

template <typename Item>
struct TList
{
    typedef std::vector <Item> Type;
};


template <typename Item>
class GList
{
private:
            typename TList <Item>::Type items;

} ;

There 4 containers of objects

GList <A> A1;
GList <B> B1;
GList <A*> A2;
GList <B*> B2;

Are those conversions (up/down) allowed or not:

1] GList <B> B3 = dynamic_cast <GList <B> &> (A1);
2] GList <A> A3 = static_cast <GList <A> &> (B1);
3] GList <B*> B4 = dynamic_cast <GList <B*> &> (A2);
4] GList <A*> A4 = static_cast <GList <A*> &> (B2);

Is there any way how to convert list of objects to list of parent objects and vice versa?

Updated question

And what about reinterpret_cast?

1] GList <B> B3 = reinterpret_cast <GList <B> &> (A1);
2] GList <A> A3 = reinterpret_cast <GList <A> &> (B1);
3] GList <B*> B4 = reinterpret_cast <GList <B*> &> (A2);
4] GList <A*> A4 = reinterpret_cast <GList <A*> &> (B2);

Answer 1

GList <B> B3 = dynamic_cast <GList <B> &> (A1);

dynamic_cast works with only polymorphic type. Here GList is not polymorphic. Hence it would not even compile!

If you make this polymorphic, even then this cast wouldn't work, since there is no relationship between GList<B> and <GList<A>. They're like two different unrelated types.

In fact, they're related in the same way as GList_B and GList_A are related (suppose, if you define two different classes with such names). Or even better, they're related in the same way as Java and JavaScript, Car and Carpet are related.

Answer 2

Fundamentally, containers are not covariant; there is no relationship between std::vector<Base> and std::vector<Derived> (nor between std::vector<Base *> and std::vector<Derived *>.

In the case of the value-type containers, there's the fundamental problem that typically, sizeof(Derived) > sizeof(Base). So all the internal pointer maths in std::vector will break horribly if you try to coerce one to the other.

In the case of the pointer-type containers, these conversion may "work" (if you can get them to compile), but the behaviour is undefined.

Answer 3

No, there are no valid conversions between containers of types, regardless of whether there are valid conversions between the types themselves.

Answer 4

dynamic_cast and static_cast work if the objects have a relationship (like A and B).

But a template create a completely new class, there's no way to use these casts. Maybe you can try reinterpret_cast, but it's not safe...

Answer 5

You cannot convert a list of objects to a list of parent objects. If you could, then i could do this :

GList<A>& a = convert_the_thing(B1);
a.add_a_element(A());

and i would have inserted a A into your list of B.