Производный класс и наследование

class Vector {
 
protected:
int *v; 
int len; 
 
public:
// Конструктор создания массива
Vector(int N=0) : v(0), len(0) { 
    if (N>0) v = new int[N];
    if (v) len = N;
}
// Конструктор копирования – конструктор, создающий объект (типа vector)
// по уже имеющемуся объекту того же класса
Vector(const Vector & temp) : v(0), len(0)
{ if (temp.len>0) v=new int [temp.len];
if ( v ) {
len=temp.len;
for (int i=0;i<len;i++) {v[i]=temp.v[i];}
}
}
// Функция вывода массива
void GetMass()
    {
        for(int i=0; i<len;i++)
        {
            cout<<v[i]<<" ";
        }
        cout<<endl;
    }
// Функция заполнения массива
void ran() {
    for(int i = 0; i < len; i++)
        v[i] = rand()%32;
}
// Функция добавления элемента в массив
void insert(int k) {
    int *t; 
    t = new int [len+1];
    for(int i = 0; i < len; i++)
        t[i] = v[i];
    t[len] = k;
    len++;
    v = t;
};
// Функция удаления элемента
void erase(int k) {
    int *t, i = 0, j = 0;   
    t = new int [len];
    for(i = 0; i < len; i++) {
        if(v[i] != k){
            t[j] = v[i];
            j++;
        }
    }
    len = len - abs(i - j);
    v = t;
};
//=============Перегрузка []==========//
// для использования в левой части присваивания:
int & operator [] (int index)
{ return v[index]; }
 
// для использования в правой части присваивания:
int operator [] (int index) const
{ return v[index]; }
 
//=============Деструктор============//
// Определение деструктора ~имя_класса () {тело деструктора}
~ Vector() { delete [] v; }
};

class datavector: public Vector{
public:
    datavector(void) {}
    datavector(int v) : Vector(v) {}
    ~datavector() {}
 
    datavector& operator += (datavector& src) {
        if(len != src.len) return *this;
 
        for(int k = 0; k < src.len/2; k++) {
            int ch = v[2*k] * src.v[2*k + 1] + v[2*k + 1] * src.v[2*k];
            int zn = v[2*k + 1] * src.v[2*k + 1];
            v[2*k] = ch;
            v[2*k + 1] = zn;
        }
        return *this;
    }
};