Небольшой шаблонный класс matrix: комментарии/критика относительно кода с точки зрения правильности написания

#pragma once
 
//Шаблонный класс matrix. Позволяет создавать двумерные массивы стандартных типов любого размера, заполнять их определенными числами, последовательностью
// чисел, последовательностью чисел с инкрементом или заполнять рандомными числами. Все базовые арифметические операции перегружены. Оператор [][] перегружен.
// Также перегружены операторы ввода и вывода.
 
#include <iostream>
#include <random>
#include <algorithm>
#include <iomanip>
#include <type_traits>
#include <cstdlib>
#include <stdexcept>
 
template<typename T, size_t R, size_t C>
class matrix
{
    T** m_matrix;
    size_t m_rows, m_cols;
public:
    explicit matrix(T f = 0);
 
    matrix(const matrix&);
 
    template<typename U>
    matrix(const matrix<U,R,C>&);
 
    matrix(matrix&&);
 
    matrix& operator=(const matrix&);
 
    template<typename U>
    matrix& operator=(const matrix<U,R,C>&);
 
    matrix& operator=(matrix&&);
 
    ~matrix();
 
    size_t get_rows() const {return m_rows;}
    size_t get_cols() const {return m_cols;}
    
    const T* operator[](size_t index) const {return m_matrix[index];}
    T* operator[](size_t index) {return m_matrix[index];}
 
    T max_element() const;
    T min_element() const;
 
    void fill(T f = 0);
    void fill_random(int bottom = 0, int top = 100);
    void fill_iota(T f = 0, T increment = 0); // заполняет матрицу по порядку (0,1,2,3,...) или по порядку с инкрементом (0,3,6,9,...)
 
    template<typename U>
    friend std::ostream& operator<<(std::ostream&, const matrix&);
    
    template<typename U>
    friend std::istream& operator>>(std::istream&, matrix<U,R,C>&);
 
    // перегруженные арифметические операторы:
 
    // +
 
    template<typename U>
    matrix& operator+=(const matrix<U,R,C>&);                                                               //matrix+=matrix
 
    template<typename U>
    matrix& operator+=(const U& value);                                                                     //matrix+=!matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator+(const matrix<U,R,C>&);                       //matrix+matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator+(const U& value);                             //matrix+!matrix
 
    template<typename V, typename U, size_t R, size_t C>
    friend matrix<typename std::common_type<V,U>::type,R,C> operator+(const V&, const matrix<U,R,C>&);      //!matrix+matrix
 
    // -
 
    template<typename U>
    matrix& operator-=(const matrix<U,R,C>&);                                                               //matrix-=matrix
 
    template<typename U>
    matrix& operator-=(const U& value);                                                                     //matrix-=!matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator-(const matrix<U,R,C>&);                       //matrix-matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator-(const U& value);                             //matrix-!matrix
 
    template<typename V, typename U, size_t R, size_t C>
    friend matrix<typename std::common_type<V,U>::type,R,C> operator-(const V&, const matrix<U,R,C>&);      //!matrix-matrix
 
    // *
 
    template<typename U>
    matrix& operator*=(const matrix<U,R,C>&);                                                               //matrix*=matrix
 
    template<typename U>
    matrix& operator*=(const U& value);                                                                     //matrix*=!matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator*(const matrix<U,R,C>&);                       //matrix*matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator*(const U& value);                             //matrix*!matrix
 
    template<typename V, typename U, size_t R, size_t C>
    friend matrix<typename std::common_type<V,U>::type,R,C> operator*(const V&, const matrix<U,R,C>&);      //!matrix*matrix
 
    // /
 
    template<typename U>
    matrix& operator/=(const matrix<U,R,C>&);                                                               //matrix/=matrix
 
    template<typename U>
    matrix& operator/=(const U& value);                                                                     //matrix/=!matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator/(const matrix<U,R,C>&);                       //matrix/matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator/(const U& value);                             //matrix/!matrix
 
    template<typename V, typename U, size_t R, size_t C>
    friend matrix<typename std::common_type<V,U>::type,R,C> operator/(const V&, const matrix<U,R,C>&);      //!matrix/matrix
 
};
 
template<typename T, size_t R, size_t C>
matrix<T,R,C>::matrix(T f /* = 0 */) : m_rows(R), m_cols(C)
{
    if (m_rows == 0 || m_cols == 0)
    {
        m_rows = m_cols = 0;
        m_matrix = nullptr;
    }
    else
    {
        m_matrix = new T*[m_rows];
        std::generate_n(m_matrix, m_rows, [=]{return new T[m_cols];});
        fill(f);
    }
}
 
template<typename T, size_t R, size_t C>
matrix<T,R,C>::matrix(const matrix<T,R,C>& obj) : m_rows(R), m_cols(C)
{
    if (m_rows == 0 || m_cols == 0)
    {
        m_rows = m_cols = 0;
        m_matrix = nullptr;
    }
    else
    {
        m_matrix = new T*[m_rows];
        std::generate_n(m_matrix, m_rows, [=]{return new T[m_cols];});
        for (size_t i = 0;  i < m_rows; ++i)
        {
            for (size_t j = 0; j < m_cols; ++j)
                m_matrix[i][j] = obj[i][j];
        }
    }
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>::matrix(const matrix<U,R,C>& obj) : m_rows(R), m_cols(C)
{
    if (m_rows == 0 || m_cols == 0)
    {
        m_rows = m_cols = 0;
        m_matrix = nullptr;
    }
    else
    {
        m_matrix = new T*[m_rows];
        std::generate_n(m_matrix, m_rows, [=]{return new T[m_cols];});
        for (size_t i = 0;  i < m_rows; ++i)
        {
            for (size_t j = 0; j < m_cols; ++j)
                m_matrix[i][j] = obj[i][j];
        }
    }
}
 
template<typename T, size_t R, size_t C>
matrix<T,R,C>::matrix(matrix<T,R,C>&& obj) : m_rows(obj.m_rows), m_cols(obj.m_cols)
{
    m_matrix = obj.m_matrix;
    obj.m_rows = obj.m_cols = 0;
    obj.m_matrix = nullptr;
}
 
template<typename T, size_t R, size_t C>
matrix<T,R,C>::~matrix()
{
    std::for_each(m_matrix, m_matrix + m_rows, [](T*& array)
    {
        delete[] array;
    });
    delete[] m_matrix;
}
 
template<typename T, size_t R, size_t C>
matrix<T,R,C>& matrix<T,R,C>::operator=(const matrix<T,R,C>& obj)
{
    if (this == &obj)
        return *this;
    for (size_t i = 0;  i < m_rows; ++i)
    {
        for (size_t j = 0; j < m_cols; ++j)
            m_matrix[i][j] = obj.m_matrix[i][j];
    }
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator=(const matrix<U,R,C>& obj)
{
    for (size_t i = 0;  i < m_rows; ++i)
    {
        for (size_t j = 0; j < m_cols; ++j)
            m_matrix[i][j] = obj[i][j];
    }
    return *this;
}
 
template<typename T, size_t R, size_t C>
matrix<T,R,C>& matrix<T,R,C>::operator=(matrix<T,R,C>&& obj)
{
    m_matrix = obj.m_matrix;
    obj.m_cols = obj.m_rows = 0;
    obj.m_matrix = nullptr;
    return *this;
}
 
template<typename T, size_t R, size_t C>
void matrix<T,R,C>::fill(T f /* = 0 */)
{
    for (size_t i = 0; i<m_rows; ++i)
        for (size_t j = 0; j<m_cols; ++j)
            m_matrix[i][j] = f;
}
 
template<typename T, size_t R, size_t C>
void matrix<T,R,C>::fill_random(int bottop /* = 0 */, int top /* = 100 */)
{
    std::random_device rd;
    std::mt19937 gen(rd());
    if (bottop>top) std::swap(bottop, top);
    std::uniform_real_distribution<> distribution(bottop, top);
    for (size_t i = 0; i<m_rows; ++i)
        for (size_t j = 0; j<m_cols; ++j)
            m_matrix[i][j] = distribution(gen);
}
 
template<typename T, size_t R, size_t C>
void matrix<T,R,C>::fill_iota(T f /* = 0 */, T increment /* = 0 */)
{
    if (increment == 0)
    {
        for (size_t i = 0; i<m_rows; ++i)
            for (size_t j = 0; j<m_cols; ++j)
                m_matrix[i][j] = f++;
    }
    else
    {
        for (size_t i = 0; i<m_rows; ++i)
            for (size_t j = 0; j<m_cols; ++j)
            {m_matrix[i][j] = f; f+=increment;}
    }
}
 
template<typename T, size_t R, size_t C>
T matrix<T,R,C>::max_element() const
{
    if (!m_matrix) return 0;
    T maxEl = m_matrix[0][0];
    for (size_t i = 0;  i < m_rows; ++i)
    {
        for (size_t j = 0; j < m_cols; ++j)
        {
            if (maxEl<m_matrix[i][j]) maxEl = m_matrix[i][j];
        }
    }
    return maxEl;
}
 
template<typename T, size_t R, size_t C>
T matrix<T,R,C>::min_element() const
{
    if (!m_matrix) return 0;
    T minEl = m_matrix[0][0];
    for (size_t i = 0;  i < m_rows; ++i)
    {
        for (size_t j = 0; j < m_cols; ++j)
        {
            if (minEl>m_matrix[i][j]) minEl = m_matrix[i][j];
        }
    }
    return minEl;
}
 
template<typename U, size_t R, size_t C>
std::ostream& operator<<(std::ostream& os, const matrix<U,R,C>& obj)
{
    size_t width = 0;
    U n = std::max(abs(obj.max_element()), abs(obj.min_element()));
    for (; n>1; n /= 10)
        ++width;
 
    size_t cols = obj.get_cols();               // количество столбцов
    if (std::is_floating_point<U>::value)
    {
        width+=5;
        if (cols > 8)
        {
            cols = 8;
            os<<"Лимит на вывод для типов с плавающей точкой: не больше "<<cols<<" столбцов.\n"
                "Иначе возможен неправильный вывод\n\n";
        }
    }
    else
    {
        if (cols > 15)
        {
            cols = 15;
            os<<"Лимит на вывод для целых типов: не больше "<<cols<<" столбцов.\n"
                "Иначе возможен неправильный вывод\n\n";
        }
    }
    
    for (size_t i = 0;  i<obj.get_rows(); ++i)
    {
        for (size_t j = 0; j<cols; ++j)
            os<<std::setw(width)<<std::showpoint<<obj[i][j]<<" ";
        os<<"\n";
    }
    return os;
}
 
template<typename U, size_t R, size_t C>
std::istream& operator>>(std::istream& is, matrix<U,R,C>& obj)
{
    for (size_t i = 0;  i<obj.get_rows(); ++i)
    {
        for (size_t j = 0; j<obj.get_cols(); ++j)
        {
            std::cout<<"Введите ["<<i<<"]["<<j<<"]: ";
            while(!(is>>obj[i][j]))
            {
                is.clear();
                is.sync();
                std::cout<<"Ошибка при вводе! Введите повторно: ";
            }
        }
    }
    return is;
}
 
// перегруженные арифметические операторы:
 
// +
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator+=(const matrix<U,R,C>& rhs)          //matrix+=matrix
{
    for (size_t i = 0;  i<m_rows; ++i)
    {
        for (size_t j = 0; j<m_cols; ++j)
            m_matrix[i][j] += rhs[i][j];
    }
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator+=(const U& value)                     //matrix+=!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation +=");  //"Не совместимый тип при операции +=");
    for (size_t i = 0;  i<m_rows; ++i)
    {
        for (size_t j = 0; j<m_cols; ++j)
            m_matrix[i][j] += value;
    }
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator+(const matrix<U,R,C>& rhs)         //matrix+matrix
{
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix+=rhs;
    return ret_matrix;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator+(const U& value)                       //matrix+!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation +");  //"Не совместимый тип при операции +");
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix+=value;
    return ret_matrix;
}
 
template<typename V, typename U, size_t R, size_t C>
matrix<typename std::common_type<V,U>::type,R,C> operator+(const V& value, const matrix<U,R,C>& rhs)                        //!matrix+matrix
{
    static_assert(std::is_fundamental<V>::value, "Not compatible type at operation +");  //"Не совместимый тип при операции +");
    matrix<typename std::common_type<V,U>::type,R,C> ret_matrix(rhs);
    ret_matrix+=value;
    return ret_matrix;
}
 
// -
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator-=(const matrix<U,R,C>& rhs)          //matrix-=matrix
{
    for (size_t i = 0;  i<m_rows; ++i)
    {
        for (size_t j = 0; j<m_cols; ++j)
            m_matrix[i][j] -= rhs[i][j];
    }
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator-=(const U& value)                     //matrix-=!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation -=");  //"Не совместимый тип при операции -=.");
    for (size_t i = 0;  i<m_rows; ++i)
    {
        for (size_t j = 0; j<m_cols; ++j)
            m_matrix[i][j] -= value;
    }
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator-(const matrix<U,R,C>& rhs)         //matrix-matrix
{
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix-=rhs;
    return ret_matrix;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator-(const U& value)                       //matrix-!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation -");  //"Не совместимый тип при операции -");
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix-=value;
    return ret_matrix;
}
 
template<typename V, typename U, size_t R, size_t C>
matrix<typename std::common_type<V,U>::type,R,C> operator-(const V& value, const matrix<U,R,C>& rhs)                        //!matrix-matrix
{
    static_assert(std::is_fundamental<V>::value, "Not compatible type at operation -");  //"Не совместимый тип при операции -");
    matrix<typename std::common_type<V,U>::type,R,C> ret_matrix(rhs);
    ret_matrix-=value;
    return ret_matrix;
}
 
// *:
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator*=(const matrix<U,R,C>& rhs)          //matrix*=matrix
{
    for (size_t i = 0;  i<m_rows; ++i)
    {
        for (size_t j = 0; j<m_cols; ++j)
            m_matrix[i][j] *= rhs[i][j];
    }
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator*=(const U& value)                     //matrix*=!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation *=");  //"Не совместимый тип при операции *=");
    for (size_t i = 0;  i<m_rows; ++i)
    {
        for (size_t j = 0; j<m_cols; ++j)
            m_matrix[i][j] *= value;
    }
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator*(const matrix<U,R,C>& rhs)         //matrix*matrix
{
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix*=rhs;
    return ret_matrix;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator*(const U& value)                       //matrix*!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation *");  //"Не совместимый тип при операции *");
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix*=value;
    return ret_matrix;
}
 
template<typename V, typename U, size_t R, size_t C>
matrix<typename std::common_type<V,U>::type,R,C> operator*(const V& value, const matrix<U,R,C>& rhs)                        //!matrix*matrix
{
    static_assert(std::is_fundamental<V>::value, "Not compatible type at operation *");  //"Не совместимый тип при операции *");
    matrix<typename std::common_type<V,U>::type,R,C> ret_matrix(rhs);
    ret_matrix*=value;
    return ret_matrix;
}
 
//  /
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator/=(const matrix<U,R,C>& rhs)          //matrix/=matrix
{
    for (size_t i = 0;  i<m_rows; ++i)
    {
        for (size_t j = 0; j<m_cols; ++j)
        {
            if (rhs[i][j] == 0) throw std::runtime_error( "Exception occurred: Division by zero." );
        }
    }
    for (size_t i = 0;  i<m_rows; ++i)
    {
        for (size_t j = 0; j<m_cols; ++j)
            m_matrix[i][j] /= rhs[i][j];
    }
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator/=(const U& value)                     //matrix/=!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation /=");  //"Не совместимый тип при операции /=");
    if (value == 0) throw std::runtime_error( "Exception occurred: Division by zero." );
    for (size_t i = 0;  i<m_rows; ++i)
    {
        for (size_t j = 0; j<m_cols; ++j)
            m_matrix[i][j] /= value;
    }
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator/(const matrix<U,R,C>& rhs)             //matrix/matrix
{
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix/=rhs;
    return ret_matrix;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator/(const U& value)                       //matrix/!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation /");  //"Не совместимый тип при операции /");
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix/=value;
    return ret_matrix;
}
 
template<typename V, typename U, size_t R, size_t C>
matrix<typename std::common_type<V,U>::type,R,C> operator/(const V& value, const matrix<U,R,C>& rhs)             //!matrix/matrix
{
    static_assert(std::is_fundamental<V>::value, "Not compatible type at operation /");  //"Не совместимый тип при операции /");
    matrix<typename std::common_type<V,U>::type,R,C> ret_matrix(rhs);
    ret_matrix/=value;
    return ret_matrix;
}

#include "matrix.h"
#include <iostream>
#include <Windows.h>
 
int main()
{
    SetConsoleCP (1251); SetConsoleOutputCP (1251); //для русификации текста
    matrix<int,10,15>    m_int(1);                  //матрица типа int 10х15 заполнена 1-ми
    matrix<double,10,8> m_double(2.23);             //матрица типа double 10х8 заполнена числами 2,2300
    matrix<double,10,8> m_dou_rand;                 //матрица типа double 10х8 заполнена 0-ми
    m_dou_rand.fill_random(-100, 400);              //заполнение случайными числами от -100 до 400
    std::cout<<m_int<<"\n"<<m_double<<"\n"<<m_dou_rand<<"\n";
 
    matrix<int,15,11> m_int_15x11;
    m_int.fill(122);                                //заполнение числами 122
    m_int_15x11.fill_iota(-10, 2);                  //заполнение числами от -10 типа -10, -8, -6, -4, -2 и т. д.
    std::cout<<m_int_15x11<<"\n"<<m_double<<"\n";
 
    //m_int+=m_double;                              //ошибка, не совместимые матрицы
    m_double*=m_dou_rand;
    matrix<long,15,11> new_long_15_11(m_int_15x11);
    matrix<double,15,11> new_double_15_11;
    new_double_15_11 = m_int_15x11;
    system("pause");
    return 0;
}

#pragma once
 
//class matrix ver 2.0
//Шаблонный класс matrix. Позволяет создавать двумерные массивы стандартных типов и любого размера, заполнять их определенными числами, последовательностью
// чисел, последовательностью чисел с инкрементом или заполнять рандомными числами. Все базовые арифметические операции перегружены. Оператор [][] перегружен.
// Также перегружены операторы ввода и вывода. Реализована семантика переноса и совместимость с STL шаблонами
 
#include <iostream>
#include <random>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <type_traits>
#include <cstdlib>
#include <cctype>
#include <stdexcept>
 
template<typename T, size_t R, size_t C>
class matrix
{
    T** m_matrix;
    size_t m_rows, m_cols;
    size_t m_size;      //m_cols*m_rows
public:
    typedef T*          iterator;
    typedef const T*    const_iterator;
    iterator        begin()         {return m_matrix[0];}
    iterator        end()           {return m_matrix[0]+m_size;}
    const_iterator  cbegin() const  {return m_matrix[0];}
    const_iterator  cend()   const  {return m_matrix[0]+m_size;}
 
    explicit matrix(T f = 0);
 
    matrix(const matrix&);
 
    template<typename U>
    matrix(const matrix<U,R,C>&);
 
    matrix(matrix&&);
 
    matrix& operator=(const matrix&);
 
    template<typename U>
    matrix& operator=(const matrix<U,R,C>&);
 
    matrix& operator=(matrix&&);
 
    ~matrix();
 
    size_t get_rows() const {return m_rows;}
    size_t get_cols() const {return m_cols;}
 
    size_t size() const {return m_size;}
 
    const T* operator[](size_t index) const {return m_matrix[index];}
    T* operator[](size_t index) {return m_matrix[index];}
 
    T max_element() const;
    T min_element() const;
 
    void fill(T f = 0);
    void fill_random(int bottom = 0, int top = 100);
    void fill_iota(T f = 0, T increment = 0); // заполняет матрицу по порядку (0,1,2,3,...) или по порядку с инкрементом (0,3,6,9,...)
 
    template<typename U>
    friend std::ostream& operator<<(std::ostream&, const matrix&);
 
    template<typename U>
    friend std::istream& operator>>(std::istream&, matrix<U,R,C>&);
 
    // перегруженные арифметические операторы:
 
    // +
 
    template<typename U>
    matrix& operator+=(const matrix<U,R,C>&);                                                               //matrix+=matrix
 
    template<typename U>
    matrix& operator+=(const U& value);                                                                     //matrix+=!matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator+(const matrix<U,R,C>&);                       //matrix+matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator+(const U& value);                             //matrix+!matrix
 
    template<typename V, typename U, size_t R, size_t C>
    friend matrix<typename std::common_type<V,U>::type,R,C> operator+(const V&, const matrix<U,R,C>&);      //!matrix+matrix
 
    // -
 
    template<typename U>
    matrix& operator-=(const matrix<U,R,C>&);                                                               //matrix-=matrix
 
    template<typename U>
    matrix& operator-=(const U& value);                                                                     //matrix-=!matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator-(const matrix<U,R,C>&);                       //matrix-matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator-(const U& value);                             //matrix-!matrix
 
    template<typename V, typename U, size_t R, size_t C>
    friend matrix<typename std::common_type<V,U>::type,R,C> operator-(const V&, const matrix<U,R,C>&);      //!matrix-matrix
 
    // *
 
    template<typename U>
    matrix& operator*=(const matrix<U,R,C>&);                                                               //matrix*=matrix
 
    template<typename U>
    matrix& operator*=(const U& value);                                                                     //matrix*=!matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator*(const matrix<U,R,C>&);                       //matrix*matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator*(const U& value);                             //matrix*!matrix
 
    template<typename V, typename U, size_t R, size_t C>
    friend matrix<typename std::common_type<V,U>::type,R,C> operator*(const V&, const matrix<U,R,C>&);      //!matrix*matrix
 
    // /
 
    template<typename U>
    matrix& operator/=(const matrix<U,R,C>&);                                                               //matrix/=matrix
 
    template<typename U>
    matrix& operator/=(const U& value);                                                                     //matrix/=!matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator/(const matrix<U,R,C>&);                       //matrix/matrix
 
    template<typename U>
    matrix<typename std::common_type<T,U>::type,R,C> operator/(const U& value);                             //matrix/!matrix
 
    template<typename V, typename U, size_t R, size_t C>
    friend matrix<typename std::common_type<V,U>::type,R,C> operator/(const V&, const matrix<U,R,C>&);      //!matrix/matrix
 
};
 
template<typename T, size_t R, size_t C>
matrix<T,R,C>::matrix(T f /* = 0 */) : m_rows(R), m_cols(C), m_size(m_cols*m_rows)
{
    m_matrix = new T*[m_rows];
    m_matrix[0] = new T[m_size];
    for (size_t i = 1; i<m_rows; ++i)
        m_matrix[i] = m_matrix[i-1]+m_cols;
 
    fill(f);
}
 
template<typename T, size_t R, size_t C>
matrix<T,R,C>::matrix(const matrix<T,R,C>& obj) : m_rows(R), m_cols(C), m_size(m_cols*m_rows)
{
    m_matrix = new T*[m_rows];
    m_matrix[0] = new T[m_size];
    for (size_t i = 1; i<m_rows; ++i)
        m_matrix[i] = m_matrix[i-1]+m_cols;
 
    std::copy(obj.cbegin(), obj.cend(), begin());
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>::matrix(const matrix<U,R,C>& obj) : m_rows(R), m_cols(C), m_size(m_cols*m_rows)
{
    m_matrix = new T*[m_rows];
    m_matrix[0] = new T[m_size];
    for (size_t i = 1; i<m_rows; ++i)
        m_matrix[i] = m_matrix[i-1]+m_cols;
 
    std::copy(obj.cbegin(), obj.cend(), begin());
}
 
template<typename T, size_t R, size_t C>
matrix<T,R,C>::matrix(matrix<T,R,C>&& obj) : m_rows(obj.m_rows), m_cols(obj.m_cols), m_size(obj.m_size), m_matrix(obj.m_matrix)
{
    obj.m_rows = obj.m_cols = obj.m_size = 0;
    obj.m_matrix = nullptr;
}
 
template<typename T, size_t R, size_t C>
matrix<T,R,C>::~matrix()
{
    if (m_matrix)
    {
        delete[] m_matrix[0];
        delete[] m_matrix;
    }
    else
        delete[] m_matrix;
}
 
template<typename T, size_t R, size_t C>
matrix<T,R,C>& matrix<T,R,C>::operator=(const matrix<T,R,C>& obj)
{
    if (this == &obj)
        return *this;
    std::copy(obj.cbegin(), obj.cend(), begin());
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator=(const matrix<U,R,C>& obj)
{
    std::copy(obj.cbegin(), obj.cend(), begin());
    return *this;
}
 
template<typename T, size_t R, size_t C>
matrix<T,R,C>& matrix<T,R,C>::operator=(matrix<T,R,C>&& obj)
{
    m_matrix = obj.m_matrix;
    obj.m_cols = obj.m_rows = obj.m_size = 0;
    obj.m_matrix = nullptr;
    return *this;
}
 
template<typename T, size_t R, size_t C>
void matrix<T,R,C>::fill(T f /* = 0 */)
{
    for (T& val : *this) val = f;
}
 
template<typename T, size_t R, size_t C>
void matrix<T,R,C>::fill_random(int bottop /* = 0 */, int top /* = 100 */)
{
    std::random_device rd;
    std::mt19937 gen(rd());
    if (bottop>top) std::swap(bottop, top);
    std::uniform_real_distribution<> distribution(bottop, top);
    for (T& val : *this) val = distribution(gen);
}
 
template<typename T, size_t R, size_t C>
void matrix<T,R,C>::fill_iota(T f /* = 0 */, T increment /* = 0 */)
{
    if (increment == 0) {for (T& val : *this) val = f++;}
    else 
        for (T& val : *this) {val = f; f+=increment;}
}
 
template<typename T, size_t R, size_t C>
T matrix<T,R,C>::max_element() const
{
    return *std::max_element(cbegin(), cend());
}
 
template<typename T, size_t R, size_t C>
T matrix<T,R,C>::min_element() const
{
    return *std::min_element(cbegin(), cend());
}
 
template<typename U, size_t R, size_t C>
std::ostream& operator<<(std::ostream& os, const matrix<U,R,C>& obj)
{
    size_t width = 1;
    U n = std::max(abs(obj.max_element()), abs(obj.min_element()));
    for (; n>1; n /= 10)
        ++width;
 
    size_t cols = obj.get_cols();               // количество столбцов
    if (std::is_floating_point<U>::value)
    {
        width+=4;
        if (cols > 8)
        {
            cols = 8;
            os<<"Лимит на вывод для типов с плавающей точкой: не больше "<<cols<<" столбцов.\n"
                "Иначе возможен неправильный вывод\n\n";
        }
    }
    else
    {
        if (cols > 15)
        {
            cols = 15;
            os<<"Лимит на вывод для целых типов: не больше "<<cols<<" столбцов.\n"
                "Иначе возможен неправильный вывод\n\n";
        }
    }
 
    for (size_t i = 0;  i<obj.get_rows(); ++i)
    {
        for (size_t j = 0; j<cols; ++j)
            os<<std::setw(width)<<std::showpoint<<obj[i][j]<<" ";
        os<<"\n";
    }
    return os;
}
 
template<typename U, size_t R, size_t C>
std::istream& operator>>(std::istream& is, matrix<U,R,C>& obj)
{
    std::cout<<"Ручной ввод элементов. Для прекращения ввода нажмите Q\n\n";
    char ch;
    for (size_t i = 0;  i<obj.get_rows(); ++i)
    {
        for (size_t j = 0; j<obj.get_cols(); ++j)
        {
            std::cout<<"Введите ["<<i<<"]["<<j<<"]: ";
            while(!(is>>obj[i][j]))
            {
                is.clear();
                is>>ch;
                if (std::toupper(ch) == 'Q')
                {
                    is.sync();
                    return is;
                }
                is.sync();
                std::cout<<"Ошибка при вводе! Введите повторно: ";
            }
        }
    }
    return is;
}
 
// перегруженные арифметические операторы:
 
// +
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator+=(const matrix<U,R,C>& rhs)          //matrix+=matrix
{
    std::transform(begin(), end(), rhs.cbegin(), begin(), std::plus<T>());
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator+=(const U& value)                     //matrix+=!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation +=");  //"Не совместимый тип при операции +=");
    std::transform(begin(), end(), begin(), std::bind2nd(std::plus<T>(), value));
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator+(const matrix<U,R,C>& rhs)         //matrix+matrix
{
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix+=rhs;
    return ret_matrix;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator+(const U& value)                       //matrix+!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation +");  //"Не совместимый тип при операции +");
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix+=value;
    return ret_matrix;
}
 
template<typename V, typename U, size_t R, size_t C>
matrix<typename std::common_type<V,U>::type,R,C> operator+(const V& value, const matrix<U,R,C>& rhs)            //!matrix+matrix
{
    static_assert(std::is_fundamental<V>::value, "Not compatible type at operation +");  //"Не совместимый тип при операции +");
    matrix<typename std::common_type<V,U>::type,R,C> ret_matrix(rhs);
    ret_matrix+=value;
    return ret_matrix;
}
 
// -
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator-=(const matrix<U,R,C>& rhs)          //matrix-=matrix
{
    std::transform(begin(), end(), rhs.cbegin(), begin(), std::minus<T>());
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator-=(const U& value)                     //matrix-=!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation -=");  //"Не совместимый тип при операции -=");
    std::transform(begin(), end(), begin(), std::bind2nd(std::minus<T>(), value));
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator-(const matrix<U,R,C>& rhs)         //matrix-matrix
{
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix-=rhs;
    return ret_matrix;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator-(const U& value)                       //matrix-!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation -");  //"Не совместимый тип при операции -");
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix-=value;
    return ret_matrix;
}
 
template<typename V, typename U, size_t R, size_t C>
matrix<typename std::common_type<V,U>::type,R,C> operator-(const V& value, const matrix<U,R,C>& rhs)            //!matrix-matrix
{
    static_assert(std::is_fundamental<V>::value, "Not compatible type at operation -");  //"Не совместимый тип при операции -");
    matrix<typename std::common_type<V,U>::type,R,C> ret_matrix(value);
    ret_matrix-=rhs;
    return ret_matrix;
}
 
// *:
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator*=(const matrix<U,R,C>& rhs)          //matrix*=matrix
{
    std::transform(begin(), end(), rhs.cbegin(), begin(), std::multiplies<T>());
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator*=(const U& value)                     //matrix*=!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation *=");  //"Не совместимый тип при операции *=");
    std::transform(begin(), end(), begin(), std::bind2nd(std::multiplies<T>(), value));
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator*(const matrix<U,R,C>& rhs)         //matrix*matrix
{
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix*=rhs;
    return ret_matrix;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator*(const U& value)                       //matrix*!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation *");  //"Не совместимый тип при операции *");
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix*=value;
    return ret_matrix;
}
 
template<typename V, typename U, size_t R, size_t C>
matrix<typename std::common_type<V,U>::type,R,C> operator*(const V& value, const matrix<U,R,C>& rhs)            //!matrix*matrix
{
    static_assert(std::is_fundamental<V>::value, "Not compatible type at operation *");  //"Не совместимый тип при операции *");
    matrix<typename std::common_type<V,U>::type,R,C> ret_matrix(rhs);
    ret_matrix*=value;
    return ret_matrix;
}
 
//  /
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator/=(const matrix<U,R,C>& rhs)          //matrix/=matrix
{
    if (std::any_of(rhs.cbegin(), rhs.cend(), [](const T v){return v == 0;})) throw std::runtime_error( "Exception occurred: Division by zero." );
    std::transform(begin(), end(), rhs.cbegin(), begin(), std::divides<T>());
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<T,R,C>& matrix<T,R,C>::operator/=(const U& value)                     //matrix/=!matrix
{
    if (value == 0) throw std::runtime_error( "Exception occurred: Division by zero." );
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation /=");  //"Не совместимый тип при операции /=");
    std::transform(begin(), end(), begin(), std::bind2nd(std::divides<T>(), value));
    return *this;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator/(const matrix<U,R,C>& rhs)         //matrix/matrix
{
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix/=rhs;
    return ret_matrix;
}
 
template<typename T, size_t R, size_t C> template<typename U>
matrix<typename std::common_type<T,U>::type,R,C> matrix<T,R,C>::operator/(const U& value)                       //matrix/!matrix
{
    static_assert(std::is_fundamental<U>::value, "Not compatible type at operation /");  //"Не совместимый тип при операции /");
    if (value == 0) throw std::runtime_error( "Exception occurred: Division by zero." );
    matrix<typename std::common_type<T,U>::type,R,C> ret_matrix(*this);
    ret_matrix/=value;
    return ret_matrix;
}
 
template<typename V, typename U, size_t R, size_t C>
matrix<typename std::common_type<V,U>::type,R,C> operator/(const V& value, const matrix<U,R,C>& rhs)            //!matrix/matrix
{
    static_assert(std::is_fundamental<V>::value, "Not compatible type at operation /");  //"Не совместимый тип при операции /");
    matrix<typename std::common_type<V,U>::type,R,C> ret_matrix(value);
    ret_matrix/=rhs;
    return ret_matrix;
}

m_matrix = new T*[m_rows];
    m_matrix[0] = new T[m_rows*m_cols];
    for (size_t i = 1; i<m_rows; ++i)
        m_matrix[i] = m_matrix[i-1]+m_cols;

#include <iostream>
 
 
int main() {
   const std::size_t i = 1000000000;
   
   double a[ i ];
   
   return 0;
}

#include <iostream>
 
 
int main() {
   const std::size_t i = 1000000000;
   
   double *a = new double [ i ];
   
   return 0;
}

//---------------------------------------------------------------------------
void foo()
{
    double x[1000000]; // Ошибка "faulted with message: 'access violation at 0x004016c0: write of address 0x00030f4c'. Process Stopped." 
    //double* x= new double[1000000]; // Нет такой ошибки...
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
using namespace std;
 
cout<<"begin"<<endl;
foo();
 
system("pause");
return 0;
}
//---------------------------------------------------------------------------

    std::cout << "Vector C = A*B:" << std::endl;
    std::for_each(vector2d.begin(), vector2d.end(), [&ivec](std::vector <int> & curLine) -> std::vector <int>
    {
        std::for_each(ivec.begin(), ivec.end(), [&curLine](std::vector <int> & curRow) -> std::vector <int>
        {
            std::cout << std::endl << std::inner_product(
                curLine.begin(),
                curLine.end(),
                curRow.begin(),
                0,
                std::plus <int>(),
                std::multiplies <int>()
            ) << std::endl;
            return curRow;
        });
        return curLine;
    });