how to reuse the same instance of a class

// Provided as is without warranty. Untested.
template <typename T>
class ObjectPool
{
public:
    ObjectPool(size_t max_size=100)
        : m_MaxSize(max_size)
    {}
    ~ObjectPool()
    {
        // We do not optimize here, keeping the code readable is more important
        // as we are creating and deleting an object pool rarely...
        SetMaxPoolSize(0);
    }
    void SetMaxPoolSize(size_t size)
    {
        m_MaxSize = size;
        size_t current_size = m_Objects.size();
        if (current_size > size)
        {
            for (size_t i=size; i<current_size; ++i)
                delete m_Objects[i];
            m_Objects.resize(size);
        }
    }
    T* AcquireObject()
    {
        if (m_Objects.empty())
            return new T;
        T* obj = m_Objects.back();
        m_Objects.pop_back();
        return obj;
    }
    void ReleaseObject(T* obj)
    {
        if (m_Objects.size() < m_MaxSize)
            m_Objects.push_back(obj);
        else
            delete obj;
    }
private:
    std::vector<T*> m_Objects;
    size_t m_MaxSize;
};

struct S
{
    void ObjMethod()
    {
        printf("%s\n", __FUNCTION__);
    }
};

void PoolTest()
{
    ObjectPool<S> op;
    S* obj = op.AcquireObject();

    // TODO: use the object
    obj->ObjMethod();

    op.ReleaseObject(obj);
}


// Provided as is without warranty. Untested.
template <typename T>
class SmartPointerLikeSomethingThatAutomaticallyReleaseTheObject
{
public:
    SmartPointerLikeSomethingThatAutomaticallyReleaseTheObject(ObjectPool<T>& pool)
        : m_Pool(pool)
    {
        m_Ptr = pool.AcquireObject();
    }
    ~SmartPointerLikeSomethingThatAutomaticallyReleaseTheObject()
    {
        Release();
    }
    void Release()
    {
        if (m_Ptr)
        {
            m_Pool.ReleaseObject(m_Ptr);
            m_Ptr = NULL;
        }
    }
    T* operator->()
    {
        assert(m_Ptr);
        return m_Ptr;
    }
    T& operator*()
    {
        assert(m_Ptr);
        return *m_Ptr;
    }
private:
    // disabling copy constructor
    SmartPointerLikeSomethingThatAutomaticallyReleaseTheObject(const SmartPointerLikeSomethingThatAutomaticallyReleaseTheObject&);
private:
    ObjectPool<T>& m_Pool;
    T* m_Ptr;
};

void PoolTestWithRAII()
{
    ObjectPool<S> op;

    SmartPointerLikeSomethingThatAutomaticallyReleaseTheObject<S> obj(op);
    // use obj, it gets release automatically when it goes out of scope (at the end of function)
    obj->ObjMethod();

    {
        SmartPointerLikeSomethingThatAutomaticallyReleaseTheObject<S> obj2(op);
        // use obj, it gets release automatically when it goes out of scope (at the end of function)
        obj2->ObjMethod();
    }

    printf("End of function\n");
}