如何防止超出范围复制的对象调用析构函数

Question

So I have this code down there which is a dummy version of my main code and is supposed to create an object stored in a vector. Since the object goes out of scope when the creator function ( spawns() ) ends, calling it's destructor and freeing picture I needed to create instead a shared_ptr inside spawn . And make the vector Entities a vector of shared pointers which goes out of scope only when there aren't any pointers to it anymore. Keeping my precious picture.

Until here no problems. But the teacher asked us to add a save button to our game which records all the objects to a json file using nlohmann's code which makes necessary to store actual values inside the vector Entities ,not pointers which would be useless used in another instance of the program. So I need to know if there is any way to instead of copying a value with push_back to a vector, generate the object already inside it somehow. Or somehow using pointers inside nlohmann's json parser.

#include <iostream>
#include <memory>
#include <vector>

class entity{
    public:
        ~entity();
        int batata=12;
        Texture * picture;
        
};
entity::~entity(){
    delete picture;
    std::cout<<"destroyed"<<std::endl;
}

void spawns(std::vector <shared_ptr<entity>> &Entities){
    std::shared_ptr <entity> ent (new entity);

    Entities.push_back(ent);

}

int main(){

    std::vector <shared_ptr<entity>> Entities;
    
    spawns(Entities);
    std::cout<<Entities[0]->batata<<std::endl;
    return 0;
}

Answer 1

I found a much easier solution that is just initializing my objects after they are already in the vector. But I also learned how to do it the hard way for the sake of learning c++. Basically there are move constructors which are called when you use std::move(a) as suggested by KamilCuk where a is the object which moves the content of 'a' instead of copying it. Though it 'a' has a declared destructor c++ will still call it on the remains of the object variable from which it was moved when it's out of scope. Making it useless for my situation.

So here comes in the ' move constructor ' which runs when you move your object. And where you can change your pointer to nullptr so that nothing happens when the destructor runs and frees it. And in your vector the pointer is available for you. Down there is my code:

#include <iostream>
#include <utility>
#include <memory>
#include <vector>

class entity{
    public:
        int batata=12;
        std::string * picture;
        entity() { }
        ~entity();
entity(entity&& o) noexcept :           //this is the move constructor
           picture(std::move(o.picture))       // explicit move of a member of class type
    {
        o.picture=nullptr;
    }
};

entity::~entity(){//destructor
    std::cout<<"destroyed"<<std::endl;
    delete picture;//frees the pointer
}

void spawns(std::vector <entity> &Entities){//initializes 
    std::string* str=(new std::string);
    (*str)="batata";
    entity ent;
    ent.picture=str;

    Entities.push_back(std::move(ent));

}

int main(){

    std::vector <entity> Entities;

    spawns(Entities);
    std::cout<<*(Entities[0].picture)<<std::endl;

    return 0;
}