Исключительные ситуации (повторный вызов деструктора)

#include <stdio.h>
#include <conio.h>
 
class Ana
 
{
    int x;
 
public:
 
    Ana(int c); 
 
    ~Ana() {}
    
    int ghf() const {return x;}
 
    class A 
    
    { 
    
    public: 
        
        A() {printf("\nKONSTRUKTOR A %p\n",this);}
 
        ~A() {printf("\nDESTRUKTOR A %p\n",this);}
    };
 
    class B : public A 
    
    {
    
    public: 
        
        B() {printf("\nKONSTRUKTOR B %p\n",this);}
 
        ~B() {printf("\nDESTRUKTOR B %p\n",this);}
    };
 
    class C : public B 
    
    {
    
    public: 
        
        C() {printf("\nKONSTRUKTOR C %p\n",this);}
 
        ~C() {printf("\nDESTRUKTOR C %p\n",this);}
    };
};
 
Ana :: Ana(int c) :
 
x(c)
 
{
    if(c == 0) throw B();
 
    if(c < 0) throw A();
 
    if(c > 10) throw C();
}
 
int main()
 
{
    try
 
    {
        Ana s(11);
 
        printf("\n-------- %d\n",s.ghf());
    }
 
 
    catch (Ana :: C)
 
    {
        printf("\n****** c > 10\n");
    }
 
    catch (Ana :: B)
 
    {
        printf("\n****** c == 0\n");
    }
 
 
    catch (Ana :: A)
 
    {
        printf("\n****** c < 0\n");
    }
        
 
        getch();
 
        return 0;
}

~pointer() {delete p;}

template <class T>
class pointer
{
T *p;
public:
pointer(T *_p) : p(_p) {}
pointer(const pointer &rhs) : p(new T(*rhs.p))  {}
~pointer() {delete p; }
T & operator * () const {return *p;}
T * operator -> () const {return p;}
};

template <class T>
class pointer
{
   pointer(const pointer &) = delete;
   pointer & operator =(const pointer &) = delete;
 
   // ...
};

pointer(const pointer &) = delete;

pointer & operator = (const pointer &rhs) 
{
    if (this != &rhs) *p = *rhs.p;
    return *this;
}

pointer & operator = (const pointer &rhs) 
{
    if (this != &rhs) 
    {
        delete p;
        p = new T(*rhs.p);  
        }
    return *this;
}