cast list<A*> to list<B*> where B inherits A
c++, casting, containers, stl, templates
Solution
Your intuition (and juanchopanza's comment) is correct - the lists are completely unrelated types.
The options are:
- use `list<A*>` everywhere in the first place, even when you know the dynamic type is `B*` or `C*`
- write a wrapper over `list<A*>` which casts to/from the correct dynamic type - this is equivalent to the (un)boxing behaviour in Java generics
re-write `doSomething` as a function template whose only constraint is that the types be convertible
template <typename Sequence1, typename Sequence2>
void doSomething(Sequence1 &x, Sequence2 &y) {
// require only that *x.begin() is convertible with *y.begin(), etc.
}
I'd also agree with Kerrek's suggestion that this should use iterators instead, but that doesn't change the type requirement significantly - you just get two iterator type params instead of two container type params
Problem
I got a function ``` void doSomething(list<A*> list1, list<A*> list2) ``` And classes ``` class B : A class C : A ``` Is there a direct way to call my function like ``` void doSomething(list<B*> listOfB, list<C*> listOfC) ``` or do I have to wrap it manually like ``` void doSomething(list<B*> listOfB, list<C*> listOfC) { list<A*> l1; list<A*> l2; for (B* b : listOfB) l1.insert(b); for (C* c : listOfC) l2.insert(c); doSomething(l1, l2); //calling the function taking supertype } ``` I tried unsuccessfully to cast `list<B*>` to `list<A*>`, my guess is that due to template specialization, the compiler consider `list<B*>` and `list<A*>` unrelated, however B inherits A. Can someone confirm this, or come with a different way to manage this problem ?