Класс Matrix

// requirements: compiler that supports C++11
 
#ifndef MATRIX_H
#define MATRIX_H
 
#include <iostream>
 
typedef double Item;
 
class Matrix
{
private:
    int m_row;
    int m_col;
    Item ** matrix;
 
public:
    Matrix(int row, int col);
    explicit Matrix(int col);
    Matrix(const Matrix & m);
    ~Matrix();
 
    void reset();
    void fill_rand(Item fromNum, Item toNum);
    void fill_by_user();
    Item find_min_value();
    Item find_max_value();
    Item find_sum();
    Item find_avg_value();
 
    int count_value_in_row(const Item chosen_value, const int chosen_row);
 
    Matrix & operator=(const Matrix & m);
    Matrix operator*(const Matrix & m);
    friend std::ostream & operator<<(std::ostream & os, const Matrix & m);
};
 
#endif // MATRIX_H

#include "Matrix.h"
#include <random>
#include <ctime>
#include <iomanip>
 
Matrix::Matrix(int row, int col)
{
    m_row = row;
    m_col = col;
 
    matrix = new Item * [m_row];
    for (int i = 0; i < m_row; ++i)
        matrix[i] = new Item[m_col];
}
 
Matrix::Matrix(int col)
{
    m_row = 1;
    m_col = col;
 
    matrix = new Item * [m_row];
    matrix[0] = new Item[m_col];
}
 
Matrix::Matrix(const Matrix & m)
{
    m_row = m.m_row;
    m_col = m.m_col;
 
    matrix = new Item * [m_row];
    for (int i = 0; i < m_row; ++i)
        matrix[i] = new Item[m_col];
 
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
            matrix[i][j] = m.matrix[i][j];
}
 
Matrix::~Matrix()
{
    for (int i = 0; i < m_row; ++i)
        delete [] matrix[i];
    delete [] matrix;
}
 
void Matrix::reset()
{
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
            matrix[i][j] = 0;
}
 
void Matrix::fill_rand(Item fromNum, Item toNum)
{
    std::mt19937 gen(time(0));
    std::uniform_real_distribution<double> urd(fromNum, toNum);
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
            matrix[i][j] = urd(gen);
}
 
void Matrix::fill_by_user()
{
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
        {
            std::cout << "\nEnter a value of the element matrix["
                      << i <<"][" << j << "]: ";
            std::cin >> matrix[i][j];
        }
}
 
Item Matrix::find_min_value()
{
    Item min_value = matrix[0][0];
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
            if (min_value > matrix[i][j])
                min_value = matrix[i][j];
    return min_value;
}
 
Item Matrix::find_max_value()
{
    Item max_value = matrix[0][0];
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
            if (max_value < matrix[i][j])
                max_value = matrix[i][j];
    return max_value;
}
 
Item Matrix::find_sum()
{
    Item sum = 0;
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
            sum += matrix[i][j];
    return sum;    
}
 
Item Matrix::find_avg_value()
{
    return find_sum() / (m_row * m_col);
}
 
int Matrix::count_value_in_row(const Item chosen_value, const int chosen_row)
{
    int counter = 0;
    for (int j = 0; j < m_col; ++j)
        if (matrix[chosen_row][j] == chosen_value)
            counter++;
    return counter;
}
 
Matrix & Matrix::operator=(const Matrix & m)
{
    if (this != &m)
    {
        for (int i = 0; i < m_row; ++i)
            delete [] matrix[i];
        delete [] matrix;
 
        m_row = m.m_row;
        m_col = m.m_col;
 
        matrix = new Item * [m_row];
        for (int i = 0; i < m_row; ++i)
            matrix[i] = new Item[m_col];
 
        for (int i = 0; i < m_row; ++i)
            for (int j = 0; j < m_col; ++j)
                matrix[i][j] = m.matrix[i][j];
    }
 
    return *this;
}
 
Matrix Matrix::operator*(const Matrix & m)
{
    Matrix res(m_row, m.m_col);
    res.reset();
 
    if (m_col == m.m_row)
    {
        for (int i = 0; i < res.m_row; ++i)
            for (int j = 0; j < res.m_col; ++j)
                for (int k = 0; k < m_row; ++k)
                    res.matrix[i][j] += matrix[i][k] * m.matrix[k][j];
    }    
    else
        std::cout << "\nIncorrect arguments in matrices multiplying.\n";
 
    return res;
}
 
std::ostream & operator<<(std::ostream & os, const Matrix & m)
{
    for (int i = 0; i < m.m_row; ++i)
    {
        for (int j = 0; j < m.m_col; ++j)
            os << std::setprecision(3) << m.matrix[i][j] << "\t";
        os << "\n";
    }
 
    return os;
}

#include <iostream>
#include "Matrix.h"
 
int main()
{
    const int rsize1 = 3;
    const int csize1 = 4;
    Matrix matrix1(rsize1, csize1);
    matrix1.fill_rand(0.11, 9.99);
 
    const int rsize2 = 4;
    const int csize2 = 5;
    Matrix matrix2(rsize2, csize2);
    matrix2.fill_rand(0, 9);
    std::cout << "\nThis is the 1st matrix:\n" << matrix1;
 
    std::cout << "\nMaximal element in this matrix is: "
              << matrix1.find_max_value();
    std::cout << "\nMinimal element in this matrix is: "
              << matrix1.find_min_value();
    std::cout << "\nTotal amount of all elements in this matrix is: "
              << matrix1.find_sum();
    std::cout << "\nAverage value in this matrix is: "
              << matrix1.find_avg_value() << "\n";
 
    std::cout << "\nThis is the 2nd matrix:\n" << matrix2;
 
    std::cout << "\nMatrices multyplying: \n" << matrix1 * matrix2;
 
    typedef Matrix Arr;
 
    Arr arr1(csize1);
    arr1.fill_rand(0, 9);
    std::cout << "\nAnd now we'll create the simple array:\n" << arr1;
    std::cout << "\nTotal amount of all elements in this array is: "
              << arr1.find_sum();
 
    return 0;
}