Self-deleting pointer class

[10oTURfi]

I'm trying to create suicidal pointer. This doesn't have any particular purpose, because it deletes pointer as soon as first pointer is out of scope, but I thought it would be fun.

This is code:

template<class T>
struct Pointer
{
    T* _Ptr;
    Pointer() { _Ptr = NULL; }
    Pointer(T* _Ptr) : _Ptr(_Ptr) {}
    ~Pointer() { if(_Ptr != NULL) { delete _Ptr; _Ptr = NULL; } }
    T& operator*() { return *_Ptr; }
    void operator=(T* _Ptr){ delete this->_Ptr; this->_Ptr = _Ptr; }
    void operator=(const Pointer& Pointer) { this->_Ptr = Pointer._Ptr; }
};

typedef Pointer<int> intptr;

int main()
{
    while(true) // Try to leak memmory
    {
        intptr p(new int);
        intptr d = new int;
        d = new int;
        d = new int;
        *p = 5;
        *d = 10;
        intptr c;
        c = d;
        cout << *p << " " << *d << " " << *c << " ";
    }
}

Now the thing is, it crashes, and I do not know why.
Where's the problem?

[Moschops]

Deleting the same pointer more than once.

#include <cstdlib>
#include <iostream>

using namespace std;


template<class T>
struct Pointer
{
    T* _Ptr;
    Pointer() { _Ptr = NULL; }
    Pointer(T* _Ptr) : _Ptr(_Ptr) {}
  ~Pointer() { if(_Ptr != NULL) { cout<< "deleting " << _Ptr << endl; delete _Ptr; _Ptr = NULL; } }
    T& operator*() { return *_Ptr; }
  void operator=(T* _Ptr){ cout<< "deleting " << this->_Ptr << endl; delete this->_Ptr; this->_Ptr = _Ptr; }
    void operator=(const Pointer& Pointer) { this->_Ptr = Pointer._Ptr; }
};

typedef Pointer<int> intptr;

int main()
{
    while(true) // Try to leak memmory
    {
        intptr p(new int);
        intptr d = new int;
        d = new int;
        d = new int;
        *p = 5;
        *d = 10;
        intptr c;
        c = d;
        cout << *p << " " << *d << " " << *c << " ";
    }   
}

[vlad from moscow]

I did not test the code but it seems the problem is connected with creating a temporary object in the statement

intptr d = new int;

Without optimization the compiler at first creates a temporary object using constructor

Pointer(T* _Ptr) : _Ptr(_Ptr) {}

Then the compiler uses implicitly defined copy constructor to copy the temporary object to d. And then it deletes the temporary object. So d contains invalid pointer.

[10oTURfi]

@Moschops
I see... Is there a way to prevent that?

[vlad from moscow]

I think you should make a copy of object the pointter passed as argument of constructor/copy constructor and the copy assignment operator refers to.

[10oTURfi]

@vlad
Yes that might fix the problem, however, I wanted both pointers to point to same object.