[c++] funzioni friend e ridefinizione degli operatori

[ndakota]

salve, sto facendo una classe che permette di usare oggetti frazione come tipi primitivi ma non capisco perchè se ridefinisco < così:

friend bool operator < (frazione a, frazione b);

bool operator < (frazione a, frazione b)
{
   if ( (a._num * b._den) < (b._num * a._den) )
      return true;

   else 
      return false;
}

perchè allora non posso fare il > così??

bool operator > (frazione a, frazione b);

bool frazione::operator > (frazione a, frazione b)
{
   return !(a<b);
}

perchè? perchè? < è già ridefinito.. invece riesco solo se faccio anche > friend implementato nello stesso modo del <.. uff.. grazie a tutti..

[cionci]

Perché è errato come l'hai scritto:

bool frazione::operator > (frazione b)
{
   return !(*this < b);  
}

In ogni caso è anche concettualmente sbagliato così, in quanto l'implementazione è quella del >= e non quella del maggiore. Infatti !(a<b) equivale a a>=b

[ndakota]

accidenti grazie.. la cosa del ! non l'avrei mai immaginata.. in ogni caso non mi è chiarissimo l'uso del *this sebbene sappia cos'è..

[cionci]

this è il puntatore all'oggetto corrente...giusto ?
*this cosa sarà ? Ovviamente l'oggetto corrente

Quindi se scrivi *this < b, passi all'operatore friend < come primo parametro l'oggetto corrente e come secondo b

[ndakota]

Originariamente inviato da cionci

this è il puntatore all'oggetto corrente...giusto ?
*this cosa sarà ? Ovviamente l'oggetto corrente

Quindi se scrivi *this < b, passi all'operatore friend < come primo parametro l'oggetto corrente e come secondo b

ok ma questo 'oggetto corrente' sarebbe?

int main()
{
   frazione a(4, 1), b(2, 1);

   bool x = a>b;
   
   return 0;
}

nella fattispecie il nostra a o che altro?

[cionci]

a...cioè l'istanza della classe di cui chiami l'operatore >.

[ndakota]

ecco il .h

Spoiler:

#ifndef FRAZIONE_H #define FRAZIONE_H class frazione { friend frazione operator + (frazione a, frazione b); friend frazione operator - (frazione a, frazione b); friend frazione operator * (frazione a, frazione b); friend frazione operator / (frazione a, frazione b); friend bool operator < (frazione a, frazione b); friend bool operator > (frazione a, frazione b); friend bool operator != (frazione a, frazione b); public: frazione operator += (frazione a); frazione operator -= (frazione a); frazione operator *= (frazione a); frazione operator /= (frazione a); bool operator == (frazione a); bool operator <= (frazione a); bool operator >= (frazione a); frazione(void); frazione(int a, int b); void visualizza(); void visualizza_s(); private: void semplifica(); int _num, _den; }; #endif

e il .cpp

Spoiler:

#include "frazione.h" #include <iostream> using namespace std; frazione operator + (frazione a, frazione b) { frazione c; c._num = a._num * b._den + a._den * b._num; c._den = a._den * b._den; return c; } frazione operator - (frazione a, frazione b) { frazione c; c._num = a._num * b._den - a._den * b._num; c._den = a._den * b._den; return c; } frazione operator * (frazione a, frazione b) { frazione c; c._num = a._num * b._num; c._den = a._den * b._den; return c; } frazione operator / (frazione a, frazione b) { frazione c; c._num = a._num * b._den; c._den = a._den * b._num; return c; } bool operator < (frazione a, frazione b) { if ( (a._num * b._den) < (b._num * a._den) ) return true; else return false; } bool operator > (frazione a, frazione b) { if ( (a._num * b._den) > (b._num * a._den) ) return true; else return false; } bool operator != (frazione a, frazione b) { return !(a == b); } frazione frazione::operator += (frazione a) { (*this) = (*this) + a; return *this; } frazione frazione::operator -= (frazione a) { (*this) = (*this) - a; return *this; } frazione frazione::operator *= (frazione a) { (*this) = (*this) * a; return *this; } frazione frazione::operator /= (frazione a) { (*this) = (*this) / a; return *this; } bool frazione::operator == (frazione a) { semplifica(); a.semplifica(); if ( (this->_num == a._num) && (a._den == this->_den) ) return true; else return false; } bool frazione::operator >= (frazione a) { return !(*this < a); } bool frazione::operator <= (frazione a) { return !(*this > a); } frazione::frazione(void) { } frazione::frazione(int a, int b) { _num = a; _den = b; } void frazione::visualizza_s() { semplifica(); if (_den == 1) cout<<_num<<endl; else cout << _num << " / " << _den << endl; } void frazione::visualizza() { if (_den == 1) cout<<_num<<endl; else cout << _num << " / " << _den << endl; } void frazione::semplifica() { int num = _den; for (int i = num; i > 1; i--) if ( (_num%i == 0) && (_den%i == 0) ) { _num /= i; _den /= i; } }

come ti sembra? si può migliorare? se si, come? dovrei aggiungerci qualcosa? grazie

[cionci]

class frazione
{
friend frazione operator + (const frazione a, const frazione b);
friend frazione operator - (const frazione a, const frazione b);
friend frazione operator * (const frazione a, const frazione b);
friend frazione operator / (const frazione a, const frazione b);
friend bool operator < (const frazione a, const frazione b);
friend bool operator > (const frazione a, const frazione b);
friend bool operator != (const frazione a, const frazione b);
public:
frazione &operator += (const frazione a);
frazione &operator -= (const frazione a);
frazione &operator *= (const frazione a);
frazione &operator /= (const frazione a);
bool operator == (const frazione a);
bool operator <= (const frazione a);
bool operator >= (const frazione a);
frazione(void);
frazione(int a, int b);
void visualizza();
void visualizza_s();
private:
void semplifica();
int _num, _den;
};

Il const mi sembra banale...nel senso che altrimenti non puoi passare variabili const agli operatori

Gli operatiro che fanno un'assegnazione devono sempre ritornare un reference all'oggetto stesso. Se non usi & ritorni una copa dell'oggetto non puoi ad esempio fare:

(a += b) += c;

in quanto a += b ritornerà un copia dell'oggetto a (tramite il costruttore di copia), ma non l'oggetto a stesso. Quindi andrai a richiamare += c su un oggetto temporaneo che verrà automaticamente liberato alla fine del blocco.