Unable to store derived class in a vector of pointer of base classes

Question

I have this collection:

vector<unique_ptr<Light>>* lights;

I have many descendants of the Light class, like DirectionalLight, PointLight and so on.

I wish to store all descendants of Light within that lights vector like so:

template<typename T>
unique_ptr<T> CreateLight()
{
    static_assert(std::is_base_of<Light, T>::value, "Type must of descendant of type Light. ");
    unique_ptr<T> light(new T());
    lights->emplace_back(light);
    return light;
}

The reason for this method is that I store my light in a collection for my renderer, which will do its magic to make the lights affect the shaders.

EDIT

These collections are parts of a class named Scene. I need them all the time and I need to have all Light instances on the heap (together with all the other instances the Scene class has). Every frame the Renderer will go through the collection of lights to affect the scene objects' shaders with them. Accessing this vector any given time is of paramount importance.

I still need a reference to my light in the scene though so I can manipulate its properties.

The error message is this:

Severity    Code    Description Project File    Line    Suppression State
Error   C2664   'std::unique_ptr<Light,std::default_delete<_Ty>>::unique_ptr(const std::unique_ptr<_Ty,std::default_delete<_Ty>> &)': cannot convert argument 1 from 'std::unique_ptr<DirectionalLight,std::default_delete<_Ty>>' to 'std::nullptr_t'

This fails during build, not runtime. I, of course, took a look at answers like this one but to no avail.

I require assistance to get this sorted out.

Answer 1

lights->emplace_back(light);

change to:

lights->emplace_back(new T());

Answer 2

I have many descendants of the Light class, like DirectionalLight, PointLight and so on. I wish to store all descendants of Light within that lights vector like so.

Then you simply need, a vector of unique_ptr<Light> rather than the pointer to the vector of unique_ptr<Light>; which is kind of over-engineered way of doing things.

std::vector< std::unique_ptr<Light> > lights;

Then you can handle everything easily.

template<typename T>
void CreateLight()
{
   static_assert(std::is_base_of<Light, T>::value, "Type must of descendant of type Light. ");
   // store to vector directly
   lights.emplace_back( std::make_unique<T>(/*args*/));
}

how do I get the freshly created light instance so I can return it?

As you have the freshly created instance at the last of lights vector, you can directly use it wherever you want. See here

//Either directly
auto iter = lights.rbegin();
if(*iter) std::cout << "Done\n";

 // or
 auto lastElement = std::move(lights.back());
 if(lastElement) std::cout << "Done\n";

Answer 3

You can simply return a reference to a newly created object:

std::vector<std::unique_ptr<Light>>* lights;

template<typename T, typename... Args>
T& CreateLight(Args&&... args)
{
    ...
    auto light = std::make_unique<T>(std::forward<Args>(args)...);
    lights->push_back(std::move(light));
    return *static_cast<T*>(lights->back().get());
}

Edit. After reading JeJo's answer, modified CreateLight so that it accepts any number (including zero) of arguments to construct T.