Критику в студию

//класс матриц
//matrix.h
/*проверка от дураков не предусмотрена*/
#pragma once
#include <iostream>
#include <fstream>
 
class matrix
{
public:
    matrix();//конструктор по умолчанию
    matrix(const int& , const int&);//конструктор, создает еденичную матрицу
    matrix(const int& , const int& , const double *array);//конструктор, берет значения из массива
    matrix::matrix(matrix &);//конструктор копирования
    ~matrix();//деструктор
 
protected:
    double *array;//массив матрицы
    int rows, columns;//количество столбцов и строк
    int precision;//точность вывода матрицы
 
public:
//операции с матрицей
    matrix& set(const double* );//функция изминения значения всех элементов матрицы
    matrix& eye();//делает матрицу еденичной(возможно не квадратной)
    matrix& zero();//делает матрицу нулевой
    matrix  transpose();//функция траспонирования, возвращает матрицу
//операторы
    matrix  operator*(const matrix& );//оператор умножения матриц
    matrix  operator*(const double&);//оператор умножение на дабл
    matrix  operator+(const matrix& );//оператор сложения матриц
    matrix  operator-(const matrix& );//оператор вычитания матриц
    matrix& operator=(const matrix& );//оператор присваивания
    double&      operator()(const int&, const int&);//оператор получения элемента матрицы
//дополнительные функции
    void householderDecomposition(matrix& Q, matrix& R);//алгоритм Хаусхолдера, изменяет параметры-ссылки
//функции установок параметров матрицы
    void output();//вывод матрицы на экран
    void output(std::ofstream* );//вывод матрицы в файл
    void SetSize (const int&, const int&);//изменение размеров
    int& Columns (void);//вывод количества столбцов
    int& Rows (void);//вывод количества строк
    void SetPrecison (const int &);//установка точности вывода
};

//класс матриц
//matrix.cpp
/*проверка от дураков не предусмотрена*/
#include "StdAfx.h"
#include "matrix.h"
#include <iomanip>
#include <math.h>
 
//конструктор по умолчанию
matrix::matrix():rows(0),columns(0),precision(2)
{
    array=NULL;
}
//конструктор еденичной матрицы
matrix::matrix(const int& rows, const int& columns) :
    rows(rows), columns(columns), precision(2)
{
    array = new double[rows * columns];
    this->eye();
}
//конструктор из массива
matrix::matrix(const int& rows, const int& columns, const double *array) :
    rows(rows), columns(columns), precision(2)
{
    this->array = new double[rows * columns];
    for (int i = 0; i < rows * columns; i++) this->array[i] = array[i];
}
//конструктор копирования
matrix::matrix(matrix &copy) 
{
    rows=copy.rows;
    columns=copy.columns;
    precision=copy.precision;
    array = new double [rows*columns];
    for( int i =0; i < rows * columns; ++i)
        array[i]=copy.array[i];
}
//деструктор
matrix::~matrix() 
{
    delete [] array;
}
//ввод данных из массива
matrix& matrix::set(const double *array) 
{
    for (int i = 0; i < rows * columns; i++) this->array[i] = array[i];
    return *this;
}
//моздание единичной матрицы
matrix& matrix::eye() 
{
    for (int j = 0; j < rows; j++)
        for (int i = 0; i < columns; i++)
            array[j * columns + i] = i == j ? 1.0 : 0.0;
    return *this;
}
//создание нулевой матрицы
matrix& matrix::zero() 
{
    for (int j = 0; j < rows; j++)
        for (int i = 0; i < columns; i++)
            array[j * columns + i] = 0.0;
    return *this;
}
//транспонированная матрица 
matrix matrix::transpose() 
{
    matrix temp(columns, rows);
    for (int j = 0; j < rows; j++)
        for (int i = 0; i < columns; i++)
            temp.array[i * rows + j] = array[j * columns + i];
    return temp;
}
//оператор умножения матриц
matrix matrix::operator*(const matrix& right_arg) 
{
    matrix temp(rows, right_arg.columns);
    for (int j = 0; j < rows; j++)
        for (int i = 0; i < right_arg.columns; i++) {
            temp.array[j * right_arg.columns + i] = 0.0;
            for (int k = 0; k < columns; k++)
                temp.array[j * right_arg.columns + i] += array[j * columns + k] * right_arg.array[k * right_arg.columns + i];
        }
    return temp;
}
//оператор умножения матрицы на число
matrix matrix::operator*(const double &s) 
{
    matrix temp(rows, columns);
    for (int j = 0; j < rows; j++)
        for (int i = 0; i < columns; i++)
            temp.array[j * columns + i] = array[j * columns + i] * s;
    return temp;
}
//оператор сложения матриц
matrix matrix::operator+(const matrix& right_arg) 
{
    matrix temp(rows, columns);
    for (int j = 0; j < rows; j++)
        for (int i = 0; i < columns; i++)
            temp.array[j * columns + i] = array[j * columns + i] + right_arg.array[j * columns + i];
    return temp;
}
//оператор вычитания матриц
matrix matrix::operator-(const matrix& right_arg) 
{
    matrix temp(rows, columns);
    for (int j = 0; j < rows; j++)
        for (int i = 0; i < columns; i++)
            temp.array[j * columns + i] = array[j * columns + i] - right_arg.array[j * columns + i];
    return temp;
}
//оператор присваивания
matrix& matrix::operator=(const matrix& right_arg) 
{
    if (rows * columns != right_arg.rows * right_arg.columns) {
        delete [] array;
        array = new double[right_arg.rows * right_arg.columns];
    }
    rows = right_arg.rows;
    columns = right_arg.columns;
 
    for (int i = 0; i < rows * columns; i++) array[i] = right_arg.array[i];
    return *this;
}
//оператор возвращения элемента
double& matrix::operator()(const int& i, const int& j)
{
    return (array[i*columns+j]);
}
//преобразование Хаусхолдера
void matrix::householderDecomposition(matrix& Q, matrix& R) 
{
    double mag, alpha;
    matrix x(rows, 1), u(rows, 1);
    matrix P(rows, rows), E(rows, rows);
 
    Q = matrix(rows, rows);
    R = *this;
 
    for (int i = 0; i < columns; i++) {
        x.zero(); u.zero();
        
        mag = 0.0;
        for (int j = i; j < rows; j++) {
            x.array[j] = R.array[j * columns + i];
            mag += x.array[j] * x.array[j];
        }
        mag = sqrt(mag);
        alpha = x.array[i] > 0 ? mag : -mag;
 
        mag = 0.0;
        for (int j = i; j < rows; j++) {
            u.array[j] = j == i ? x.array[j] + alpha : x.array[j];
            mag += u.array[j] * u.array[j];
        }
        mag = sqrt(mag);
 
        for (int j = i; j < rows; j++) u.array[j] /= mag;
 
        P = E - (u * u.transpose()) * 2.0;
 
        R = P * R;
        Q = Q * P;
    }
}
//вывод матрицы на экран
void matrix::output() 
{
    for (int j = 0; j < rows; j++) {
        for (int i = 0; i < columns; i++) {
            std::cout << std::fixed << std::setprecision(precision) << 
                std::setw(16) << array[j * columns + i] << "   ";
        }
        std::cout << std::endl;
    }
    std::cout << std::endl;
}
//вывод матрицы в файл
void matrix::output(std::ofstream* file)
{
    for (int j = 0; j < rows; j++) {
        for (int i = 0; i < columns; i++) {
            *file << std::fixed << std::setprecision(precision) << 
                std::setw(16) << array[j * columns + i] << "   ";
        }
        *file << std::endl;
    }
    *file << std::endl;
}
//изменение размеров матрицы
void matrix::SetSize (const int& rows, const int& columns)
{
    if (array!=NULL)
        delete[] array;
    array=new double[rows * columns];
    this->zero();
}
//возвращаение количества стобцов
int& matrix::Columns (void)
{
    return columns;
}
//возвращает количество строк
int& matrix::Rows (void)
{
    return rows;
}
//установка точности вывода
void matrix::SetPrecison(const int& precision)
{
    matrix::precision=precision;
}

matrix arr(5,5);
arr.Columns() = 4; //ok: теперь arr.columns равно 4

array[j * columns + i] = (i == j);

array = {0};

int& matrix::Columns

matrix::matrix():rows(0),columns(0),precision(2)
{
    array=NULL;
}

void matrix::SetSize (const int& rows, const int& columns)
{
    if (array!=NULL)
        delete[] array;
    array=new double[rows * columns];
    this->zero();
}

public:
...
protected:
...
public: