Сумму и разность двух двумерных динамических массивов записать в отдельные массивы

#include <iostream> 
#include <string>
 
using std::cout;
using std::cin;
using std::endl;
int m, n, i, j, l, i_cont;
int main()
{
    setlocale(0, "");
 
    cout << "Введите количество строк n= ";
    cin >> n;
    cout << endl;
    cout << "Введите количество столбцов m= ";
    cin >> m;
    cout << endl;
    
    int *str = new int[n];   ////Инициализация двумерного динамического массива
    int **a = new int*[n]; // n строк в массиве
    for (i = 0; i < n; i++)
        a[i] = new int[m]; // и m столбцов
 
    for (l = 0; l <= i_cont; l++)
    {
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < m; j++) {
                a[i][j] = 0.001*rand();
                if (a[i][j]<10)
                    cout << a[i][j] << "  ";
                else
                    cout << a[i][j] << " ";
            }
            cout << endl;
        }
        
???????????
 
    }
    delete[] str;
    for (i = 0; i < n; i++)
        delete[] a[i];
    system("pause"); 
}

#include <iostream>
#include <vector>
 
using namespace std;
 
int main() 
{
    int n = 4;
    // создание массивов
    int **A = new int*[n];
    int **B = new int*[n];
    int **RES = new int*[n];
    for (int i = 0; i < n; ++i)
    {
        A[i] = new int[n];
        B[i] = new int[n];
        RES[i] = new int[n];
    }
    // инициализация массивов
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            A[i][j] = rand() % 10;
            B[i][j] = rand() % 10;
        }
    }
    // операции над массивами
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            RES[i][j] = A[i][j] + B[i][j];
        }
    }
    // вывод массивов
    cout << "A" << endl;
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            cout << A[i][j] << '\t';
        }
        cout << endl;
    }
    cout << "B" << endl;
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            cout << B[i][j] << '\t';
        }
        cout << endl;
    }
    cout << "RES" << endl;
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            cout<<RES[i][j] << '\t';
        }
        cout << endl;
    }
    // удаления массивов
    for (int i = 0; i < n; ++i)
    {
        delete[] A[i];
        delete[] B[i];
        delete[] RES[i];
    }
    delete[] A;
    delete[] B;
    delete[] RES;
 
    system("pause");
    
    return 0;
}

#include <iostream>
#include <ctime>
 
template<typename T>
class Matrix
{
private:
    T **_matrix = nullptr;
    int _colCount;
    int _rowCount;
public:
    Matrix<T>();
    Matrix<T>(int rows, int cols);
    Matrix<T>(const Matrix<T>& obj);
 
    void SetLength(int rows, int cols);
    void SetMatrix();
    void GenerateMatrix(T from, T to);
 
    int GetColsCount() const { return _colCount; };
    int GetRowsCount() const { return _rowCount; };
 
    void Print();
 
    Matrix<T> & operator = (const Matrix<T> &obj);
    Matrix<T> & operator + (const Matrix<T> &obj);
    Matrix<T> & operator - (const Matrix<T> &obj);
 
    const T operator () (int i, int j);
 
    friend std::ostream& operator << (std::ostream& stream, const Matrix<T> &obj)
    {
        for (auto i = 0; i < obj._rowCount; i++)
        {
            for (auto j = 0; j < obj._colCount; j++)
                stream << obj._matrix[i][j] << " ";
            stream << std::endl;
        }
        stream << std::endl;
        return stream;
    }
    friend std::istream& operator >> (std::istream &stream, Matrix<T>& obj)
    {
        std::cout << "Matrix has " << obj._rowCount << " rows and " << obj._colCount << " cols" << std::endl;
        for (auto i = 0; i < obj._rowCount; i++)
        {
            for (auto j = 0; j < obj._colCount; j++)
            {
                std::cout << "Matrix[" << i << "," << j << "]: ";
                stream >> obj._matrix[i][j];
            }
        }
        return stream;
    }
 
    ~Matrix<T>();
};
 
template <typename T>
Matrix<T>::Matrix()
{
    _matrix = nullptr;
    _colCount = 0;
    _rowCount = 0;
}
 
template <typename T>
Matrix<T>::Matrix(int rows, int cols)
{
    _rowCount = rows;
    _colCount = cols;
    _matrix = new T*[_rowCount];
    for (auto i = 0; i < _rowCount; i++)
    {
        _matrix[i] = new T[_colCount];
        for (auto j = 0; j < _colCount; j++)
            _matrix[i][j] = 0;
    }
}
 
template <typename T>
Matrix<T>::Matrix(const Matrix<T>& obj)
{
    this->_rowCount = obj._rowCount;
    this->_colCount = obj._colCount;
 
    this->_matrix = new T*[this->_rowCount];
    for (auto i = 0; i < _rowCount; i++)
    {
        this->_matrix[i] = new T[this->_colCount];
        for (auto j = 0; j < _colCount; j++)
            this->_matrix[i][j] = obj._matrix[i][j];
    }
}
 
template <typename T>
void Matrix<T>::SetLength(int rows, int cols)
{
    if (_matrix)
    {
        for (auto i = 0; i < _rowCount; i++)
            delete[]_matrix[i];
        delete[]_matrix;
        _matrix = nullptr;
        _colCount = rows;
        _rowCount = cols;
    }
    
    _matrix = new T*[_rowCount];
    for (auto i = 0; i < _rowCount; i++)
    {
        _matrix[i] = new T[_colCount];
        for (auto j = 0; j < _colCount; j++)
            _matrix[i][j] = 0;
    }
}
 
template <typename T>
void Matrix<T>::SetMatrix()
{
    if (!_matrix)
    {
        std::cout << "Enter rows count: ";
        std::cin >> _rowCount;
        std::cout << "Enter cols count: ";
        std::cin >> _colCount;
    }
    for (auto i = 0; i < _rowCount; i++)
    {
        for (auto j = 0; j < _colCount; j++)
            std::cin >> _matrix[i][j];
    }
}
 
template <typename T>
void Matrix<T>::GenerateMatrix(T from, T to)
{
    for (auto i = 0; i < _rowCount; i++)
    {
        for (auto j = 0; j < _colCount; j++)
        {
            if (typeid(T).name() == typeid(double).name())
                _matrix[i][j] = (double)rand() / (double)RAND_MAX * (to - from) + from;
            else
                _matrix[i][j] = fmod(from + rand(), (to - from + 1));
        }
        
    }
}
 
template <typename T>
void Matrix<T>::Print()
{
    for (auto i = 0; i < _rowCount; i++)
    {
        for (auto j = 0; j < _colCount; j++)
            std::cout << _matrix[i][j] << " ";
        std::cout << std::endl;
    }
    std::cout << std::endl;
}
 
template <typename T>
Matrix<T>& Matrix<T>::operator=(const Matrix<T>& obj)
{
    if (this->_matrix)
    {
        for (auto i = 0; i < this->_rowCount; i++)
            delete[]this->_matrix[i];
        delete[]this->_matrix;
        this->_matrix = nullptr;
    }
 
    this->_rowCount = obj._rowCount;
    this->_colCount = obj._colCount;
 
    this->_matrix = new T*[this->_rowCount];
    for (auto i = 0; i < _rowCount; i++)
    {
        this->_matrix[i] = new T[this->_colCount];
        for (auto j = 0; j < _colCount; j++)
            this->_matrix[i][j] = obj._matrix[i][j];
    }
    return *this;
}
 
template <typename T>
Matrix<T>& Matrix<T>::operator+(const Matrix<T>& obj)
{
    if (obj._colCount == this->_colCount && obj._rowCount == this->_rowCount)
    {
        for (auto i = 0; i < this->_rowCount; i++)
        {
            for (auto j = 0; j < this->_colCount; j++)
                this->_matrix[i][j] += obj._matrix[i][j];
        }
    }
    else
        std::cout << "\nMatrixs have dif sizes\n";
    return *this;
}
 
template <typename T>
Matrix<T>& Matrix<T>::operator-(const Matrix<T>& obj)
{
    if (obj._colCount == this->_colCount && obj._rowCount == this->_rowCount)
    {
        for (auto i = 0; i < this->_rowCount; i++)
        {
            for (auto j = 0; j < this->_colCount; j++)
                this->_matrix[i][j] -= obj._matrix[i][j];
        }
    }
    else
        std::cout << "\nMatrixs have dif sizes\n";
    return *this;
}
 
template <typename T>
const T Matrix<T>::operator () (int i, int j)
{
    if (this->_colCount > i && this->_rowCount > j) return _matrix[i][j];
    return -INFINITY;
}
 
template <typename T>
Matrix<T>::~Matrix()
{
    for (auto i = 0; i < _rowCount; i++)
        delete[]_matrix[i];
    delete[]_matrix;
    _matrix = nullptr;
    _colCount = 0;
    _rowCount = 0;
}
 
int main()
{
    srand(time(NULL));
    Matrix<int> arrI1(5, 2);
    Matrix<int> arrI2(5, 2);
    
    arrI1.GenerateMatrix(10, 99);
    arrI1.Print();
    
    arrI2.GenerateMatrix(10, 99);
    arrI2.Print();
 
    std::cout << arrI1 + arrI2;
    std::cout << arrI1 - arrI2;
    std::cout << arrI1 - arrI1;
 
    Matrix<double> arrD1(4, 3);
    Matrix<double> arrD2(4, 3);
 
    arrD1.GenerateMatrix(10.0, 20.0);
    arrD1.Print();
 
    arrD2.GenerateMatrix(10.0, 20.0);
    arrD2.Print();
 
    std::cout << arrD1 + arrD2;
    std::cout << arrD1 - arrD2;
    std::cout << arrD1 - arrD1;
 
    return 0;
}

int main()
{
    srand(time(NULL));
    Matrix<int> arrI1(5, 2);
    Matrix<int> arrI2(5, 2);
    
    arrI1.GenerateMatrix(10, 99);
    std::cout << arrI1;
    
    arrI2.GenerateMatrix(10, 99);
    std::cout << arrI2;
 
    Matrix<int> arrI3 = arrI1 + arrI2;
    std::cout << arrI3;
 
    Matrix<int> arrI4 = arrI1 - arrI2;
    std::cout << arrI4;
 
    Matrix<double> arrD1(4, 3);
    Matrix<double> arrD2(4, 3);
 
    arrD1.GenerateMatrix(10.0, 20.0);
    std::cout << arrD1;
 
    arrD2.GenerateMatrix(10.0, 20.0);
    std::cout << arrD2;
 
    Matrix<double> arrD3 = arrD1 + arrD2;
    std::cout << arrD3;
 
    Matrix<double> arrD4 = arrD1 - arrD2;
    std::cout << arrD4;
 
    return 0;
}

double *A = new double[3]{1,2,3};
    double *B = new double[4]{1,2,3,4};
    double *RES = new double[3];
 
        for (int i = 0; i < 3; ++i)
        {
            RES[i] = A[i] + B[i];
        }