Деструктор вызывает исключение Access violation

class MyVector
{        // класс с динамическим массивом
  private:
 
  public:
    int size;
    int* Element;
    MyVector(int n,int *m)  // или MyVector(int n,int m[])
    {
      size=n;
      Element = new int[size];
      for (int i=0;i<n;i++)
        Element[i]=m[i];
    }
    ~MyVector()
    {
      delete[] (Element);   //<-  !!Вот здесь возникает исключение
    }
/*
    int* operator[](int ind)
    {
        return Element+ind;
    }   */
 
};
 
MyVector operator+ (MyVector a, MyVector b)
{
   if (a.size!=b.size) throw;
   int *m= new int[a.size];
   MyVector c(a.size,m);
   for(int i=0;i<a.size;i++)
     c.Element[i]=a.Element[i]+b.Element[i];
   return(c);
}

  int *m= new int[4];
  m[0]=1;m[1]=2;m[2]=3;m[3]=4; MyVector vect(4,m);
  m[0]=2;m[1]=1;m[2]=2;m[3]=4; MyVector vect1(4,m);
  m[0]=0;m[1]=0;m[2]=0;m[3]=0; MyVector vect2(4,m);
  vect2=vect+vect1;

//---------------------------------------------------------------------------
 
#include <vcl.h>
#include <conio.h>
#pragma hdrstop
 
//---------------------------------------------------------------------------
 
#pragma argsused
 
class vect
{
private:
public:
    int *Element; // указатель на массив
    int Size;
    vect() :Element(0),Size(0) {}
    vect(int N, int *m) : Size(N)
    {
        Element = new int [N]; // под массив выделяется память - нужен деструктор для ее удаления
        for (int i(0);i<N;i++)
        {
          Element[i]=m[i];
        }
    }
 
    ~vect() // Создаем деструктор
    {
        delete []Element;
    }
 
    vect(const vect &a ):Size(a.Size) //  Обязательный копиконструктор (раз есть деструктор)
    {
        Element = new int [a.Size];
        for ( int i = 0; i < a.Size; i++ )
            Element[i] = a.Element[i];
    }
 
    vect &operator = ( const vect &a ) // Обязательный оператор присвоения (раз есть деструктор)
    {
        if ( this == &a ) 
            return *this; // присвоение самому себе, ничего делать не надо
 
        if ( Element != 0 )
            delete []Element;
 
        Element = new int [a.Size];
        for ( int i = 0; i < a.Size; i++ )
            Element[i] = a.Element[i];
    }
 
    vect operator+ ( vect &a ) // сложение векторов
    {
        if (this->Size!=a.Size) throw;
        vect c;
        c.Size = a.Size;
        c.Element = new int[c.Size];
        for (int i = 0; i < this->Size; i++ )
            c.Element[i] = this->Element[i]+a.Element[i];
        return c; // для передачи по значению используется копиконструктор
    }
};
 
int main()
{
    int m[5]={0,1,2,3,4}; vect a1(5,m);
    int m1[5]={5,6,7,8,9}; vect a2(5,m1);
    vect a3 = a1 + a2; // используется оператор присвоения
    getch();
    return 0;
}

class A
{
private:
    int * x; // указатель на массив
    int n;
 
public:
    A() : x( 0 ), n( 0 ) {}
    A( int N ) : n( N )
    {
        x = new int [N]; // под массив выделяется память - нужен деструктор для ее удаления
        for ( int i = 0; i < N; i++ )
            x[i] = i;
    }
 
    ~A() // Создаем деструктор
    {
        delete [] x;
    }
 
    A( const A & a ) : n( a.n ) //  Обязательный копиконструктор (раз есть деструктор)
    {
        x = new int [a.n];
        for ( int i = 0; i < a.n; i++ )
            x[i] = a.x[i];
    }
 
    A & operator = ( const A & a ) // Обязательный оператор присвоения (раз есть деструктор)
    {
        if ( this == &a ) 
            return *this; // присвоение самому себе, ничего делать не надо
 
        delete [] x;
 
        x = new int [a.n];
        for ( int i = 0; i < a.n; i++ )
            x[i] = a.x[i];
    }
 
    A operator + ( A & a ) // слияние массивов 
    {
        A c;
        c.n = this->n + a.n;
        c.x = new int [c.n];
 
        int i = 0;
        for ( ; i < this->n; i++ )
            c.x[i] = this->x[i];
 
        int j = 0;
        for ( ; i < c.n; i++, j++ )
            c.x[i] = a.x[j];
 
        return c; // для передачи по значению используется копиконструктор
    }
};
 
int main()
{
    A a1( 2 ), a2( 3 );
    A a3 = a1 + a2; // используется оператор присвоения
    return 0;
}