Мелкая и глубокая копии

#include <cassert>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <iomanip>
using namespace std;
 
template <typename T>
class MyVector
{
    public:
        typedef T* iterator_type;
    private:
        iterator_type pole;
        int v_size;                                             //используется только для аллокации
        int  number;                                           //количество элементов в поле
        int * pocetPointeru;                                       //количество указателей на копию
 
 
    public:
                        MyVector        ();
                        MyVector        ( const MyVector<T>   & src );
                       ~MyVector        ();
        MyVector<T>&    operator =      ( const MyVector<T>   & src );
        MyVector<T>&    deep_copy       ( const MyVector<T>   & src );
    private:
        void realloc  ();
};
template<class T>
MyVector<T>::MyVector()
{
    pocetPointeru = new int ( 1 );
    number=0;
    equal_bit=false;
    v_size=2;
    pole = new T [v_size];
}
 
template<class T>
MyVector<T>::~MyVector      ()
{
    if ( --(*pocetPointeru) == 0 )
    {
        delete[] pole;
        delete pocetPointeru;
    }
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template<class T>
MyVector<T>::MyVector( const MyVector<T>   & src )
{
    pocetPointeru=src.pocetPointeru;
    ++(*pocetPointeru);
 
    equal_bit=src.equal_bit;
    v_size=src.v_size;
    number=src.number;
    pole=src.pole;
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template<class T>
MyVector<T>&    MyVector<T>::operator =     ( const MyVector<T>   & src )
{
    if ( --(*pocetPointeru) == 0 )
    {
        delete[] pole;
        delete pocetPointeru;
    }
 
    pocetPointeru=src.pocetPointeru;
    ++(*pocetPointeru);
 
    v_size=src.v_size;
    number=src.number;
    equal_bit=src.equal_bit;
    pole=src.pole;
    return ( *this );
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template<class T>
MyVector<T>&    MyVector<T>::deep_copy      ( const MyVector<T>   & src )
{
    --(*pocetPointeru);
    v_size=src.v_size;
    number=src.number;
    equal_bit=src.equal_bit;
    T* tmp = new T [ v_size ];
    memcpy( tmp,   pole, number * sizeof( T ) );
    pole = tmp;
 
    pocetPointeru = new int ( 1 );
    return ( *this );
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
class CRegister
 {
   public:
                    CRegister   ( void );
                    CRegister   ( const CRegister   & src );
                    ~CRegister  ( void );
 
    CRegister   &  operator =   ( const CRegister   & src );
    bool           some_action ( void );
    void           deep_copy    ( void );
   private:
    MyVector < Person *> VectorPersons;
    MyVector < Car    *> VectorCars;
    int * pocetPointeru;
 };
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
CRegister::CRegister    ( void ){pocetPointeru = new int ( 1 );}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
CRegister::CRegister    ( const CRegister   & src )
{
    pocetPointeru=src.pocetPointeru;
    ++(*pocetPointeru);
 
    VectorPersons=src.VectorPersons;
    VectorCars=src.VectorCars;
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
CRegister::~CRegister   ( void )
{
    if ( --(*pocetPointeru) == 0 )
    {
        for(int i = 0; i < VectorPersons.size(); i++)
            delete VectorPersons[i];
 
        for(int i = 0; i < VectorCars.size(); i++)
            delete VectorCars[i];
 
 
            delete pocetPointeru;
 
    }
 
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
CRegister&  CRegister::operator =   ( const CRegister   & src )
{
    if ( --(*pocetPointeru) == 0 )
    {
        for(int i = 0; i < VectorPersons.size(); i++)
            delete VectorPersons[i];
 
        for(int i = 0; i < VectorCars.size(); i++)
            delete VectorCars[i];
 
            delete pocetPointeru;
    }
    pocetPointeru=src.pocetPointeru;
    ++(*pocetPointeru);
 
    VectorPersons=src.VectorPersons;
    VectorCars=src.VectorCars;
    return ( *this );
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void         CRegister::deep_copy    ( void )
{
        --(*pocetPointeru);
        MyVector < Person * > tmpVectorPersons;
        MyVector < Car    * > tmpVectorCars;
 
        VectorPersons.deep_copy(VectorPersons);                             //tady vola destruktor pro VecrorPersons
        VectorCars.deep_copy(VectorCars);
 
        pocetPointeru = new int ( 1 );
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
bool CRegister::some_action ()
{
if ( (*pocetPointeru) > 1 )
    {
        deep_copy();
    }
...
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
int main (void)
{
CRegister  b0;                          //создаем вектор
b0.some_action();                    //что-то делаем, пока все в порядке
 
CRegister  b1(b0);                   //создаем мелкую копию
b0.some_action();                   //valgrind говорит, что в предыдущей строке элементы были удалены, segfault
return 0;
}

CRegister::~CRegister   ( void )
{
    if ( --(*pocetPointeru) == 0 )
    {
        for(int i = 0; i < VectorPersons.size(); i++)  //<--- у вашего вектора нет такого метода
            delete VectorPersons[i];
 
        for(int i = 0; i < VectorCars.size(); i++)
            delete VectorCars[i];
 
 
            delete pocetPointeru;
 
    }
 
}

delete VectorPersons[i]; //<--- у вашего вектора отсутствует operator[]

template<class T>
MyVector<T>::MyVector()
{
    pocetPointeru = new int ( 1 );
    number=0;
    equal_bit=false;    //<--- это откуда взялось? его нет среди данных-членов
    v_size=2;
    pole = new T [v_size];
}

MyVector::MyVector(MyVector &&); // shallow copy
MyVector::MyVector(const MyVector &); // deep copy