Question

I have a method

void foo(list<shared_ptr<Base>>& myList); 

Which I’m trying to call with a two different types of lists, one of DerivedClass1 and one of DerivedClass2

list<shared_ptr<DerivedClass1>> myList1; 
foo(myList1);
list<shared_ptr<DerivedClass2>> myList2; 
foo(myList2);

However this obviously generates a compiler error

error: a reference of type "std::list<boost::shared_ptr<Base>, std::allocator<boost::shared_ptr<Base>>> &" (not const-qualified) cannot be initialized with a value of type "std::list<boost::shared_ptr<DerivedClass1>, std::allocator<boost::shared_ptr<DerivedClass1>>>"

Is there any easy way to cast a container of shared_ptr? Of alternate containers that can accomplish this?

Update: Thanks to everyone who responded. Working within the confines of the language, it seems the best way to go while keeping the method ‘as-is’ is to use a container of shared_ptr and pass exactly that in (creating a new list at the call site).

I guess I pretty much already knew this, but I remembered reading about other parts of the boost library dealing with containers of shared_ptr and thought maybe it was solved more elegantly by someone else already. From my own further research however these seem to be geared more towards reducing overhead of shared_ptr in cases where a number of pointers are owned exclusively (therefore requiring a single lock per container rather than one per object in the container).

Thanks again, you guys are all awesome!

Answer 1

You can’t cast a container of one type to a container of another type. There are a few ways to create a new container from an existing container, if the type of object stored by the existing container is convertible to the type of object stored by the new container:

You can use std::copy to do the conversion element-by-element:

list<shared_ptr<Base> > baseList;
list<shared_ptr<Derived> > derivedList;
std::copy(derivedList.begin(), derivedList.end(), std::back_inserter(baseList));

You can also directly construct baseList using the begin and end iterators from derivedList:

list<shared_ptr<Base> > baseList(derivedList.begin(), derivedList.end());

If your function can take a const reference instead, you can construct a temporary in the function call:

typedef list<shared_ptr<Base> > BaseList;
foo(BaseList(derivedList.begin(), derivedList.end()));