cast list<A*> to list<B*> where B inherits A

Question

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 ?

Answer 1

Your intuition (and juanchopanza's comment) is correct - the lists are completely unrelated types.

The options are:

1. use list<A*> everywhere in the first place, even when you know the dynamic type is B* or C*
2. 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

3. 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