[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]

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



#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



#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.