Wychodzenie z aplikacji po dodaniu do tablicy klas, klasy zainicjowaniej w innej klasie, kończy się błędem

Witam! Tworzę klasę, która ma pełnić rolę managera. Taka fabryka. klasa posiada std::vector<std::unique_ptr<Object>> object; do którego dodaje obiek zainicjowany w innej klasie.

class Object 
{
public:
	Object(float x, float y) 
	{ 
		this->x = x; 
		this->y = y;
	}
	~Object() {}

float x, y;
};

class Mob 
{
public:
	Mob() 
	{
		mobObject = std::make_unique<Object>(500, 500);
	}
	~Mob() {}

	inline Object* getObject() { return mobObject.get(); }
private:
	std::unique_ptr<Object> mobObject;
};

class Manager 
{
public:
	Manager() {}
	~Manager() 
	{
		for(const auto& o : object) {
			delete o;
		}
		object.clear();
	}

	void AddObject(Object* o) {
		object.push_back(o);
	}
	
	std::vector<Object*> object;
};

int main() 
{
	Manager manager;
	Mob mob;

	manager.AddObject(mob.mobObject);
		
	return 0;
}

Wszystko działa dobrze do momentu gdy wyłączam aplikację. Pojawia się wtedy komunikat

		// MEMBER FUNCTIONS FOR _Container_base12
inline void _Container_base12::_Orphan_all() _NOEXCEPT
	{	// orphan all iterators
 #if _ITERATOR_DEBUG_LEVEL == 2
	if (_Myproxy != 0)
		{	// proxy allocated, drain it
		_Lockit _Lock(_LOCK_DEBUG);

		for (_Iterator_base12 **_Pnext = &_Myproxy->_Myfirstiter;
			*_Pnext != 0; *_Pnext = (*_Pnext)->_Mynextiter)
			(*_Pnext)->_Myproxy = 0;
		_Myproxy->_Myfirstiter = 0;
		}
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
	}

Gdy nie deletuje object w managerze wszystko działa dobrze, tylko zostaje ta luka w pamięci.

Dodatkowo w klasie Object jak chce dodać inną klasę, która jest pointerem to też albo musi być do normalny wskaźnik bez delete, albo wysypie się błąd podczas wyłączania.

W jaki sposób to naprawić?

Po to masz unique_ptr, żebyś nie wołał jawnie delete. Masz coś nie tak z designem. https://dsp.krzaq.cc/post/176/ucze-sie-cxx-kiedy-uzywac-new-i-delete/

Pewnie miało być tak (nadal bezsensu):

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

class Object 
{
public:
    Object(float x, float y) 
    { 
        this->x = x; 
        this->y = y;
    }
    ~Object() {}
 
float x, y;
};

class MobMaker
{
public:
    MobMaker() 
    {}
    ~MobMaker() {}
 
    std::unique_ptr<Object> makeObject() { return std::make_unique<Object>(22, 33); }

private:
};

class Manager 
{
public:
    Manager() {}
    ~Manager() 
    {
        // implementation not needed
    }
 
    void AddObject(std::unique_ptr<Object> object) {
        objects.push_back(std::move(object));
    }
 
    std::vector<std::unique_ptr<Object>> objects;
};

int main() 
{
    Manager manager;
    MobMaker mob;
 
    manager.AddObject(mob.makeObject());
 
    return 0;
}

https://wandbox.org/permlink/Q74p39I5NRFuXIoe