C++ Vector of shared_ptr of child to vector of shared_ptr to base

I have this class

class GameObjectTemplateModel : public DatabaseModel<GameObjectTemplate, WorldDatabaseConnection, GameObjectTemplateModel>

And I have this:

std::vector<std::shared_ptr<DatabaseModel>>  ManyWhere(const std::string& column, const std::string& where);

and this:

std::vector<std::shared_ptr<GameObjectTemplateModel>> LootableCollection;

Why I can not do:

LootableCollection = ManyWhere("test","test");

My question is how can I make the vector of child shared_ptrs to get it's data from vector of base shared ptr?

Is it good idea if I use dynamic_cast ?

> My question is how can I make the vector of child shared_ptrs to get it's data from vector of base shared ptr?

You need to have something that will convert each pointer in turn. In C++23 that can be a view like std::ranges::to<std::vector>.

LootableCollection = ManyWhere("test","test") | std::ranges::to<std::vector>;

Prior to that you could use the iterator assignment (with a helper variable)

auto collection = ManyWhere("test","test");
LootableCollection.assign(collection.begin(), collection.end());

> Is it good idea if I use dynamic_cast ?

No. Using a pointer gotten via dynamic_cast is undefined behaviour in almost all cases, and this isn't one of the exceptions.

The type std::vector<std::shared_ptr<GameObjectTemplateModel>> is not related to the type std::vector<std::shared_ptr<DatabaseModel>> at all, despite the types GameObjectTemplateModel and DatabaseModel being related.

The problem here is that even though there may be a way of converting between element types of the vectors, this doesn't establish a relationship between the vector types and the assigment operators/constructors necessary for the assignment/initialization to work do not exist.

You need to provide your own conversion for this. Depending on whether you're sure the types of the elements are ok or not, you should be using std::static_pointer_cast or std::dynamic_pointer_cast for the element conversions:

The following example uses Base as base class and Derived as derived class for simplicity and assumes all elements of the std::vector<std::shared_ptr<Base>> actually reference Deriveds.

struct Base
{
    virtual ~Base() = default;
};

struct Derived : Base
{
};

template<class T, class U>
std::vector<std::shared_ptr<T>> ConvertSharedPointerVector(std::vector<std::shared_ptr<U>>&& from)
{
    std::vector<std::shared_ptr<T>> to;
    to.reserve(from.size());

    for (auto& e : from)
    {
        to.emplace_back(std::static_pointer_cast<T>(std::move(e)));
    }

    return to;
}

std::vector<std::shared_ptr<Base>> Create()
{
    return { std::make_shared<Derived>(), std::make_shared<Derived>() };
}

int main()
{
    std::vector<std::shared_ptr<Derived>> convertedVector = ConvertSharedPointerVector<Derived>(Create());
}

Note: You're likely better of avoiding this kind of conversion. You may be able to use templates for this.