Overloading degli operatori?!?!??!

[Luc@s]

Io so come funzia l' Overloading delle funzioni ma, onestamente, nn ho ancora capito Overloading degli operatori

Qualcuno è cosi gentile e pio da spiegarmelo?????

Ringrazio anticipatamente chiunque mi sappia aiutare

P.S: se annettete degli esempi(anche banali ma ben COMMENTATI) nn sarebbe male

[cionci]

Un esempio banale è questo...

class prova {
	int a;
	int b;
public:
	prova() {a = b = 0;}  //costruttore di default
	prova(int aa, int bb) {a = aa; b = bb;}  //costruttore (int, int)
	prova(const prova &p) {a = p.a*p.a; b = p.b*p.b;}  //costruttore di copia
	//overloading dell'operatore +=
	prova &operator += (int aa) {a += aa; b += aa; return *this;}  //overloading 1
	prova &operator += (prova &p) {a += p.a; b += p.b; return *this;}  //overloading 2
};

void main()
{
	prova	a,			//costruttore di default
		b(1,2);		//costruttore (int, int)
	prova	c(b);		//costruttore di copia

	a += 2; //overloading 1 di +=
	a += b; //overloading 2 di +=
}

[Luc@s]

ho capito quasi tutto tranne

	//overloading dell'operatore +=
	prova &operator += (int aa) {a += aa; b += aa; return *this;}  //overloading 1
	prova &operator += (prova &p) {a += p.a; b += p.b; return *this;}  //overloading 2

P.S: ma in che contesto, e per quale motivo, bisogna usare l'overloading degli operatori???????? nn basta l'overloading delle funzioni?

[MickMacello]

Generalmente serve semplicemente a rendere più leggibile un programma e a risparmiarsi righe di codice. Se vuoi moltiplicare due matrici e mettere il risultato in C è meglio :

C=A*B

o

C=mult(A,B) ?

Inoltre l' overloading di alcuni operatori tipo [] rende possibile la scrittura di algoritmi generici che funzionano indipendentemente dal tipo di dati su cui lavorano.

[Luc@s]

meglio C=mult(A,B)

[Luc@s]

giusto per imparare bene, mi spiegate come funzia sto codice che mi ha passato un amico e perche nn ha usato una funzione??????

#include <stdio.h>
#include <iostream>

using namespace std;

class Persona
{
public:
	Persona( const string&, const string&, const unsigned short, const string& );

	friend ostream& operator<<( ostream& out, const Persona& pers );	// 'friend' per permettere all'operatore overloadato in 'ostream' di accedere ai membri privati di 'Persona'
	friend void main();	/* per accedere ai membri come una 'struct' (pubblica)
				lo faccio solo per questione di fretta, ma l'incapsulamento
				così va a farsi benedire.. per quest'esempio fregatene!  */

private:
	string pNome;
	string pCognome;

	unsigned short pEta;
	string pCitta;
}; // può bastare.. 

Persona::Persona( const string& nome, const string& cognome, const unsigned short eta, const string& citta ) : pNome( nome ), pCognome( cognome ), pEta( eta ), pCitta( citta )
{
}

ostream& operator<<( ostream& out, const Persona& pers )
{
	/* il metodo c_str() di 'string' restituisce la stringa sotto forma di char*
	questo perché in 'ostream' l'operatore << non ha un overload che accetti
	il tipo di dato 'string' */
	out << "La persona si chiama " << pers.pNome.c_str() << " " << pers.pCognome.c_str() << "." << endl;
	out << "Ha " << pers.pEta << " anni." << endl;
	out << "Vive nella citta' di " << pers.pCitta.c_str() << "." << endl;

	return out;
}

void main()
{
	Persona esempio( "Mario", "Rossi", 32, "Roma" );

	// C
	printf( "La persona si chiama %s %s.\n", esempio.pNome.c_str(), esempio.pCognome.c_str() );
	printf( "Ha %d anni.\n", esempio.pEta );
	printf( "Vive nella citta' di %s.\n\n", esempio.pCitta.c_str() );

	// C++
	cout << esempio << endl;
}

[cionci]

Originariamente inviato da Luc@s
[b]meglio C=mult(A,B)

No...con l'overloading degli operatori puoi fare C = A*B !!! Con almeno una fra A, B, C che deve essere una istanza di una classe...

Comunque mi sa che il tuo amico è andato un po' oltre...
Vedi...ogni operatore ha il suo modo + o - meno standard per farci l'overloading... L'operatore << si fa come ha fatto il tuo amico...il += si fa come l'ho fatto io (manca un const sui valori passati ai due operatori per essere puntigliosi)...
Quindi ti consiglio lo studio di un buon libro o di consultare almeno una buona guida...

Considera che per spiegare il codice che ha scritto il tuo amico (+ che altro per spiegare il perchè è stato scritto così e non in un altro modo) ci vogliono almeno 2 capitoli di un libro

[/\/\@®¢Ø]

Originariamente inviato da Luc@s
[b]meglio C=mult(A,B)

Nei casi semplici forse si', pero' quando le cose si complicano...

Confronta

string x,y,z,a;
a = x+"(" + y + "-" + z ")";

con

a = concat( x , concat( "(" , concat( y , concat( "-" , concat( z , ")" )))));

oppure

Matrix A,B,C;
Vector x,y,z;
...
A = B*y - B*C*z;

con

A = MsumM( MmulV(B,y) , MmulM( B , MmulV( C , z ) ) );

dove concat concatena le stringhe, MsumM somma matrici, MmulV moltiplica matrice per vettore e così via...

Secondo me non c'e' paragone !
Soprattutto nella lettura del codice scritto da un altro.

[/\/\@®¢Ø]

Originariamente inviato da Luc@s
[b]giusto per imparare bene, mi spiegate come funzia sto codice che mi ha passato un amico e perche nn ha usato una funzione??????

In C++ usare "<<" è il modo standard per scrivere l'output.
Questo perchè risulta comodo stampare su una stessa riga diversi tipi di valori:

int x=5;
float y=1.0;
string nome="Io";

cout << "Nome: " << nome << " . Il resto: (" << x << ',' << y << ')' << endl;

stampa la riga
Nome: Io . Il resto: (5,1.0)
Sovraccaricando questo operatori puoi inserire nella riga precedente anche un oggetto definito da te. Non e' poi molto diverso dai parametri di printf, pero' nel caso di "<<" se fai un errore lo individui durante la compilazione, con printf probabilmente avrai un bel crash.