перегрузка операторов. без подсказки никак..

[lisica198808]

перегрузка операторов..
ЗАДАНИЕ:
М2=М1-V – из М1 удалить строки, сумма элементов которых больше суммы элементов V.

где V- массив, М1 и М2 -матрицы.



То есть, если я правильно понимаю, в перегрузке нужно работать с преобразованными матрицами.

Строки и суммы элементов матриц я нашла..Понимаю что нужно поставить условие,чтоб удалять строки из матрицы, сумма элементов которых больше суммы элементов массива V.То есть преобразовываем матрицу..
то есть

 if (sum2>sum1)
    {for (int k=i; k<n-1; k++)
     for(int j=0;j<m;j++)
     x[k][j]=x[k+1][j];

, где sum2 - сумма элементов строк матрицы, а sum1- массива

А как правильно это сделать, чтоб потом использовать ее для перезагрузки - теряюсь: нужно новый класс создавать?или как?? подскажите что мне делать, как реализовать свою программку правильно..
свой предположительный вариант реализации этого условия я взяла в комментарии, т.к. не знаю верно ли, и на такой вариант выбивает ошибки

#include<stdio.h>
#include<iostream>/*zagolovochnij fajl s klassami, funktsijami i peremennimi dlja organizacii vvoda-vivoda v jazike programmirovaniya C++*/
#include <stdlib.h>
using namespace std;/*ob'javlenie prostranstva imen  std.*/

class massiv
        { float *a; int stroka; float sum1;int n;
         public: 
         massiv();
         void vvod();/*vvod elementov*/
         void vivod();
         void sum_el();
         void vivod_stroka();
         
         ~massiv(){delete[]a; puts("rabotal destryktor\n");}    /*{puts("rabotal destryktor massiva\n")*/;
         };
 //==============================================//        
  massiv::massiv()
    {printf("\nvvedite razmer massiva n: ");
     scanf("%d",&n);
     puts("\nrabotal konstruktor massiva\n");    
    }  
    
//==============================================//    
  void massiv::vvod()/*vvod elementov*/
    {a=new float[n];
     for(int i=0;i<n;i++)
      {*(a+i)=rand() % 101 - 50;printf("%3.2f ", *(a+1));
      }/*ot -50 do 50  ili  rand() % 201 - 100 ot -100 do 100 */
    } 
  
//==============================================//        
  void massiv::sum_el()
    {sum1=0;/*snachala summa v stroke=0*/
     for(int i=0;i<n;i++)/*idem po strokam*/
      {sum1+=*(a+i);}/*summiruyem yeye elementy*/
    }
//==============================================//       
  void massiv::vivod_stroka()
    {printf("\nsumma elementov massiva= %3.2f",sum1); printf("\n");}

//========================================//==============================================//======//  


class matrica:public massiv
        { float *x; int n,m; 
          public:float sum2; int stroka;
          matrica(); 
          void vvod();
          void vivod(); 
          void sum_el();
          void vivod_stroka();
         /* void yslovie();*/
           
          ~matrica(){delete[]x; puts("rabotal destryktor matrici\n");}                
        };
//==============================================//     
  matrica::matrica()
    {printf("\nvvedite razmernost n*m: ");
     scanf("%d %d",&n,&m);
     puts("\nrabotal konstruktor matrici\n");    
    } 
//==============================================//    
  void matrica:: vvod()    
    {x=new float [n*m]; 
     for(int i=0;i<n;i++)
     for(int j=0;j<m;j++)
      *(x+i*m+j)=rand() % 101 - 50;
    }
//==============================================//
  void matrica::vivod()/*vivodit matrici na ekran*/
    {printf("\nmatrica:\n"); 
     for(int i=0; i<n; i++)
     {for(int j=0;j<m;j++)
       cout<<*(x+i*m+j)<< " ";cout << "\n";}
    }
//==============================================//    
  void matrica::sum_el()
    {for(int i=0;i<n;i++)/*idem po strokam*/
      {sum2=0;/*snachala summa v stroke=0*/
      for(int j=0;j<m;j++)/*idem po stroke*/
       sum2+=*(x+i*m+j);/*summiruyem yeye elementy*/
      stroka=i+1; 
      printf("\nsumma= %3.2f v stroke %d ",sum2, stroka); }printf("\n");
    } 
    
 /*----------------------------------------------------------------*/

/*void matrica:: yslovie()  
 {  int i;   if (sum2>sum1)
    {for (int k=i; k<n-1; k++)
     for(int j=0;j<m;j++)
     *(x+k*m+j)=*(x+i*m+1+j);     
     }
 }*/


int main()
{
massiv V;
V.vvod();
V.sum_el();
V.vivod_stroka();
system("pause");  
  
matrica A;
A.vvod();
A.vivod();
A.sum_el();
/*A.yslovie() ;*/
system("pause"); 
}

[Son Of Pain]

Все проще. Для перегрузки operator- у матрицы нужно в класс добавить метод:

matrica operator-(const massiv &mas)

.
Он должен создать новую матрицу; записать в нее только те строки, у которых сумма <= суммы переданного массива; вернуть эту матрицу. А потом в мейне просто написать

matrica res = A - V;

И да, почему матрица наследуется от массива? )

[lisica198808]

Сообщение от Son Of Pain

И да, почему матрица наследуется от массива? )

это я затупила..экспериментировала по разному.. а когда код копировала - неувидела, что не стерла..

Сообщение от Son Of Pain

Все проще. Для перегрузки operator- у матрицы нужно в класс добавить метод:

matrica operator-(const massiv &mas)

.
Он должен создать новую матрицу; записать в нее только те строки, у которых сумма <= суммы переданного массива; вернуть эту матрицу. А потом в мейне просто написать

matrica res = A - V;

то есть описание метода должно быть примерно такое::

matrica matrica::operator-(const massiv &p)
  
 {  matrica rez;
    if (sum2>p.sum1)
    {for (int k=i; k<n-1; k++)
     for(int j=0;j<m;j++)
     rez.x[k][j]=x[k+1][j];
     }
     return rez;
 }
 }

?????
на такой вариант у меня ошибки выбивает((((
93 `i' undeclared (first use this function)
95 invalid types `float[int]' for array subscript
я наверное не понимаю главного для себя- как передавать правильно массивы и матрицы в перегрузке, если так не верно..

[Son Of Pain]

Примерно так, только сначала ж нужно определить, сколько строк в результирующей матрице останется; потом выделить память в ней; и только потом копировать.

[lisica198808]

сделала вот так:

#include<stdio.h>
#include<iostream>/*zagolovochnij fajl s klassami, funktsijami i peremennimi dlja organizacii vvoda-vivoda v jazike programmirovaniya C++*/
#include <stdlib.h>
using namespace std;/*ob'javlenie prostranstva imen  std.*/
 
class massiv
        { float *a; int stroka; int n;
         public: float sum1;
         massiv();
         void vvod();/*vvod elementov*/
         void vivod();
         void sum_el();
         void vivod_stroka();
         
         ~massiv(){delete[]a; puts("rabotal destryktor\n");}    /*{puts("rabotal destryktor massiva\n")*/;
         };
 //==============================================//        
  massiv::massiv()
    {printf("\nvvedite razmer massiva n: ");
     scanf("%d",&n);
     puts("\nrabotal konstruktor massiva\n");    
    }  
    
//==============================================//    
  void massiv::vvod()/*vvod elementov*/
    {a=new float[n];
     for(int i=0;i<n;i++)
      {*(a+i)=rand() % 101 - 50;printf("%3.2f ", *(a+1));
      }/*ot -50 do 50  ili  rand() % 201 - 100 ot -100 do 100 */
    } 
  
//==============================================//        
  void massiv::sum_el()
    {sum1=0;/*snachala summa v stroke=0*/
     for(int i=0;i<n;i++)/*idem po strokam*/
      {sum1+=*(a+i);}/*summiruyem yeye elementy*/
    }
//==============================================//       
  void massiv::vivod_stroka()
    {printf("\nsumma elementov massiva= %3.2f",sum1); printf("\n");}
 
//========================================//==============================================//======//  
 
 
class matrica
        { float *x; int n,m; 
          public:
          float sum2; int stroka; float *b;int kol_str;
          matrica(); 
          void vvod();
          void vivod(); 
          void sum_el();
          void vivod_stroka();
          
          matrica operator-(const massiv &mas);
           
          ~matrica(){delete[]x; puts("rabotal destryktor matrici\n");}                
        };
//==============================================//     
  matrica::matrica()
    {printf("\nvvedite razmernost n*m: ");
     scanf("%d %d",&n,&m);
     puts("\nrabotal konstruktor matrici\n");    
    } 
//==============================================//    
  void matrica:: vvod()    
    {x=new float [n*m]; 
     for(int i=0;i<n;i++)
     for(int j=0;j<m;j++)
      *(x+i*m+j)=rand() % 101 - 50;
    }
//==============================================//
  void matrica::vivod()/*vivodit matrici na ekran*/
    {printf("\nmatrica:\n"); 
     for(int i=0; i<n; i++)
     {for(int j=0;j<m;j++)
       cout<<*(x+i*m+j)<< " ";cout << "\n";}
    }
//==============================================//    
  void matrica::sum_el()
    { kol_str=0;
      for(int i=0;i<n;i++)/*idem po strokam*/
      {sum2=0;/*snachala summa v stroke=0*/
      for(int j=0;j<m;j++)/*idem po stroke*/
       sum2+=*(x+i*m+j);/*summiruyem ee elementy*/
      stroka=i+1; kol_str++;
      printf("\nsumma= %3.2f v stroke %d ",sum2, stroka); }printf("\n");
      printf("koli4estvo strok novoj matrici = %d",kol_str);printf("\n");
    } 
 /*----------------------------------------------------------------*/
matrica matrica::operator-(const massiv &p)
  
 {  matrica rez;
    *b=new float [kol_str*m];/*Videlim pamjat' dlja rezyltiryjywej  matrici*/
    if (sum2<p.sum1)        /*esli summi strok po matrice men'we summi massiva*/
    {for (int i=0; i<kol_str; i++)  /*zapiwem stroki v novij massiv*/
     for(int j=0;j<m;j++)
     rez.*b=*(x+i*m+j);                 
     }
     return rez;
 }
 
 
int main()
{
massiv V;
V.vvod();
V.sum_el();
V.vivod_stroka();
system("pause");  
  
matrica A;
A.vvod();
A.vivod();
A.sum_el();
matrica rez = A - V;
system("pause"); 
}

выбивает ошибки в методе

96 cannot convert `float*' to `float' in assignment
100 `((matrica*)this)->matrica::b' cannot be used as a member pointer, since it is of type `float*'
Не правильно передаю данные что ли в методе?Или чего-то недописала?? Как сделать чтоб работало нормально?

[Helloween]

На колене, идея думаю понятна.

#include "stdio.h"
#include "stdlib.h"
#include "time.h"
#include "memory"
#include "string"


template <class T>
class TArray
{
private:
    T* _values;
    unsigned long _size;    
public:
    TArray(unsigned long size) : _size(size)
    {
        _values = (T*)malloc(_size * sizeof(T));
        memset(_values, 0, sizeof(T) * _size);
    }

    ~TArray()
    {
        if(_values)
            free(_values);
        _size = 0;
    }
    
    void set(unsigned long indx, T val)
    {
        if(_values && indx < _size)        
            _values[indx] = val;                    
    }

    T sum()
    {
        T _sum = 0;
        for(unsigned long i = 0; i < _size; i++)        
            _sum += _values[i];
        return _sum;
    }

    void print(const char* fmt)    
    {
        for(unsigned long i = 0; i < _size; i++)
            printf(fmt, _values[i]);
        printf("\n");
    }
};

template <class T>
class Matrix
{
private:
    T** _arr;
    unsigned long _sizex;
    unsigned long _sizey;
private:
    void init()
    {
        _arr = (T**)malloc(_sizex * sizeof(T*));        
        for(unsigned long i = 0; i < _sizey; i++)
        {
          _arr[i] = (T*)malloc(_sizey * sizeof(T));
          memset(_arr[i], 0, _sizey * sizeof(T));
        }
    }
    void release()
    {
        if(_arr)
        {
            for(unsigned long i = 0; i < _sizey; i++)
                free(_arr[i]);
            free(_arr);
        }
    }
    T _sum(unsigned long idx)
    {
        T s_sum = 0;
        for(unsigned long i = 0; i < _sizey; i++)        
          s_sum += _arr[idx][i];        
        return s_sum;
    }
public:
    Matrix(unsigned long sizex, unsigned long sizey) : _sizex(sizex), _sizey(sizey)
    {
        init(); 
    }
    ~Matrix()
    {
        release();
    }

    void set(unsigned long i, unsigned long j, T val)
    {
        _arr[i][j] = val;
    }

    Matrix& operator-(TArray<T>& arr)
    {
        T a_sum = arr.sum();                
        unsigned long i = 0;
        for(;;)
        {
          if(i >= _sizex)
              break;
          if(_sum(i) > a_sum)
          {
              for(unsigned long j = i; j < _sizex - 1; j++)
              {
                  memcpy(_arr[j], _arr[j+1], _sizey * sizeof(T));                  
              }
              free(_arr[_sizex--]);
          }
          i++;
        }
        return *this;
    } 
    void print(const char* fmt)
    {
        for(unsigned long i = 0; i < _sizex; i++)
        {
            for(unsigned long j = 0; j < _sizey; j++)
            {
                printf(fmt, _arr[i][j]);             
            }
            printf("\n");
        }
    }
};

typedef TArray<int> ITArray;
typedef Matrix<int> IMatrix;

int main(int argc, char *argv[])
{        
    ITArray _a(10);
    unsigned long seed = time(NULL);
    srand(seed);
    for(unsigned long i = 0; i < 10; i++)
        _a.set(i,(rand() % 10 + 1));
    _a.print("%5d");
    printf("sum:%d\n",_a.sum());
    IMatrix _b(5,5);
    for(unsigned long i = 0; i < 5; i++)
        for(unsigned long j = 0; j < 5; j++)
            _b.set(i,j,rand()% 20 + 1);
    _b.print("%4d");
    IMatrix c = _b - _a;
    printf("\n");
    c.print("%4d");
    return 0;
}

[lisica198808]

вот как я сделала

#include<stdio.h>
#include<iostream>/*zagolovochnij fajl s klassami, funktsijami i peremennimi dlja organizacii vvoda-vivoda v jazike programmirovaniya C++*/
#include <stdlib.h>
using namespace std;/*ob'javlenie prostranstva imen  std.*/
 
class massiv
        { float *a; int stroka; int n;
         public: float sum1;
         massiv();
         void vvod();/*vvod elementov*/
         void vivod();
         void sum_el();
         void vivod_stroka();
         
         ~massiv(){delete[]a; puts("rabotal destryktor\n");}    /*{puts("rabotal destryktor massiva\n")*/;
         };
 //==============================================//        
  massiv::massiv()
    {printf("\nvvedite razmer massiva n: ");
     scanf("%d",&n);
     puts("\nrabotal konstruktor massiva\n");    
    }  
    
//==============================================//    
  void massiv::vvod()/*vvod elementov*/
    {a=new float[n];
     for(int i=0;i<n;i++)
      {*(a+i)=rand() % 101 - 50;printf("%3.2f ", *(a+1));
      }/*ot -50 do 50  ili  rand() % 201 - 100 ot -100 do 100 */
    } 
  
//==============================================//        
  void massiv::sum_el()
    {sum1=0;/*snachala summa v stroke=0*/
     for(int i=0;i<n;i++)/*idem po strokam*/
      {sum1+=*(a+i);}/*summiruyem yeye elementy*/
    }
//==============================================//       
  void massiv::vivod_stroka()
    {printf("\nsumma elementov massiva= %3.2f",sum1); printf("\n");}
 
//========================================//==============================================//======//  
 
 
class matrica
        { float *x; int n,m; 
          public:
          float sum2; int stroka; float *b;int kol_str;
          matrica(); 
          void vvod();
          void vivod(); 
          void sum_el();
          void vivod_stroka();
          
          matrica operator-(massiv &mas);
           void reshenie();
          ~matrica(){delete[]x; puts("rabotal destryktor matrici\n");}                
        };
//==============================================//     
  matrica::matrica()
    {printf("\nvvedite razmernost n*m: ");
     scanf("%d %d",&n,&m);
     puts("\nrabotal konstruktor matrici\n");    
    } 
//==============================================//    
  void matrica:: vvod()    
    {x=new float [n*m]; 
     for(int i=0;i<n;i++)
     for(int j=0;j<m;j++)
      *(x+i*m+j)=rand() % 101 - 50;
    }
//==============================================//
  void matrica::vivod()/*vivodit matrici na ekran*/
    {printf("\nmatrica:\n"); 
     for(int i=0; i<n; i++)
     {for(int j=0;j<m;j++)
       cout<<*(x+i*m+j)<< " ";cout << "\n";}
    }
//==============================================//    
  void matrica::sum_el()
    { kol_str=0;
      for(int i=0;i<n;i++)/*idem po strokam*/
      {sum2=0;/*snachala summa v stroke=0*/
      for(int j=0;j<m;j++)/*idem po stroke*/
       sum2+=*(x+i*m+j);/*summiruyem ee elementy*/
      stroka=i+1; kol_str++;
      printf("\nsumma= %3.2f v stroke %d ",sum2, stroka); }printf("\n");
      printf("koli4estvo strok novoj matrici = %d",kol_str);printf("\n");
    } 
 /*----------------------------------------------------------------*/
matrica matrica::operator-(massiv &p)
{
    matrica rez;
 
    printf("Rabotaet minus\n");
    rez.x=new float [kol_str*m];/*Videlim pamjat' dlja rezyltiryjywej  matrici*/
    if (sum2<p.sum1)        /*esli summi strok po matrice men'we summi massiva*/
    {for (int i=0; i<kol_str; i++)  /*zapiwem stroki v rezyltiryjywyjy  matricy*/
     for(int j=0;j<m;j++)
     rez.x=(x+i*m+j);
     }
     return rez;
}
 
void matrica::reshenie()
{
for(int i=0;i<n;i++)
{
cout<<"\n" ;
for(int j=0;j<m;j++)
cout<< *(x+i*m+j)<<"  "; }
} 
 
 
int main()
{
massiv V;
V.vvod();
V.sum_el();
V.vivod_stroka();
system("pause");  
  
matrica A;
A.vvod();
A.vivod();
A.sum_el();
 
matrica rez = A - V;
rez.reshenie(); 
printf("\n");
system("pause"); 
}

но я теперь не понимаю правильно ли идет перегрузка оператора, потому что после вывода массива и матрицы, суммы их строк программа просит чтоб снова ввели значения для матрицы, задает матрицу новую по ходу, а не вставляет и выводит нужные строки, элементы . Это ведь наверно неправильно?
И почему-то неправильно считается сумма элементов массива.

[Son Of Pain]

1) в строке

printf("%3.2f ", *(a+1));

вместо единицы должна быть буква i;
2) Вынеси запрос размерности матрицы из конструктора куда-то, хотя бы в функцию ввода
3)

rez.x=(x+i*m+j);

- в левой части тоже ж нужно по индексам обращаться;
4) Количество строк в новой матрице считается не так, как должно быть по заданию;
5) Еще там что-то было, забыл )