How to manage vector of pointers in C++ where pointer is allocated by Lua

Question

In the simple 2D Game Engine I am working. I want to define and script my entities using Lua and do all the heavy work in C++ (rendering, physics, etc.)

To do this I have basic Entity class:

class Entity {
    public:
        Entity() {
            alive = true;
            livingCount++;
        }

        void destroy() {
            alive = false;
        }

        bool isAlive() { return alive; }

        ~Entity(){
            // Gets called if I manually call delete entity in EntityManager or if I use smart pointers, but causes seg faults in either case
            std::cout << "Entity destructor called." << std::endl;
            livingCount--;
        }
    private:
        bool alive;
};

And the EntityManager singleton which groups all active Entities and is used in main game loop to refresh, update and render entities in this order, here is the EntityManager class:

class EntityManager {
        public:
            static EntityManager* Instance() {
                if(s_pInstance == 0) {
                    s_pInstance = new EntityManager();
                    return s_pInstance;
                }
                return s_pInstance;
            }
            // Main game loop goes through these and calls refresh(), then update() and finally render() on each frame
            void update(float deltaTime) {
                for (auto& e: entities)
                    e->update(deltaTime);
            }

            void render(float deltaTime) {
                for (auto& e: entities)
                    e->draw(deltaTime);

            }
            // This method causes segfault after entity gets destroyed, it doesn't matter if I use raw pointers or smart, I am still getting segfault here
            void refresh() {
                for (auto& e: entities) {
                    if (!e->isAlive()) {
                        entities.erase(std::remove(entities.begin(), entities.end(), e), entities.end());
                        // Uncommenting this also causes segfault, but if this is commented, Entity* is not freed from the memory, only gets removed from vector                        
                        // delete e;

                    }
                }
                // Tried doing the same using shared_ptr or even unique_ptr, but every time entity is destroyed this causes segfault as well
                // entities.erase(std::remove_if(std::begin(entities), std::end(entities),
                //     [](std::shared_ptr<Entity> &e) {
                //         return !e->isAlive();
                //     }),
                //     std::end(entities));
            }

            // Add new entity
            // This will become legacy, I am only using this to create entities in C++, but soon they will only be created by Lua and passed to this class
            Entity* addEntity() {
                Entity* entity = new Entity();
                entities.push_back(entity);
                return entity;
            }

            // Add existing entity: for lua
            // I have a feeling this method is not correct
            void addEntity(Entity* entity) {
                entities.push_back(entity);
            }

            const std::vector<Entity*>& getEntities() { return entities; }

        private:
            EntityManager() {}

            static EntityManager* s_pInstance;
            // Probably should use std::shared_ptr<Entity> instead
            // I tried this on Ubuntu and it does seem to solve memory problem and entities get deleted
            // but also getting segfault on Linux and I'm not sure if it's because of this class or
            // my use of unique pointers
            std::vector<Entity*> entities;
    };

Now everytime I want to create new Entity, I can do this from Lua script, because I have implemented __index and __gc metamethods for Entity, so this works perfectly:

testEntity = Entity.create()
testEntity:move(400, 400)
testEntity:scale(2, 2)
testEntity:addSprite("slime", "assets/sprite/slime.png", 32, 32)
testEntity:addAnimation("default", "0", "4")
testEntity:addCollider("enemy", 48, 48)
print("Slime ID: "..testEntity:id())

And finally, this is Lua binder for then we want to create new entity, notice how I pass pointer to EntityManager as well, because otherwise game will not update it:

 int Script::lua_createEntity(lua_State *L) {
    Entity* entity = (Entity*)lua_newuserdata(L, sizeof(Entity));
    // Placement new operator takes already allocated memory and calls constructor
    new (entity) Entity();
    // This Entity created in here must be added to EntityManager vector so that game knows about it
    EntityManager::Instance()->addEntity(entity);

    luaL_getmetatable(L, "EntityMetaTable");
    lua_setmetatable(L, -2);
    return 1;
}

And this method is bound to __gc metatable, but does not seem to get called at all, I'm not even sure if I want Lua to take care of this:

// Will be called once lua state is closed
int Script::lua_destroyEntity(lua_State *L) {
    Entity* entity = (Entity*)lua_touserdata(L, -1);
    std::cout << "Lua __gc for Entity called" << std::endl;
    entity->destroy();
    return 0;
}

Now, let's say I have an Entity which is also a Projectile, every time Projectile goes off screen, I call entity->destroy() on that Projectile and it's member "isAlive" is marked as "false". This is all done in C++, but projectile gets created by Lua script

So on the next frame, EntityManager refresh() method is invoked and that projectile gets removed correctly from the Vector, but if I try to delete it then to free the memory, it causes segfault, otherwise destructor never gets called.

As I said before, I have tried std::vectorstd::unique_ptr<Entity> and std::vectorstd::shared_ptr<Entity>, but that also causes segfault in EntityManager refresh method, which makes me think something fundamentally is wrong with how I am dealing with Entity lifetime.

__gc metamethod might not even be needed for me, as I want EntityManager to take care of all active Entities in the game, Lua will only be able to tell it which entity have been marked as destroyed and let C++ take care of deleting it.