перегрузка оператора + - C++ - Ответ 757472

/*(А[(B[3.7])] +( C +(~A)))
M[К] - возвращается сумма элементов столбцов М, имеющих минимальное значение < К.
~М - элементы столбцов переставить в обратном порядке, если первый элемент >0, в противном случае отсортировать по убыванию. 
М3=М1+М2 // M3[i,j] = M2[i,j] + M1[i,j], для элементов, расположенных по периметру матриц. Остальные элементы равны соответствующим элементам М2.*/
#include <iostream>
#include <iomanip>
#include <conio.h>
#include <windows.h>
#include <time.h>
using namespace std;
 
class Matrix
{
    protected:
        float *matr;
        int n,m;
        friend ostream& operator<<(ostream& o, Matrix& a);
    public:
        Matrix(int n, int m);
        ~Matrix() {delete[] matr; cout<<"matrix kill"<<endl;}
        Matrix(Matrix &a);
        Matrix& operator=(Matrix& a);
        Matrix& operator~();
        Matrix& operator+(Matrix &a);
        float operator[](float K);
        int _n() {return n;}
        int _m() {return m;}
        float _matr(int i, int j) {return *(matr+i*n+j);}
        void matr_(int i, int j, float el) {if((i>=0&&i<n)&&(j>=0&&j<m)) *(matr+i*n+j)=el;}
        friend void form(Matrix &a);
        friend Matrix operator+(float l, Matrix &a);
};
 
    Matrix::Matrix(int n, int m)
    {
        int i,a;
        cout<<"matrix done"<<endl;
        this->n=n;
        this->m=m;
        matr=new float[n*m];
        for(i=0;i<n;i++)
        for(a=0;a<m;a++)
        matr_(i,a,(-50+100.*rand()/(RAND_MAX+1)));
    }
    
    Matrix::Matrix(Matrix &a)
    {
        n=a.n;
        m=a.m;
        matr=new float[n*m];
        for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
        matr_(i,j,a._matr(i,j));
        cout<<"matrix copy"<<endl;
    }
    
    Matrix& Matrix::operator=(Matrix& a)
    {
        if(this!=&a)
        {
            n=a.n;
            m=a.m;
            if(matr!=NULL) delete[] matr;
            matr=new float[n*m];
            for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
            matr_(i,j,a._matr(i,j));
        }
        return *this;
    }
    
    float Matrix::operator[](float K)
    {
        float ret=0;
        for(int i=0;i<n;i++)
        {
            float min_t=32000;
            for(int j=0;j<m;j++)
            {
                if(_matr(j,i)<min_t) min_t=_matr(j,i);
            }
            if(min_t<K) for(int j=0;j<m;j++) ret+=_matr(j,i);
        }
        return ret;
    }
 
    Matrix& Matrix::operator~()
    {
        float tmp;
        int i,a,k;
        if(_matr(0,0)>0)
        {
            for(a=0;a<m;a++)
            {
                for(i=0;i<(int)(n/2);i++)
                {
                    tmp=_matr(i,a);
                    matr_(i,a,_matr(n-i-1,a));
                    matr_(n-i-1,a,tmp);
                }
            }
        }
        else
        {
            for(a=0;a<m;a++)
            {
                for(i=0;i<n-1;i++)
                {
                    for(k=i+1;k<n;k++)
                    {
                        if(_matr(i,a)<_matr(k,a))
                        {
                            tmp=_matr(i,a);
                            matr_(i,a,_matr(k,a));
                            matr_(k,a,tmp);
                        }
                    }
                }
            }
        }
        return *this;
    }
 
    Matrix& Matrix::operator+(Matrix &a)
    {
        int i,j;
        int m_m=_m()<a._m()?_m():a._m();
        int m_n=_n()<a._n()?_n():a._n();
        for(i=0;i<m_m;i++) 
        a.matr_(0,i,a._matr(0,i)+_matr(0,i));
        for(i=1;i<m_n;i++)
        a.matr_(i,m_m-1,a._matr(i,m_m-1)+_matr(i,m_m-1));
        for(i=m_m-2;i>=0;i--)
        a.matr_(m_n-1,i,a._matr(m_n-1,i)+_matr(m_n-1,i));
        for(i=m_n-2;i>0;i--)
        a.matr_(i,0,a._matr(i,0)+_matr(i,0));
        return a;
    }
 
void form(Matrix &a)
{
    for(int i=0;i<a._n();i++)
    for(int j=0;j<a._m();j++)
    a.matr_(i,j,100.*rand()/(RAND_MAX+1));
}
 
Matrix operator+(float l, Matrix &a)
{
    Matrix res(a);
    for(int i=0;i<a._n();i++)
    for(int j=0;j<a._m();j++)
    res.matr_(i,j,res._matr(i,j)+l);
    return res;
}
 
ostream& operator<<(ostream& o, Matrix& a)
{
    for(int i=0;i<a.n;i++)
    {
        for(int j=0;j<a.m;j++)
        o<<setw(9)<<setprecision(4)<<a._matr(i,j);
        o<<endl;
    }
    return o;
}
 
int main()
{
    srand((unsigned) time(NULL));
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    Matrix A(5,5);
    Matrix B(5,5);
    Matrix C(5,5);
    cout<<"Matrix A:"<<endl;
    cout<<A;
    cout<<"----------------------------------------------------------------------"<<endl;
    cout<<"Matrix B:"<<endl;
    cout<<B;
    cout<<"----------------------------------------------------------------------"<<endl;
    cout<<"Matrix C:"<<endl;
    cout<<C;
    cout<<"----------------------------------------------------------------------"<<endl;
    cout<<"B[3.7]="<<B[3.7]<<endl<<"A[(B[3.7])]="<<A[(B[3.7])]<<endl;
    cout<<"Matrix ~A:"<<endl;
    cout<<(~A); //операция выполняется нормально, но при присваивание другой матрицы этой (например B=(~A)) в матрицу В копируется матрица А, а не ~A
    cout<<"----------------------------------------------------------------------"<<endl;
    cout<<"Matrix C+(~A):"<<endl;
    cout<<(C+(~A));
    cout<<"----------------------------------------------------------------------"<<endl;
    getch();
    return 0;
}