Newsgroup: it.comp.lang.c++
Titolo: Overloading degli operatori?!?!??!

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
***************************************
messaggio inviato tramite HostSearch.it
---------------------------------------
---> 
http://www.hostsearch.it/newsgroup
***************************************

ancora capito Overloading degli operatori  
Ti premette di poter usare i normali operatori anche con le tue
classi:
#include <iostream>
class Intero{
public:
    Intero(int value){
        val = value;
    }
    int get_val(){
        return val;
    }
    Intero operator+(Intero other){
        return Intero(val + other.val);
    }
private:
    int val;
};
int main(){
    Intero i = Intero(5) + Intero(7);
    std::cout << i.get_val() << std::endl;
    return 0;
}
Per avere più informazioni ti consiglio di leggerti un buon libro sul
C++, puoi trovarne un elenco su 
http://cpp.programmazione.it
.
-- 
Marco Barisione (ICQ 84277092)


Mi permetti di darti due consigli (in modo che tu possa evitare gli errori
da me commessi in passato)?
Utilizza quanto vuoi l'overloading degli operatori, che è una delle
potenzialità migliori (e + fiche) del c++ ma:
1 - NON utilizzarlo in progetti particolarmente complessi se ancora non hai
dimestichezza: puoi cascare in un sacco di trabocchetti che generano errori
difficilmente riconoscibili (in particolare se overloadi l'operatore = ) e
che ti fanno perdere il lavoro di giorni... (sigh, quanti ricordi!)
2 - Evita l'errore comunissimo di interpretare l'overloading degli operatori
come un modo "più fico" di chiamare una funzione... un famoso programmatore
C++, dopo aver visionato una nota libreria che utilizzava un istruzione tipo
Finestra += Controllo per aggiungere un controllo ad una finestra, suggerì
al suo creatore di "fare come fanno gli int", cioè di cercare il modo +
semplice per ottenere ciò che si vuole (ad es. utilizzare una funzione del
tipo Finestra.AggiungiControllo(&Controllo)  ); non fare come me che abusavo
in ogni maniera dell'overloading degli operatori: sovraccarica un operatore
+ solo per fare somme, e un operatore - solo per fare sottrazioni.
E ripeto: attenzione all'operatore = !!!!

che ti fanno perdere il lavoro di giorni... (sigh, quanti ricordi!)
DEVE essere definito in molti casi ad esempio:
#include <iostream>
class C{
public:
    C(){a = new int;}
    ~C(){
        std::cout << "Distruggo 'a' (" << a << ")" << std::endl;
        delete a;
    }
    int * a;
};
int main(){
    C c1, c2;
    c1 = c2;
    return 0;


 DEVE essere definito in molti casi ad esempio:
Sě, lo so benissimo. Tuttavia, per chi muove i primi passi, č meglio
ignorarlo (possibilmente evitando di dichiarare costruttori per copia oppure
dichiarandoli come privati senza definirli, per impedire esplicitamente la
copia).
Ti faccio solo alcuni esempi di errori che commettevo o che sono comunemente
commessi:
class A { [cut] }
A A::operator = (A& other)  // restituisce una copia anzichč un riferimento
                                            // dichiara "A& other" anzichč
"const A& other"
                                            // (ignorare il const causa
conflitti con i contenitori standard)
{
    if (this != &other) { [cut] }    // č un test che in genere č meglio
evitare
    ~A(); new (this) A(other);     // tecnica distruttore + placement new:
SBAGLIATISSIMA
    return *this;
}
Altro errore comune č implementare il costruttore per copia in funzione
dell'operatore =
(oppure operatori tipo += in funzione degli operatori +)
Prima di imparare a gestire con sicurezza l'overloading degli operatori, ho
dovuto leggere Exceptional C++ di Herb Sutter (a cui ti rimando per
riscontrare quanto da me qui affermato, e che comunque ti consiglio come
assolutamente "illuminante").
Il mio era semplicemente un invito alla prudenza e a fare le cose poco alla
volta :-) .