Safe Pointer

// Use safe pointer to automatically delete allocated memory that goes out of scope.
template<typename T>
class SafePtr
{
public:
    // Get object referenced by pointer.
    T &operator * () const { return *ptr; }

    // Get member accessor.
    T *operator -> () const { return ptr; }

    // Get pointer.
    T *operator () () const { return ptr; }

    // Get item at [index] if pointer is an array of items of <T>.
    T &operator [] (int index) const { return ptr[index]; }

    // Check if no pointer is assigned.
    bool operator ! () const { return !ptr; }

    // Assign pointer after releasing any existing pointer.
    void *operator = (T *ptr_) { Release(); return ptr = ptr_; }

    // Returns memory to use with new. Usage: new (safePtr.Alloc<K>()) Type().
    // Any current pointer is released before new memory pointer is allocated.
    template<typename K = T>
    void *Alloc() { Release(); return ptr = (T *)HeapMem::Alloc(sizeof(K)); }

    // Release memory pointer.
    void Release() { if (ptr) { ptr->~T(); HeapMem::Free((void **)&ptr); } }

    // Construct safe pointer using [ptr] or 0.
    SafePtr(T *ptr = 0) : ptr(ptr) {}

    // Destructor.
    ~SafePtr() { Release(); }

private:
    T *ptr;
};