lab2_3

#include "stdafx.h"
#include <iostream>
#include <stdlib.h>
#include <time.h>

using namespace std;

class Matrix{                                   // класс матрицы
        private:                                // ЗАКРЫТЫЕ ЧЛЕНЫ КЛАССА !
                double** mtptr;                 // указатель на указатель - будущий двумерный массив
                int size;                       // ранг матрицы ( размер). Матрицы будут тоьлко квадратные !
        public:                                 // ОТКРЫТЫЕ ЧЛЕНЫ КЛАССА !

                Matrix(int size);               // конструктор
                Matrix(const Matrix& ini);      // конструктор копий ( копирования )
                ~Matrix();                      // деструктор
                int getSize();                  // ф-ция получения размера матрицы
                void putData(int i, int j, double value);   // помещение данных в матрицу
                double getData (int i, int j);              // получение данных -//-
                void fillRandom(int scale);                 // заполнение случайно
                void fillByOrder(double num );              // заполнение по порядку
                void init(double num);                      // инициализация всей матрицы одним числом

                // перегруженный оператор +
                Matrix operator+ (const Matrix& right) const;   // складывает две матрицы п оправилам сложения матриц.
                                                                // возвращает результат
                friend Matrix operator+(const Matrix& right, double num); // складывает матрицу с числом
                friend Matrix operator+(double num, const Matrix& right); // складывает число с матрицей. ВОЗВРАЩАЕТ МАТРИЦУ !
                // перегруженный оператор -
                // аналогичен оператору +, только -  (с) КЭП
                friend Matrix operator-(double num, const Matrix& right) ;
                friend Matrix operator-(const Matrix& right, double num);
                Matrix operator- (const Matrix& right) const;
                //перегруженный оператор *
                Matrix operator* (const Matrix& right) const; // умножает 2 матрицы по правилам умножения матриц
                // перегруженные операторы ввода и вывода из потока.
                // возвращают ссылку на поток ввода/вывода
                friend istream& operator>>(istream& input, Matrix& obj);
                friend ostream& operator<<(ostream& output, Matrix& obj);
                // перегруженные операторы арифмет. присваивания -=, +=
                Matrix operator+=(const Matrix& rt)const;
                Matrix operator-=(const Matrix& rt)const;
                // перегруженный оператор присваивания
                Matrix& operator=(const Matrix& right);

};
/* Инициализация */
void Matrix::init(double num = 0){
    for (int i =0; i < this->getSize(); ++i)
        for(int j = 0; j < this->getSize(); ++j)
            mtptr[i][j] = num;
}
/*Помещение данных*/
void Matrix::putData(int i, int j, double num){
    mtptr[i][j] = num;  // aaaaaaaaaa?
}
/* Получение данных */
double Matrix::getData(int i, int j){
    return mtptr[i][j];
}
/*Деструктор */
Matrix::~Matrix(){
    for(int i = 0; i < size; ++i)
            delete[] mtptr[i];

        delete[] mtptr;
}
/* Получение размера */
int Matrix::getSize(){
        return size;
}
// Конструктор по умолчанию
Matrix::Matrix(int size = 2){

        this->size = size;
        //
        mtptr = new double*[size];
        for(int i = 0; i < size; ++i)
                mtptr[i] = new double[size];
        //
}
// Конструктор копирования ( копий) : создаёт копию переданного ему объекта
Matrix::Matrix(const Matrix &ini){ // copy constructor

    size = ini.size;
    // выделение памяти
    mtptr = new double*[size];
    for(int i = 0; i < size; ++i)
            mtptr[i] = new double[size];
    // copy
    for (int i = 0; i < size; ++i)
        for (int j = 0; j < size; ++j)
             mtptr[i][j] = ini.mtptr[i][j];

}
/* Перегруженный ввод из потока */
istream& operator>> (istream& inputStream, Matrix& obj){

        cout << "Fill matrix:" << endl;
        for (int i = 0; i < obj.getSize(); ++i)
            for (int j = 0; j < obj.getSize(); ++j)
                inputStream >> obj.mtptr[i][j];
                //inputStream >> obj.putData(i,j);


    return inputStream;
}
/* Перегруженный вывод из потока */
ostream& operator<< (ostream& outputStream,  Matrix& obj){

        cout << endl;
        for (int i = 0; i < obj.size; ++i){
            for (int j = 0; j < obj.size; ++j)
                    outputStream << obj.mtptr[i][j] << " ";
            cout << endl;
        }
    return outputStream;
}
/* Заполнение случайно */
void Matrix::fillRandom(int scale = 5){

    srand(time(NULL));
    for (int i = 0; i < size; ++i)
        for (int j = 0; j < size; ++j)
            this->mtptr[i][j] = rand() % scale;

}
/* Заполнение по порядку */
void Matrix::fillByOrder(double num = 1){

    for (int i = 0; i < size; ++i)
        for(int j = 0; j < size; ++j)
            this->mtptr[i][j] = num++;
}
/* Перегруженный + */
Matrix Matrix::operator+ (const Matrix& right) const {


    Matrix tmp( right );        // создаем копию объекта
    int tmpSize = right.size;
    if ( tmpSize == size ){     // проверяем размер
        for (int i = 0; i < tmpSize; ++i)
            for(int j = 0; j < tmpSize; ++j)
                tmp.putData(i,j, mtptr[i][j] + right.mtptr[i][j]);  // складываем
        }
    return tmp; // возвращаем результат
}
/* Перегруженный - */
Matrix Matrix::operator- (const Matrix& right) const {

    Matrix tmp( right );
    int tmpSize = right.size;
    if ( tmpSize == size ){
        for (int i = 0; i < tmpSize; ++i)
            for(int j = 0; j < tmpSize; ++j)
                tmp.putData(i,j, mtptr[i][j] - right.mtptr[i][j]);
        }
    return tmp;
}// end of operator-
Matrix Matrix::operator-= (const Matrix& right) const {

    int tmpSize = right.size;
    if ( tmpSize == size ){
        for (int i = 0; i < tmpSize; ++i)
            for(int j = 0; j < tmpSize; ++j)
                mtptr[i][j] -= right.mtptr[i][j];   // сохраняем результата в объекте
        }
    return *this;       // возвращаем ссылку на текущий объект для поддержки цепочек вида : а -= b -= c ;
}// end of operator-
/* Оператор += */
Matrix Matrix::operator+= (const Matrix& right) const {
    // аналогичен -=
    int tmpSize = right.size;
    if ( tmpSize == size ){
        for (int i = 0; i < tmpSize; ++i)
            for(int j = 0; j < tmpSize; ++j)
                mtptr[i][j] += right.mtptr[i][j];
        }
    return *this;
}// operator +=
/* Оператор *  */
Matrix Matrix::operator* (const Matrix& right) const {

    Matrix tmp( right );        // создаем временынй объект
    int tmpSize = right.size;   // проверяем размеры
    if ( tmpSize == size ){
        for (int i = 0; i < tmpSize; ++i){
            for( int j = 0; j < tmpSize; ++j){
                tmp.mtptr[i][j] = 0;    // сохраняем результата во временном объекте
                for (int k = 0 ; k < tmpSize; ++k)
                    tmp.mtptr[i][j] += mtptr[i][k] * right.mtptr[k][j];
                }
            }
        }
    return tmp; // возвращаем результат
}// end of operator*
/*
* Операторы +/- число
*
* Данные операторы реализованы через дружественные  классу Matrix ф-ции, т.к.
* необходим доступ как к объекту класса Matrix, так и к числу , кот. не явл. членом класса.
*
*/
Matrix operator+ (const Matrix& lft, double num){

    Matrix tmp( lft );
    for (int i = 0; i < lft.size; ++i)
        for(int j = 0; j < lft.size; ++j)
            tmp.mtptr[i][j] = lft.mtptr[i][j] + num;
    return tmp;
}
Matrix operator- (const Matrix& lft, double num) {

    Matrix tmp( lft );
    for (int i = 0; i < lft.size; ++i)
        for(int j = 0; j < lft.size; ++j)
            tmp.mtptr[i][j] = lft.mtptr[i][j] - num;
    return tmp;
}
Matrix operator- (double num, const Matrix& lft){

    Matrix tmp(  lft );
    for (int i = 0; i < lft.size; ++i)
        for(int j = 0; j < lft.size; ++j)
            tmp.mtptr[i][j] = num - lft.mtptr[i][j];

    return tmp;
}
Matrix operator+ (double num, const Matrix& lft){

    Matrix tmp(  lft );
    for (int i = 0; i < lft.size; ++i)
        for(int j = 0; j < lft.size; ++j)
            tmp.mtptr[i][j] = num + lft.mtptr[i][j];

    return tmp;
}
/* Оператор = ( присваивания ) */
Matrix& Matrix::operator=(const Matrix& right){

    if (&right != this){        // проверка на присваивание самому себе
        // очистка памяти
        if (right.size != size){
            for(int i = 0; i < size; ++i)
                delete[] mtptr[i];
            delete[] mtptr;
            // выделение памяти для копии массива
            size = right.size;

            mtptr = new double*[size];
            for(int i = 0; i < size; ++i)
                mtptr[i] = new double[size];
        }
        for (int i = 0; i < size; ++i)
            for (int j = 0; j < size; ++j)
                mtptr[i][j] = right.mtptr[i][j];
    }
    return *this;
}




///////////////////////////////
///////////////////////////////



int main(int argc, char *argv[])
{

    // Driver
    Matrix mtOne(4), mtTwo(4), mtThree(4);

    mtOne.fillRandom(9);
    mtTwo.fillRandom(4);
    mtThree.init(1);

    cout << "mtOne" << endl << mtOne << endl;
    cout << "mtTwo" << endl << mtTwo << endl;

    cout << "mtOne * mtTwo" << endl;
    cout << mtOne * mtTwo << endl;

    cout << "mtOne + mtTwo" << endl;
    cout << mtOne + mtTwo << endl;

    cout << "mtOne - 4 "<< endl;
    cout << mtOne  - 4 << endl;

    return 0;
}