Ĺadny brzuch
mam taką klasę:
class Godzina { int godziny; int minuty; bool jutro; public: Godzina(int h, int m); //Operatory porownania bool operator==(Godzina &g); bool operator!=(Godzina &g); bool operator>(Godzina &g); bool operator<(Godzina &g); //Operatory arytmetyczne void operator+=(Godzina &g); void operator-=(Godzina &g); Godzina & operator+(Godzina &g); Godzina & operator-(Godzina &g); friend ostream & operator<<(ostream &ostr, Godzina &g); };
A oto definicje przeładowanych operatorów:
/****************************************** * OPERATORY POROWNANIA ******************************************/ bool Godzina::operator==(Godzina &g) { if(g.godziny == godziny && g.minuty == minuty && g.jutro == jutro) return true; return false; } bool Godzina::operator!=(Godzina &g) { return !(*this == g); } bool Godzina::operator>(Godzina &g) { int m1 = jutro * 24 * 60 + godziny * 60 + minuty; int m2 = g.jutro * 24 * 60 + g.godziny * 60 + g.minuty; if(m1 > m2) return true; return false; } bool Godzina::operator<(Godzina &g) { if(*this != g) return !(*this > g); else return false; } /****************************************** * OPERATORY ARYTMETYCZNE ******************************************/ void Godzina::operator+=(Godzina &g) { godziny += g.godziny; minuty += g.minuty; if(minuty >= 60) { godziny++; minuty -= 60; } if(godziny >= 24) { jutro = true; godziny -= 24; } } void Godzina::operator-=(Godzina &g) { godziny -= g.godziny; minuty -= g.minuty; if(minuty < 0) { godziny--; minuty += 60; } if(godziny < 0) { jutro = false; godziny += 24; } } Godzina & Godzina::operator+(Godzina &g) { Godzina tmp = *this; tmp += g; return tmp; } Godzina & Godzina::operator-(Godzina &g) { Godzina tmp = *this; tmp -= g; return tmp; }
I jest problem tego typu, że te operatory nie zawsze działają. Oto przykład:
Godzina f1(1, 0), f2(1, 15), f3(2, 0); Godzina a = f3 + f2 + f1 + f3 + f1; Godzina b = f1 + f3; Godzina f4(3, 3); if(a > b) cout << "TAK\n"; if(f3 + f2 + f1 + f3 + f1 > f1 + f3) cout << "TAK\n";
Teoretycznie program powinien 2 razy wypisać TAK, ponieważ linijka 5 i 6 działają tak samo. A program wypisuje TAK tylko dla linijki 5.
Nie wiecie może dlaczego tak się dzieje?
po pierwsze przy operatorach +/- nie zwracamy referencji:
Godzina operator+(Godzina &g); Godzina operator-(Godzina &g);
ale zwracamy ja przy operatorach +=/-=:
Godzina &operator+=(Godzina &g); Godzina &operator-=(Godzina &g);
zupelnie nie rozumiem tego operatora< ??
chodzi glownie o to:
int m1 = jutro * 24 * 60 + godziny * 60 + minuty; int m2 = g.jutro * 24 * 60 + g.godziny * 60 + g.minuty;
co robi "bool" z "intami" ??
zamiast tego to moze lepiej:
int m1 = godziny * 60 + minuty; int m2 = g.godziny * 60 + g.minuty; if( jutro ) m1+=24; if( g.jutro ) m2+=24;
edit@matilinks
FAKT, nie przyuwazylem tego od razu ;)
zwracam honor..
Użytkownik fernandez edytował ten post 11 grudzień 2007, 16:40
gdy h > 24, wtedy h = h - 24, zaś jutro = true :)
Po pierwsze kod konstruktora, po drugie operator > (chyba) ma większy priorytet niż operator +, a wtedy w if będziesz miał coś takeigo:
f1 > f1
Co zawsze zwraca wartość false, więc napis TAK nie wyświetli się.
//Edit
Jutro oznacza następny dzień. Podczas niejawnego rzutowania bool zostaje przekrztałcony na wartośc int, która w przypadku, gdy składowa jutro ma wartośc true wynosi 1, a gdy wynosi false - 0. Gdy jutro ma wartość true, do m1 lub m2 zostaje dodana wartość 1*24*60, czyli ilość minut w dobie
Użytkownik matilinks edytował ten post 11 grudzień 2007, 16:33
aha i jeszcze jedno..
operatory prownan stosuje sie z parametrami const:
bool operator==(const Godzina &g); bool operator!=(const Godzina &g); bool operator>(const Godzina &g); bool operator<(const Godzina &g);
poza tym wydaje mi sie ze co najwyzej dwa Ci sa potrzebne, bo jeden wyklucza drugi automatycznie..
calosc:
#include <iostream> using namespace std; class Godzina { int godziny; int minuty; bool jutro; public: Godzina(int h, int m):godziny(h),minuty(m){ if(h>=24) {h-=24; jutro=true;} }; //Operatory porownania bool operator==(const Godzina &g); bool operator!=(const Godzina &g); bool operator>(const Godzina &g); bool operator<(const Godzina &g); //Operatory arytmetyczne void operator+=(Godzina &g); void operator-=(Godzina &g); Godzina operator+(Godzina &g); Godzina operator-(Godzina &g); friend ostream & operator<<(ostream &ostr, Godzina &g); }; /****************************************** * OPERATORY POROWNANIA ******************************************/ bool Godzina::operator==(const Godzina &g) { if(g.godziny == godziny && g.minuty == minuty && g.jutro == jutro) return true; return false; } bool Godzina::operator!=(const Godzina &g) { return !(*this == g); } bool Godzina::operator>(const Godzina &g) { int m1 = godziny * 60 + minuty; int m2 = g.godziny * 60 + g.minuty; if( jutro ) m1+=24; if( g.jutro ) m2+=24; if(m1 > m2) return true; return false; } bool Godzina::operator<(const Godzina &g) { if(*this != g) return !(*this > g); else return false; } /****************************************** * OPERATORY ARYTMETYCZNE ******************************************/ void Godzina::operator+=(Godzina &g) { godziny += g.godziny; minuty += g.minuty; if(minuty >= 60) { godziny++; minuty -= 60; } if(godziny >= 24) { jutro = true; godziny -= 24; } } void Godzina::operator-=(Godzina &g) { godziny -= g.godziny; minuty -= g.minuty; if(minuty < 0) { godziny--; minuty += 60; } if(godziny < 0) { jutro = false; godziny += 24; } } Godzina Godzina::operator+(Godzina &g) { Godzina tmp = *this; tmp += g; return tmp; } Godzina Godzina::operator-(Godzina &g) { Godzina tmp = *this; tmp -= g; return tmp; } main() { Godzina f1(1, 0), f2(1, 15), f3(2, 0); Godzina a = f3 + f2 + f1 + f3 + f1; Godzina b = f1 + f3; //Godzina f4(3, 3); if(a > B) cout << "TAK1\n"; if(f3 + f2 + f1 + f3 + f1 > f1 + f3) cout << "TAK2\n"; }
u mnie sie kompiluje i dziala jak nalezy..
BTW - jakiego Ty kompilatora uzywasz?? u mnie nie bylo mozliwosci skompliowania nawet tego bez poprawki :>
@DOWN:
wpisuje tak i tez dziala, z reszta to bez roznicy, bo operator + ma wiekszy priorytet od >
Użytkownik fernandez edytował ten post 11 grudzień 2007, 16:46
dzięki, stary. u mnie twoja wersja też się kompiluje ładnie, teraz walczę z przerobieniem swojej :)
Mam jeszcze jedno pytanie poboczne, a nie chcę zakładać nowego tematu. Mam już klasę Godzina. Teraz robię 2 funkcje zwracające obiekt Godzina, np:
Godzina g1() { Godzina f(1, 0); return f; } Godzina g2() { Godzina f(2, 0); return f; }
i w main() piszę:
Godzina g = g1() + g2();
I tu wyskakuje błąd:
no match for 'operator+' in 'g1() + g2()'
candidates are: lot::Godzina lot::Godzina::operator+(lot::Godzina&)
I nie wiem o co mu chodzi :/
Użytkownik eugeniusz edytował ten post 11 grudzień 2007, 16:56
widzisz, blad zostal popelniony wczesniej..
pisalem o tym ze operatory +=/-= powinny byc inaczej napisane:
daje od razu calosc:
#include <iostream> using namespace std; class Godzina { int godziny; int minuty; bool jutro; public: Godzina(int h, int m):godziny(h),minuty(m){ if(h>=24) {h-=24; jutro=true;} }; //Operatory porownania bool operator==(const Godzina &g); bool operator!=(const Godzina &g); bool operator>(const Godzina &g); bool operator<(const Godzina &g); //Operatory arytmetyczne Godzina& operator+=(const Godzina &g); Godzina& operator-=(const Godzina &g); Godzina operator+(const Godzina &g); Godzina operator-(const Godzina &g); friend ostream & operator<<(ostream &ostr, Godzina &g); }; /****************************************** * OPERATORY POROWNANIA ******************************************/ bool Godzina::operator==(const Godzina &g) { if(g.godziny == godziny && g.minuty == minuty && g.jutro == jutro) return true; return false; } bool Godzina::operator!=(const Godzina &g) { return !(*this == g); } bool Godzina::operator>(const Godzina &g) { int m1 = godziny * 60 + minuty; int m2 = g.godziny * 60 + g.minuty; if( jutro ) m1+=24; if( g.jutro ) m2+=24; if(m1 > m2) return true; return false; } bool Godzina::operator<(const Godzina &g) { if(*this != g) return !(*this > g); else return false; } /****************************************** * OPERATORY ARYTMETYCZNE ******************************************/ Godzina& Godzina::operator+=(const Godzina &g) { godziny += g.godziny; minuty += g.minuty; if(minuty >= 60) { godziny++; minuty -= 60; } if(godziny >= 24) { jutro = true; godziny -= 24; } return *this; } Godzina& Godzina::operator-=(const Godzina &g) { godziny -= g.godziny; minuty -= g.minuty; if(minuty < 0) { godziny--; minuty += 60; } if(godziny < 0) { jutro = false; godziny += 24; } return *this; } Godzina Godzina::operator+(const Godzina &g) { Godzina tmp = *this; tmp += g; return tmp; } Godzina Godzina::operator-(const Godzina &g) { Godzina tmp = *this; tmp -= g; return tmp; } Godzina g1() { return Godzina(1, 0); } Godzina g2() { return Godzina(2, 0); } main() { /*Godzina f1(1, 0), f2(1, 15), f3(2, 0); Godzina a = f3 + f2 + f1 + f3 + f1; Godzina b = f1 + f3; Godzina f4(3, 3); if(a > B) cout << "TAK1\n"; if((f3 + f2 + f1 + f3 + f1) > (f1 + f3)) cout << "TAK2\n";*/ Godzina g = g1() + g2(); }
choc nieukrywam ze dziwne te funkcje, wolalbym od razu z konstruktora jechac ;) :P
Użytkownik fernandez edytował ten post 11 grudzień 2007, 21:34
Wielkie dzięki! :cheers:
zanotowane.pl doc.pisz.pl pdf.pisz.pl zsf.htw.pl
class Godzina { int godziny; int minuty; bool jutro; public: Godzina(int h, int m); //Operatory porownania bool operator==(Godzina &g); bool operator!=(Godzina &g); bool operator>(Godzina &g); bool operator<(Godzina &g); //Operatory arytmetyczne void operator+=(Godzina &g); void operator-=(Godzina &g); Godzina & operator+(Godzina &g); Godzina & operator-(Godzina &g); friend ostream & operator<<(ostream &ostr, Godzina &g); };
A oto definicje przeładowanych operatorów:
/****************************************** * OPERATORY POROWNANIA ******************************************/ bool Godzina::operator==(Godzina &g) { if(g.godziny == godziny && g.minuty == minuty && g.jutro == jutro) return true; return false; } bool Godzina::operator!=(Godzina &g) { return !(*this == g); } bool Godzina::operator>(Godzina &g) { int m1 = jutro * 24 * 60 + godziny * 60 + minuty; int m2 = g.jutro * 24 * 60 + g.godziny * 60 + g.minuty; if(m1 > m2) return true; return false; } bool Godzina::operator<(Godzina &g) { if(*this != g) return !(*this > g); else return false; } /****************************************** * OPERATORY ARYTMETYCZNE ******************************************/ void Godzina::operator+=(Godzina &g) { godziny += g.godziny; minuty += g.minuty; if(minuty >= 60) { godziny++; minuty -= 60; } if(godziny >= 24) { jutro = true; godziny -= 24; } } void Godzina::operator-=(Godzina &g) { godziny -= g.godziny; minuty -= g.minuty; if(minuty < 0) { godziny--; minuty += 60; } if(godziny < 0) { jutro = false; godziny += 24; } } Godzina & Godzina::operator+(Godzina &g) { Godzina tmp = *this; tmp += g; return tmp; } Godzina & Godzina::operator-(Godzina &g) { Godzina tmp = *this; tmp -= g; return tmp; }
I jest problem tego typu, że te operatory nie zawsze działają. Oto przykład:
Godzina f1(1, 0), f2(1, 15), f3(2, 0); Godzina a = f3 + f2 + f1 + f3 + f1; Godzina b = f1 + f3; Godzina f4(3, 3); if(a > b) cout << "TAK\n"; if(f3 + f2 + f1 + f3 + f1 > f1 + f3) cout << "TAK\n";
Teoretycznie program powinien 2 razy wypisać TAK, ponieważ linijka 5 i 6 działają tak samo. A program wypisuje TAK tylko dla linijki 5.
Nie wiecie może dlaczego tak się dzieje?
po pierwsze przy operatorach +/- nie zwracamy referencji:
Godzina operator+(Godzina &g); Godzina operator-(Godzina &g);
ale zwracamy ja przy operatorach +=/-=:
Godzina &operator+=(Godzina &g); Godzina &operator-=(Godzina &g);
zupelnie nie rozumiem tego operatora< ??
chodzi glownie o to:
int m1 = jutro * 24 * 60 + godziny * 60 + minuty; int m2 = g.jutro * 24 * 60 + g.godziny * 60 + g.minuty;
co robi "bool" z "intami" ??
zamiast tego to moze lepiej:
int m1 = godziny * 60 + minuty; int m2 = g.godziny * 60 + g.minuty; if( jutro ) m1+=24; if( g.jutro ) m2+=24;
edit@matilinks
FAKT, nie przyuwazylem tego od razu ;)
zwracam honor..
Użytkownik fernandez edytował ten post 11 grudzień 2007, 16:40
gdy h > 24, wtedy h = h - 24, zaś jutro = true :)
Po pierwsze kod konstruktora, po drugie operator > (chyba) ma większy priorytet niż operator +, a wtedy w if będziesz miał coś takeigo:
f1 > f1
Co zawsze zwraca wartość false, więc napis TAK nie wyświetli się.
//Edit
Jutro oznacza następny dzień. Podczas niejawnego rzutowania bool zostaje przekrztałcony na wartośc int, która w przypadku, gdy składowa jutro ma wartośc true wynosi 1, a gdy wynosi false - 0. Gdy jutro ma wartość true, do m1 lub m2 zostaje dodana wartość 1*24*60, czyli ilość minut w dobie
Użytkownik matilinks edytował ten post 11 grudzień 2007, 16:33
aha i jeszcze jedno..
operatory prownan stosuje sie z parametrami const:
bool operator==(const Godzina &g); bool operator!=(const Godzina &g); bool operator>(const Godzina &g); bool operator<(const Godzina &g);
poza tym wydaje mi sie ze co najwyzej dwa Ci sa potrzebne, bo jeden wyklucza drugi automatycznie..
calosc:
#include <iostream> using namespace std; class Godzina { int godziny; int minuty; bool jutro; public: Godzina(int h, int m):godziny(h),minuty(m){ if(h>=24) {h-=24; jutro=true;} }; //Operatory porownania bool operator==(const Godzina &g); bool operator!=(const Godzina &g); bool operator>(const Godzina &g); bool operator<(const Godzina &g); //Operatory arytmetyczne void operator+=(Godzina &g); void operator-=(Godzina &g); Godzina operator+(Godzina &g); Godzina operator-(Godzina &g); friend ostream & operator<<(ostream &ostr, Godzina &g); }; /****************************************** * OPERATORY POROWNANIA ******************************************/ bool Godzina::operator==(const Godzina &g) { if(g.godziny == godziny && g.minuty == minuty && g.jutro == jutro) return true; return false; } bool Godzina::operator!=(const Godzina &g) { return !(*this == g); } bool Godzina::operator>(const Godzina &g) { int m1 = godziny * 60 + minuty; int m2 = g.godziny * 60 + g.minuty; if( jutro ) m1+=24; if( g.jutro ) m2+=24; if(m1 > m2) return true; return false; } bool Godzina::operator<(const Godzina &g) { if(*this != g) return !(*this > g); else return false; } /****************************************** * OPERATORY ARYTMETYCZNE ******************************************/ void Godzina::operator+=(Godzina &g) { godziny += g.godziny; minuty += g.minuty; if(minuty >= 60) { godziny++; minuty -= 60; } if(godziny >= 24) { jutro = true; godziny -= 24; } } void Godzina::operator-=(Godzina &g) { godziny -= g.godziny; minuty -= g.minuty; if(minuty < 0) { godziny--; minuty += 60; } if(godziny < 0) { jutro = false; godziny += 24; } } Godzina Godzina::operator+(Godzina &g) { Godzina tmp = *this; tmp += g; return tmp; } Godzina Godzina::operator-(Godzina &g) { Godzina tmp = *this; tmp -= g; return tmp; } main() { Godzina f1(1, 0), f2(1, 15), f3(2, 0); Godzina a = f3 + f2 + f1 + f3 + f1; Godzina b = f1 + f3; //Godzina f4(3, 3); if(a > B) cout << "TAK1\n"; if(f3 + f2 + f1 + f3 + f1 > f1 + f3) cout << "TAK2\n"; }
u mnie sie kompiluje i dziala jak nalezy..
BTW - jakiego Ty kompilatora uzywasz?? u mnie nie bylo mozliwosci skompliowania nawet tego bez poprawki :>
@DOWN:
wpisuje tak i tez dziala, z reszta to bez roznicy, bo operator + ma wiekszy priorytet od >
Użytkownik fernandez edytował ten post 11 grudzień 2007, 16:46
dzięki, stary. u mnie twoja wersja też się kompiluje ładnie, teraz walczę z przerobieniem swojej :)
Mam jeszcze jedno pytanie poboczne, a nie chcę zakładać nowego tematu. Mam już klasę Godzina. Teraz robię 2 funkcje zwracające obiekt Godzina, np:
Godzina g1() { Godzina f(1, 0); return f; } Godzina g2() { Godzina f(2, 0); return f; }
i w main() piszę:
Godzina g = g1() + g2();
I tu wyskakuje błąd:
no match for 'operator+' in 'g1() + g2()'
candidates are: lot::Godzina lot::Godzina::operator+(lot::Godzina&)
I nie wiem o co mu chodzi :/
Użytkownik eugeniusz edytował ten post 11 grudzień 2007, 16:56
widzisz, blad zostal popelniony wczesniej..
pisalem o tym ze operatory +=/-= powinny byc inaczej napisane:
daje od razu calosc:
#include <iostream> using namespace std; class Godzina { int godziny; int minuty; bool jutro; public: Godzina(int h, int m):godziny(h),minuty(m){ if(h>=24) {h-=24; jutro=true;} }; //Operatory porownania bool operator==(const Godzina &g); bool operator!=(const Godzina &g); bool operator>(const Godzina &g); bool operator<(const Godzina &g); //Operatory arytmetyczne Godzina& operator+=(const Godzina &g); Godzina& operator-=(const Godzina &g); Godzina operator+(const Godzina &g); Godzina operator-(const Godzina &g); friend ostream & operator<<(ostream &ostr, Godzina &g); }; /****************************************** * OPERATORY POROWNANIA ******************************************/ bool Godzina::operator==(const Godzina &g) { if(g.godziny == godziny && g.minuty == minuty && g.jutro == jutro) return true; return false; } bool Godzina::operator!=(const Godzina &g) { return !(*this == g); } bool Godzina::operator>(const Godzina &g) { int m1 = godziny * 60 + minuty; int m2 = g.godziny * 60 + g.minuty; if( jutro ) m1+=24; if( g.jutro ) m2+=24; if(m1 > m2) return true; return false; } bool Godzina::operator<(const Godzina &g) { if(*this != g) return !(*this > g); else return false; } /****************************************** * OPERATORY ARYTMETYCZNE ******************************************/ Godzina& Godzina::operator+=(const Godzina &g) { godziny += g.godziny; minuty += g.minuty; if(minuty >= 60) { godziny++; minuty -= 60; } if(godziny >= 24) { jutro = true; godziny -= 24; } return *this; } Godzina& Godzina::operator-=(const Godzina &g) { godziny -= g.godziny; minuty -= g.minuty; if(minuty < 0) { godziny--; minuty += 60; } if(godziny < 0) { jutro = false; godziny += 24; } return *this; } Godzina Godzina::operator+(const Godzina &g) { Godzina tmp = *this; tmp += g; return tmp; } Godzina Godzina::operator-(const Godzina &g) { Godzina tmp = *this; tmp -= g; return tmp; } Godzina g1() { return Godzina(1, 0); } Godzina g2() { return Godzina(2, 0); } main() { /*Godzina f1(1, 0), f2(1, 15), f3(2, 0); Godzina a = f3 + f2 + f1 + f3 + f1; Godzina b = f1 + f3; Godzina f4(3, 3); if(a > B) cout << "TAK1\n"; if((f3 + f2 + f1 + f3 + f1) > (f1 + f3)) cout << "TAK2\n";*/ Godzina g = g1() + g2(); }
choc nieukrywam ze dziwne te funkcje, wolalbym od razu z konstruktora jechac ;) :P
Użytkownik fernandez edytował ten post 11 grudzień 2007, 21:34
Wielkie dzięki! :cheers: