Матрицы - перегрузка операторов >> и <<

#pragma once
 
#include <iostream>         //библиотека для потокового ввода, вывода
using namespace std;                                    //пространство имен
 
class Matrix
{
friend ostream &operator<< (ostream &, const Matrix &); // перегруженный оператор вывода
friend istream &operator>> (istream &, Matrix &); // перегруженный оператор ввода
private:
    int* adenin;
    size_t width;
    size_t height;
public:
    Matrix() :
        adenin(nullptr),
        width(0),               //Ширина и высота матрицы
        height(0)
    {
    }
 
    Matrix(size_t width, size_t height) :        //Конструктор
        adenin(new int[width * height]),
        width(width),
        height(height)
    {
    }
 
    Matrix(const Matrix& matrix):                                    //Конструктор копирования
        adenin(new int[matrix.width * matrix.height]), 
        width(matrix.width), 
        height(matrix.height) 
    { 
        for(int i = 0; i < width; ++i) 
            for(int j = 0; j < height; ++j) 
                adenin[j * width + i] = matrix.adenin[j * width + i]; 
    }
    ~Matrix()                            //Деструктор
    {
        if(adenin != nullptr)        
            delete[] adenin;            //Освободить память, удалив матрицу        
    }
 
    size_t GetWidth() const
    {
        return width;                   
    }
 
    size_t GetHeight() const
    {
        return height;          
    }                                                                                           
 
    void SetWidth(size_t newWidth)
    {
        //если новый размер равен старому, то ничего не делаем
        if(width == newWidth)
            return;
        if(newWidth == 0)
        {
            delete[] adenin;
            width = 0;
            return;
        }
        if(adenin == nullptr)
        {
            adenin = new int[width * height];
            width = newWidth;
            return;
        };
        auto bufArr{new int[height * newWidth]};
        auto bufSize{(width < newWidth)? width : newWidth};
        for(int j = 0; j < height; ++j)
            for(int i = 0; i < bufSize; ++i)
                bufArr[j * newWidth + i] = adenin[j * width + i];
        width = newWidth;
        adenin = bufArr;
    }
 
    void SetHeight(size_t newHeight)
    {
        //если новый размер равен старому, то ничего не делаем
        if(height == newHeight)
            return;
        if(newHeight == 0)
        {
            delete[] adenin;
            height = 0;
            return;
        }
        if(adenin == nullptr)
        {
            adenin = new int[width * height];
            height = newHeight;
            return;
        };
        auto bufArr{new int[height * newHeight]};
        auto bufSize{(height < newHeight)? height : newHeight};
        for(int i = 0; i < bufSize; ++i)
            for(int j = 0; j < height; ++j)         
                bufArr[j * width + i] = adenin[j * width + i];
        height = newHeight;
        adenin = bufArr;
    }
 
    void Resize(size_t newWidth, size_t newHeight)
    {
        SetWidth(newWidth);
    }
 
    int& operator()(size_t x, size_t y)
    {
        if((x >= width) || (y >= height) || (adenin == nullptr))
        {
            cout << "Ошибка доступа";
            //выходим из  программы с ошибкой
            exit(EXIT_FAILURE);
        }
        return adenin[y * width+x ];
    }
 
    //версия для константных объектов
    const int& operator()(size_t x, size_t y) const
    {
        if((x >= width) || (y >= height) || (adenin == nullptr))
        {
            cout << "Ошибка доступа";
            //выходим из  программы с ошибкой
            exit(EXIT_FAILURE);
        }
        return adenin[y * width + x];
    }
 
    Matrix& operator=(const Matrix& right)  //Перегружаем оператор присваивания
    {
        if (&right != this) // чтобы не выполнялось самоприсваивание
        {
            if (width != right.width || height!=right.height)
            for (int i = 0; i < width; i++)
                for (int j = 0; j < height; j++)
                    adenin[j * width + i] = right.adenin[j * width + i]; // скопировать массив
        }
 
        return *this;
    }
 
    // перегруженный оператор ввода, для заполнения матрицы с клавиатуры
    //friend - дружественная функция
/*
friend std::istream &operator>> (std::istream & input, Matrix &matrix)
    {
        for (int i = 0; i < matrix.width; i++)
 
            for (int j = 0; j < matrix.height; j++)
 
                input >> matrix.adenin[j * width + i]; // заполняем матрицу
 
        return input; // позволяет множественный ввод, типа cin » x » y » z » ...
    }
// перегруженный оператор вывода 
    friend std::ostream &operator<< (std::ostream &output, const Matrix &matrix)
    {
        for (int i = 0; i < matrix.width; i++)
        {
            for (int j = 0; j < matrix.height; j++)
            {
                output << matrix.adenin[j * width + i];  
            }
            cout << std::endl;
        }
 
        output << std::endl; // перенос маркера на новую строку
 
        return output; // позволяет множественный вывод, типа cout << x << y << z << ...
    }       */  
 
 
    Matrix operator+(const Matrix& right)
    {       if (width != right.width || height!=right.height)
            {
                cout << "Array sizes are not the same!\n";
                exit(1); // завершить работу программы
            }   
    Matrix buf(width, height); 
    for(int i = 0; i < width; ++i) 
        for(int j = 0; j < height; ++j) 
            buf.adenin[j * width + i] = adenin[j * width + i] + right.adenin[j * width + i]; 
    return Matrix(buf); 
    }
 
    Matrix& operator+=(const Matrix& right)
    {
        if(width != right.width || height != right.height)
        {
            cout << "Array sizes are not the same!\n";
            exit(1);
        }// завершить работу программы
        for(int i = 0; i < width; ++i) 
            for(int j = 0; j < height; ++j) 
                adenin[j * width + i] = adenin[j * width + i] + right.adenin[j * width + i]; 
        return *this; // вернуть сумму
    }
 
    Matrix& operator-=(const Matrix& right)
    {
        if(width != right.width || height != right.height)
        {
            cout << "Array sizes are not the same!\n";
            exit(1);
        }// завершить работу программы
        for(int i = 0; i < width; ++i) 
            for(int j = 0; j < height; ++j) 
                adenin[j * width + i] = adenin[j * width + i] - right.adenin[j * width + i]; 
        return *this; // вернуть сумму
    }
 
    Matrix operator-(const Matrix& right)
    {       if (width != right.width || height!=right.height)
    {
        cout << "Array sizes are not the same!\n";
        exit(1); // завершить работу программы
    }
    Matrix buf(width, height); 
    for(int i = 0; i < width; ++i) 
        for(int j = 0; j < height; ++j) 
            buf.adenin[j * width + i] = adenin[j * width + i] - right.adenin[j * width + i]; 
    return Matrix(buf); 
    }
 
};