Pointer defragging

#include <iostream>
#include <list>
#include <cstring>

using namespace std;

struct defrag_enabler
{
    virtual void defrag() = 0;
};

std::list<defrag_enabler*> allocated_refrences;

void defrag()
{
    for(defrag_enabler* ref : allocated_refrences)
        ref->defrag();
}

template<typename T>
struct pointer_ref : public defrag_enabler
{
    T* ptr;
    size_t references;

    template<typename... Args>
    pointer_ref<T>(Args... args)
    {
        allocated_refrences.push_back(this);
        cout << "Created\n";
        ptr = new T(args...);
        ref();
    }

    ~pointer_ref()
    {
        cout << "Destroyed\n";
        delete ptr;
    }

    void ref()
    {
        references++;
        cout << "Made reference (" << references << " total)\n";
    }

    void deref()
    {
        references--;
        cout << "Deleted reference (" << references << " total)\n";
        if(references <= 0)
            delete this;
    }

    void defrag()
    {
        size_t bytes = sizeof(T);
        T* pNew = new T;
        memcpy(pNew, ptr, bytes);
        delete ptr;
        ptr = pNew;
    }
};

template<typename T>
struct pointer
{
    pointer_ref<T>* ref;

    pointer<T>(const pointer<T>& other)
    {
        ref = other.ref;
        ref->ref();
    }

    template<typename... Args>
    pointer<T>(Args... args)
    {
        ref = new pointer_ref<T>(args...);
    }

    T& operator*()
    {
        return *ref->ptr;
    }

    ~pointer()
    {
        ref->deref();
    }
};


int main (int argc, char *argv[])
{
    std::list<pointer<int>> ptrs;

    pointer<int> ptr = pointer<int>(10);

    for(int i = 0; i < 5; i++)
        ptrs.push_back(ptr);

    for(pointer<int>& p : ptrs)
        std::cout << "in list: " << p.ref->ptr << " = " << *p << "\n";

    cout << "Defragging...\n";
    defrag();

    for(pointer<int>& p : ptrs)
        std::cout << "in list: " << p.ref->ptr << " = " << *p << "\n";

    std::cout << *ptr << "\n";
    return 0;
}