Нужно найти ошибку в коде. С++ перезагрузка операторов

#include "stdafx.h"
#include <cstdlib>
#include <iostream>
#include <iomanip> // для манипулятора setw
 
using namespace std;
 
 
 
class Matrix
{
    friend ostream &operator<< (ostream &, const Matrix &); // перегруженный оператор вывода
    friend istream &operator>> (istream &, Matrix &); // перегруженный оператор ввода
public:
     Array* ptr; // указатель на матрицу типа Array
    int size; // размер матрицы
 
public:
    Matrix();// конструктор по умолчанию
    Matrix(int, int); // конструктор с параметрами
    Matrix(Matrix &matrixToCopy); // конструктор копии
    ~Matrix(); // десструктор класса Matrix
 
    int getSize() const; // возвратить количество объектов типа Array
    Array *getPtr() const; // вернуть указатель на объект типа Array
    Array &operator[] (int); // перегруженная операция взятия индекса
    void setMatrix(); // заполнение матрицы
    void getMatrix(); // вывод матрицы
    int *search(const int key) const; // поиск по ключу
    Matrix operator+ (const Matrix &right);
    Matrix operator+= (const Matrix &right);
    Matrix operator- (const Matrix &right);
    const Matrix &operator= (const Matrix &right); // оператор присваивания
    bool operator== (const Matrix &right) const;// оператор сравнения
};
 
Matrix::Matrix() // конструктор по умолчанию
{
    size = 10; // по умолчанию размер матрицы = 10 объектам типа Array
    ptr = new Array[size]; // выделить место в памяти для матрицы
    for (int ix = 0; ix < size; ix++) // обнуляем матрицу
        for (int jx = 0; jx < 10; jx++)
            ptr[ix][jx] = 0;
}
 
Matrix::Matrix(int matrixSize, int arraySize) // конструктор с параметрами
{
    size = (matrixSize > 0 ? matrixSize : 10); // количество строк
 
    ptr = new Array[size]; // выделить место в памяти для матрицы
 
    for (int ix = 0; ix < size; ix++) // перераспределяем выделенную память
        ptr[ix].setSize(arraySize > 0 ? arraySize : 10); // количество столбцов
 
    for (int ix = 0; ix < size; ix++) // обнуляем матрицу
        for (int jx = 0; jx < ptr->getSize(); jx++)
            ptr[ix][jx] = 0;
}
 
Matrix::Matrix(Matrix &matrixToCopy) // конструктор копии
    :size(matrixToCopy.size)              // инициализатор размера массива
{
    ptr = new Array[size]; // выделить место в памяти для матрицы
 
    for (int ix = 0; ix < size; ix++) // перераспределяем выделенную память
        ptr[ix].setSize(size); // количество столбцов
 
    for (int ix = 0; ix < size; ix++)
        for (int jx = 0; jx < ptr->getSize(); jx++)
            ptr[ix][jx] = matrixToCopy[ix][jx];// заполняем матрицу значениями матрицы matrixToCopy
}
 
Matrix::~Matrix() // десструктор класса Matrix
{
    delete[] ptr; // освободить память, удалив матрицу
}
 
int Matrix::getSize() const // возвратить количество элементов матрицы
{
    return size;
}
 
Array *Matrix::getPtr() const
{
    return ptr;
}
 
// перегруженный оператор вывода для класса Array (вывод элементов массива на экран)
ostream &operator<< (ostream &output, const Matrix &obj)
{
    for (int ix = 0; ix < obj.size; ix++)
    {
        for (int jx = 0; jx < obj.ptr->getSize(); jx++)
        {
            output << setw(5) // под каждое число выделяется 5 позиций
                << obj.ptr[ix][jx];
        }
        cout << std::endl;
    }
 
    output << std::endl; // перенос маркера на новую строку
 
    return output; // позволяет множественный вывод, типа cout << x << y << z << ...
}
 
// перегруженный оператор ввода, для заполнения матрицы с клавиатуры
istream &operator>> (istream & input, Matrix &obj)
{
    for (int ix = 0; ix < obj.size; ix++)
        for (int jx = 0; jx < obj.ptr->getSize(); jx++)
            input >> obj.ptr[ix][jx]; // заполняем матрицу
 
    return input; // позволяет множественный ввод, типа cin >> x >> y >> z >> ...
}
 
// перегруженный оператор взятия индекса
Array &Matrix::operator[] (int subscript)
{
    if (subscript < 0 || subscript >= size)
    {
        std::cerr << "\n Ошибка индекса: " << subscript << std::endl;
        exit(1); // завершить работу программы, неправильный индекс
    }
    return ptr[subscript]; // возврат ссылки на элемент массива
}
 
void Matrix::setMatrix() // заполнение массива
{
    for (int ix = 0; ix < size; ix++)
        for (int jx = 0; jx < ptr->getSize(); jx++)
            cin >> ptr[ix][jx]; // ввод элементов матрицы с клавиатуры
}
 
void Matrix::getMatrix() // вывод массива
{
    for (int ix = 0; ix < size; ix++)
    {
        for (int jx = 0; jx < ptr->getSize(); jx++)
            cout << setw(5) << ptr[ix][jx]; // вывод элементов матрицы на экран
        cout << std::endl;
    }
 
    cout << std::endl; // новая строка
}
 
int *Matrix::search(const int key) const // поиск по ключу
{
    for (int ix = 0; ix < size; ix++)
        for (int jx = 0; jx < ptr->getSize(); jx++)
            if (key == ptr[ix][jx]) // поиск по ключу
                return (&ptr[ix][jx]);             // позиция искомого элемента
 
    return NULL;
}
 
Matrix Matrix::operator+ (const Matrix &right)
{
    if (size != right.size || ptr->getSize() != right.getPtr()->getSize())
    {
        cout << "Массивы разного размера!\n";
        exit(1); // завершить работу программы
    }
 
    Matrix result(size, ptr->getSize());
    for (int ix = 0; ix < size; ix++)
        for (int jx = 0; jx < ptr->getSize(); jx++)
            result.ptr[ix][jx] = ptr[ix][jx] + right.ptr[ix][jx];
 
    return result; // вернуть сумму
}
 
Matrix Matrix::operator+= (const Matrix &right)
{
    if (size != right.size || ptr->getSize() != right.getPtr()->getSize())
    {
        cout << "Массивы разного размера!\n";
        exit(1); // завершить работу программы
    }
 
    //    Matrix result(size, ptr->getSize());
    for (int ix = 0; ix < size; ix++)
        for (int jx = 0; jx < ptr->getSize(); jx++)
            ptr[ix][jx] = ptr[ix][jx] + right.ptr[ix][jx];
 
    return *this; // вернуть сумму
}
 
Matrix Matrix::operator- (const Matrix &right)
{
    if (size != right.size || ptr->getSize() != right.getPtr()->getSize())
    {
        cout << "Массивы разного размера!\n";
        exit(1); // завершить работу программы
    }
 
    Matrix result(size, ptr->getSize());
    for (int ix = 0; ix < size; ix++)
        for (int jx = 0; jx < ptr->getSize(); jx++)
            result.ptr[ix][jx] = ptr[ix][jx] - right.ptr[ix][jx];
 
    return result; // вернуть сумму
}
 
const Matrix &Matrix::operator= (const Matrix &right) // оператор присваивания
{
    if (&right != this) // чтобы не выполнялось самоприсваивание
    {
        if (size != right.size || ptr->getSize() != right.getPtr()->getSize())
        {
            delete[] ptr; // освободить пространство
            size = right.size; // установить нужный размер матрицы
            ptr = new Array[size]; // выделить память под копируемый массив
 
            for (int ix = 0; ix < size; ix++) // перераспределяем выделенную память
                ptr[ix].setSize(right.getPtr()->getSize()); // количество столбцов
        }
 
        for (int ix = 0; ix < size; ix++)
            for (int jx = 0; jx < ptr->getSize(); jx++)
                ptr[ix][jx] = right.ptr[ix][jx]; // скопировать массив
    }
 
    return *this; // разрешает множественное присваивание, например x = t = e
}
 
bool Matrix::operator== (const Matrix &right) const// оператор сравнения
{
    if (size != right.size || ptr->getSize() != right.getPtr()->getSize())
        return false; // матрицы с разным количеством элементов
 
    for (int ix = 0; ix < size; ix++)
        for (int jx = 0; jx < ptr->getSize(); jx++)
            if (ptr[ix][jx] != right.ptr[ix][jx])
                return false; // матрицы не равны
 
    return true; // матрицы равны
}
 
 
 
int main()
{
    srand(time(NULL));
    Matrix myMatrix1(5, 5); // конструктор с параметрами
 
                            // заполнение матрицы
    for (int ix = 0; ix < myMatrix1.getSize(); ix++)
        for (int jx = 0; jx < myMatrix1.getPtr()->getSize(); jx++)
            myMatrix1[ix][jx] = rand() % 100;
 
    cout << myMatrix1;  // перегруженный оператор вывода
 
    Matrix myMatrix2(myMatrix1); // конструктор копии
 
    myMatrix2.getMatrix(); // вывод матрицы с помощью метода класса Matrix
 
                           //myMatrix2.setMatrix(); // заполнение матрицы с помощью метода класса Matrix
 
    int * adr = myMatrix2.search(99);
 
    if (adr == NULL)
        cout << "Значения " << 99 << " в матрице нет!\n";
    else
        cout << "Значение " << 99 << " находится в памяти по адресу: " << adr << endl;
 
    cout << (myMatrix1 + myMatrix2); // перегруженная операция сложения
 
    cout << "Как видите, myMatrix1 осталась без изменения!\n";
    cout << myMatrix1;
 
    myMatrix1 += myMatrix2; // перегруженная операция сложения-присвоения
 
    cout << "myMatrix1 содержит значения ,полученные при: myMatrix1 += myMatrix2; !\n";
    cout << myMatrix1;
 
    cout << (myMatrix1 - myMatrix1); // перегруженная операция вычитания
 
    Matrix myMatrix3 = myMatrix2; // перегруженная операция присваивания
 
    cout << myMatrix3;
 
    if (myMatrix3 == myMatrix2)
        cout << "Матрицы myMatrix3 и myMatrix2 равны!\n";
 
    return 0;
}

Matrix& Matrix::operator+= (const Matrix &right)