Przeładowanie operatorów (dodawanie)

Question

mam taki prosty programik tworzący macierz o zadanych rozmiarach. Użytkownik z klawiatury przesyła żądaną wielkość tej macierzy, a program wpisuje wartości do tych macierzy. Dodatkowo posiadam klasę, a macierz to po prostu obiekt. Prześlę na razie w fragmentach kod . oto mój plik:

#include <iostream>
#include <time.h>
#include "macierz.h"

using namespace std;

int main()
{
    srand(time(NULL));

    int M,N;
    cout<<"1.Utworzenie tablicy"<<endl;
    cout << "Podaj ilosc wierszy: " << endl;
    cin>>M;
    cout << "Podaj ilosc kolumn: " << endl;
    cin>>N;
    Macierz m1(M,N);
    m1.wypisz();


    float **tablica;
    tablica=new float*[M];
    for(int i=0; i<M; i++)
    {
        tablica[i]=new float[N];
    }

    for(int i=0; i<M; i++)
    {
        for (int j=0; j<N; j++)
        {
            tablica[i][j]=float(i+1)/float(j+1);
        }
    }

    Macierz m2(M,N),m3(M,N),m4(M,N),m5(M,N);
    cout<<"Jednoargumentowy +(1)"<<endl;
    m3+1;
    m3.wypisz();
    cout<<endl;

    cout<<"Jednoargumentowy -(1)"<<endl;
    m4-1;
    m4.wypisz();
    cout<<endl;

    cout<<"Przypisania ="<<endl;
    m5=1;
    m5.wypisz();
    cout<<endl;

    cout<<"+"<<endl;
    m5=m2+m3;
    m5.wypisz();
    cout<<endl;

    return 0;
}

To mój plik macierz.h

#include <iostream>

using namespace std;

class Macierz
{
        public:
    int m, n, x, y;
    float **macierz;

    Macierz(int=0,int=0);
    Macierz(float**,int,int);
    Macierz(Macierz &);
    ~Macierz();

    Macierz& operator+(int);
    Macierz& operator-(int);
    Macierz& operator=(int);

    Macierz operator+(Macierz);


    int wiersze();
    int kolumny();
    void wypisz();
    void generujlosowe();
    void zmienrozmiar(int=0, int=0);
};

a to macierz.cpp

#include <iostream>
#include "macierz.h"

using namespace std;

Macierz::Macierz(int w, int k)
{
    m=w;
    n=k;
    macierz=new float*[m];

    for(int i=0; i<m; i++)
    {
        macierz[i]=new float[n];
    }

    for(int i=0; i<m; i++)
    {
        for(int j=0; j<n; j++)
        {
            macierz[i][j]=i+j;
        }
    }
    x=m;
    y=n;
}

Macierz::Macierz(float** tabl, int s, int k)
{
    m=s;
    n=k;
    macierz=new float*[m];

    for(int i=0; i<m; i++)
    {
        macierz[i]=new float[n];
    }
    for(int i=0; i<s; i++)
    {
        for(int j=0; j<k; j++)
        {
            macierz[i][j]=tabl[i][j];
        }
        cout<<endl;
    }
}

Macierz::~Macierz()
{
    for(int i = 0; i <m; ++i) {
        delete[] macierz[n];
    }
    delete[] macierz;
    macierz = NULL ;
}

void Macierz::wypisz()
{
    for(int i=0; i<m; i++)
    {
    for(int j=0; j<n; j++)
        {
            cout<<macierz[i][j]<<"   ";
        }
        cout<<endl;
    }
}
void Macierz::generujlosowe()
{
    float a = 0.0;
    float b = 1.0;
    for ( int i = 0 ; i < m ; i++) {
        for ( int k = 0 ; k < n ; k ++) {
            macierz[i][k] = ((float)rand() / RAND_MAX) * (b - a) + a;
        }
    }
}

void Macierz::zmienrozmiar(int d, int j)
{
    m=d;
    n=j;
    float **tablica;
    tablica=new float*[m];

    for(int i=0; i<m; i++)
    {
        tablica[i]=new float[n];
    }

    for(int i = 0; i <x; ++i) {
        delete[] macierz[y];
    }
    delete [] macierz;

    macierz=new float*[m];

    for(int i=0; i<m; i++)
    {
        macierz[i]=new float[n];
    }


}

Macierz::Macierz(Macierz &obiekt) {
    m = obiekt.m;
    n = obiekt.n;
    macierz = new float*[m];
    for ( int i = 0 ; i < m; i++) {
        macierz[i] = new float[n];
    }

    for ( int j = 0 ;j < m ; j++) {
        for ( int k = 0 ; k < n ; k++) {
            macierz[j][k] = obiekt.macierz[j][k];
        }
    }
}

int Macierz::wiersze()
{
    return m;
}

int Macierz::kolumny()
{
    return n;
}

Macierz& Macierz::operator+(int a1)
{
    for(int i=0; i<m; i++)
    {
        for(int j=0; j<n; j++)
        {
            macierz[i][j]+=a1;
        }
    }
}
Macierz& Macierz::operator-(int a2)
{
     for(int i=0; i<m; i++)
    {
        for(int j=0; j<n; j++)
        {
            macierz[i][j]-=a2;
        }
    }
}

Macierz& Macierz::operator=(int a3)
{
    for(int i=0; i<m; i++)
    {
        for(int j=0; j<n; j++)
        {
            macierz[i][j]=a3;
        }
    }
}

Macierz Macierz::operator+(Macierz c1)
{
    Macierz d(*this);
    for(int i=0; i<m; i++)
    {
        for(int j=0; j<n; j++)
        {
            d.macierz[i][j]+=c1.macierz[i][j];

        }
    }

    return d;
}

Noi m i n to są poprostu wartości pobrane z klawiatury czyli rozmiar tej macierzy. Przechowywane są one w klasie. Robiłem testy czy mi gdzieś nie zmienia tych wartości program i wszystko jest okej wartości sprawdzałem przed samym wywołaniem m5.wypisz(). Bo jeśli wpiszę wartości, ktore mają taki sam rozmiar na przykład 4 i 4 to wszystko ładnie dodaje natomiast jeśli zmienię wartości np 4 i 5 to juz sie sypie i wychodzą jakieś wartości "2.56507e-038" i nic nie działa albo jak wpiszę 4 i 9 to mi 2 pierwsze wiersze psuje a 2 kolejne są ok. 

Answer 1

1. Funkcje operator+(int) i operator-(int) nie powinny modyfikować obiektu. Zmień je na += i -=
2. Operatory powinny zwracać wartość (return *this)
3. Nieprawidłowo zwalniasz pamięć
4. Brakuje ci operatora Macierz& operator=(Macierz&). Operator automatycznie tworzony przez kompilator działa nieprawidłowo.
Jeżeli chcesz zobaczyć jak powinien wyglądać ten program zajrzyj tutaj ale najpierw postaraj się sam naprawić te problemy.

Comments

okej narazie spróbuję sam

1. Okej rozumiem natomiast w zadaniu mam napisane aby stworzyć przeładowanie operatorów:

• jednoargumentowy +
• jednoargumentowy -

Właśnie zastanawiam się jak to zrobić. Czy w pętli dać return macierz[i][j]+a1 ? Nie wiem też czy można tyle razy używać return.

2. Wszystkie operatory powinny zwracać return *this?

3. Szczerze nie wiem jaki mam błąd.

4. Co ten operator ma za zadanie zrobić? Jest mi on potrzebny do tego aby dodać 2 obiekty?

 

---

Operatory + i - nie powinny zwracać nową macierz a nie modyfikować istniejącą.
Wszystkie funkcje zwracające wartość muszą zwracać wartość! Jeżeli typem zwracanym przez funkcję jest referencja na typ to powinieneś zwracać *this lub refencję do jakiegoś obiektu nie tymczasowego.
Operator

Macierz operator=(Macierz& macierz)

ma za zadanie przeprowadzić poprawną operację przypisania jednej macierzy do drugiej.

Operator domyślny kopiuje wszystkie pola z przypisywanej macierzy wraz ze wskaźnikiem na tablicę.
W linii

m5=m2+m3;

najpierw jest wykonywany operator Macierz::operator+(Macierz&),
tworzony jest obiekt tymczasowy,
następnie wszystkie pola tego obiektu (m,n,x,y,macierz) są kopiowane do obiektu m5,
potem obiekt tymczasowy jest niszczony (zwalniana jest również pamięć zajmowana przez pole macierz).
W efekcie czego zmienna m5.macierz wskazuje na zwolnioną pamięć.
Operator Macierz::operator=(Macierz&) działa podobnie do konstruktora kopiującego Macierz::Macierz(Macierz&). Musi się tylko upewnić, że rozmiar macierzy jest zgodny (czyli usunąć ją i utworzyć na nowo jeżeli macierz, którą chcemy skopiować ma inny rozmiar) i na koniec zwraca referencję na obiekt.

---

Dzięki za wyjaśnienie i przesłanie kodu. Postaram się to wszystko zrozumieć. :D

---

Operatory + i - nie powinny zwracać nową macierz a nie modyfikować istniejącą.

A mógłbyś mi napisać jak to zrobić żeby operator był jednoargumentowy ale bez modyfikacji istniejącej macierzy?

---

class Class {
private:
    int mValue;
public:
    Class(int value) : mValue(value) {}
    Class operator+(const Class &other) const {
        return Class(mValue+other.mValue);
    }
};

 

Answer 2

Jeżeli nie musisz w zadaniu używać operatora new, to pomyśl o zastosowania kontenera std::vector. Zamiast surowego wskaźnika ( float** macierz; ) będziesz miał:

vector<vector<float>> macierz;

i dalej w konstruktorze

 macierz.resize(w);
 for( auto& row : macierz ) row.resize(k,0.0f);

Zaletą tego rozwiązani jest, że kontener std::vector ma już napisane konstruktory/operatory kopiujące,przenoszące. Nie musisz także implementować własnego destruktora, gdyż w momencie usunięcia obiektu wywołany będzie automatycznie destruktor kontenera.

Comments

Dziękuję :) Na pewno przyda się informacja.