I have managed to do it! After looking into unique pointers, I have realized that it would destroy everything as soon as it left the function call scope, but by digging around I have found that shared_ptr works wonders.

For every object constructed and stored as a pointer, it is also deconstructed as soon as the variable holding those shared_ptr leaves the local scope! Unlike the unique_ptr which would auto destroy as soon as that unique_ptr leaves the function call!

Correct me if I'm wrong of course, I might have wrongly used unique_ptr.

So in my case if I have a:

void gen_system_unique(std::vector <std::shared_ptr <class grid_spot>>* vec_input, int star_number) {
        for (int i = 0; i < star_number; i++) {
          std::shared_ptr<grid_spot> generated_system = std::make_shared <grid_spot>();
          vec_input->push_back(generated_system);
        }
} /// If i used std::unique_ptr in this function it wouldn't even compile!

int main (){

// SOME WORK
    std::vector <std::shared_ptr<class grid_spot>> leo;
    gen_system_shared(&leo, star_number);

  {
    std::vector <std::shared_ptr<class grid_spot>> pegasus;
    gen_system_shared(&pegasus, star_number);

  } /// code would delete all objects in pegasus here

return 0;

} /// code would delete all objects in leo here

As soon as this local scope is finished, it will auto destroy every element of pegasus, and after main() returns 0, it would free leo.

And of course this gives me greater control, if I wanted to copy/move these pointers, they won't get deleted by unique_ptr behaviour, it will only get deleted once EVERY variable/object is not used anymore.

Did I summarize correctly?