Shared_str реализация - На выходе из деструктора падает программа

class shared_ptrMy
{
    private:
        Storage *st;
 
 
    public:
        shared_ptrMy(){};
        shared_ptrMy(Object*);
        ~shared_ptrMy();
        shared_ptrMy& operator=(shared_ptrMy&);
};
 
shared_ptrMy::shared_ptrMy(Object *o){
    st = new Storage(o);
}
 
shared_ptrMy& shared_ptrMy::operator=(shared_ptrMy &o){
    st->Copy(o.st);
    st = o.st;
    Storage *a = st;
    return *this;
}
 
 
 
shared_ptrMy::~shared_ptrMy(){
        delete st;
        st = NULL;
}

class Storage
{
    public:
        Storage(Object *o){
            pObj = o;
            counter = 1;
        }
        ~Storage(){
 
            int &k = counter;
            --counter;
 
            if(counter == 0)
                delete pObj;
        }
 
       Object& getObject(){
            return *pObj;
        }
 
        void Copy(Storage *s){
            ++(s->counter);
        }
 
 
   // private:
        Object *pObj;
        int counter ;

shared_ptrMy::shared_ptrMy(shared_ptrMy &ptr){
        this->st->Copy(ptr.st);
        this->st = ptr.st;
}

#include "shared_std.h"
#include <iostream>
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    shared_ptrMy a(new Object());
    shared_ptrMy b;
        b = a;
        
    return 0;
}

#include "Storage.h"
#include <iostream>
 
class shared_ptrMy
{
private:
    Storage *st;
 
 
public:
    shared_ptrMy(){};
    shared_ptrMy(shared_ptrMy&);
    shared_ptrMy(Object*);
    ~shared_ptrMy();
    shared_ptrMy& operator=(shared_ptrMy&);
};

#include "shared_std.h"
 
shared_ptrMy::shared_ptrMy(Object *o){
    st = new Storage(o);
}
 
shared_ptrMy& shared_ptrMy::operator=(shared_ptrMy &o){
    st->Copy(o.st);
    st = o.st;
    return *this;
}
 
 
 
shared_ptrMy::~shared_ptrMy(){
        delete st;
}
 
shared_ptrMy::shared_ptrMy(shared_ptrMy &ptr){
    this->st->Copy(ptr.st);
    this->st = ptr.st;
}

#include "Object.h"
#include <iostream>
 
class Storage
{
public:
    Storage(Object *o){
        pObj = o;
        counter = 1;
    }
    ~Storage(){
        
        std::cout << "destruct";
        --(this->counter);
 
        //bool j = (pObj == 0);
 
        if (this->counter == 0) 
            delete pObj;
    }
 
    Object& getObject(){
        return *pObj;
    }
 
    void Copy(Storage *s){
        ++(s->counter);
    }
 
 
    // private:
    Object *pObj;
    int counter;
};

class Object
{
public:
    Object();
    ~Object();
private:
 
    int *arr;
};

#include "Object.h"
 
Object::Object()
{
    arr = new int[10000];
    for (int i = 0; i<10000; ++i) arr[i] = i;
    int l = arr[70];
}
 
Object::~Object()
{
    delete[] arr;
}

int main(int argc, char* argv[])
{
    // 0. Создается объект "а"
    shared_ptrMy a(new Object()); //1. внутри создается объект класса Storage, st указывает на него
    shared_ptrMy b; //2. создается объект "b" - внимание указатель st в нем неинициализирован!
    b = a; // 3. выполняется operator=
    // 4. у st объекта "b" вызывается метод Copy - это уже неверно, 
    // т.к. st в "b" не содержит правильного адреса
    // но в моем случае это прокатило и программа пошла дальше, 
    // хотя могло и уже здесь упасть (UB есть UB)
    // Далее выполняется присваивание значения st из "а" значению st из "b"
    // теперь у нас два объекта "a" и "b", которые указывают на один и тот же экземпляр класса Storage
    // Затем идут вызовы деструкторов, деструктор "b" освобождает память Storage
    // Деструктор "a" пытается еще раз освободить память Storage, но т.к.
    // она уже освобождена, то это приводит к падению  
 
    return 0;
}