Newsgroup: it.comp.lang.c++
Titolo: Overloading dell'operatore di postincremento su oggetti allcoati dinamicamente

Salve,
Sto scrivendo alcune classi ed avrei bisogno di eseguire l'overloading
dell'operatore ++ di post-incremento; fin qui tutto ok; infatti, il
seguente codice funziona perfettamente:
Rotore R;
Rotore R2=R++;
Il problema è il seguente: se provo a rendere dinamica l'allocazione
di R e R2, il programma non funziona:
Rotore* R=new Rotore;
R++;           //<----------------ERRORE
Come ambiente di sviluppo uso DEV-C++ e il codice per l'overloading
dell'operatore è il seguente:
Rotore Rotore::operator++(int)          // post incremento
{
    Rotore r=*this;                    
    Ruota();                              
    return r;                               
}
Forse c'è un problema magari sul tipo di ritorno, ma come posso fare
per sistemarlo.
Grazie.
Ciao
Diego the dolphin
-- 
Parafrasando Cartesio, "Digito, ergo sum." (D. Zanga)

 
Essend R un puntatore a Rotore e non un Rotore, con R++ incrementi
il puntatore (facendo puntare R a un ipotetico Rotore memorizzato di
seguito a quello puntato, con effetti imprevedibili).
Quello che vuoi fare, invece, e' chiamare l'operatore di postincremento
sul rotore puntato da R, cioe su *R quindi:
 (*R)++;
Saluti,
Fabio
-- 
Posted from 
flopiano.mm.eutelsat.org
 [194.214.173.28] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 sul rotore puntato da R, cioe su *R quindi:
Oppure definire esternamente alla classe una overload di ++ che accetta come
parametro un R*.
--
Stefano

 R++;           //<----------------ERRORE
stai cercando di applicare l'operatore ++ ad un puntatore al Rotore, 
non al rotore stesso; tra l'altro la linea che segnali e' perfettamente 
valida, quindi non credo che il compilatore di segnali un errore (al 
massimo ti crasha il programma a runtime).
Per applicare l'operatore ++ al Rotore e non al suo puntatore devi 
dereferenziare quest'ultimo:
        *R++
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

parametro un R*.
Uhm non avevo mai pensato che si potesse fare (si puņ?) ma non mi
sembra una buona idea.
-- 
                    Marco Barisione (ICQ 84277092)
Se sei interessato alla creazione di un newsgroup generico in cui si
possa parlare di quei linguaggi di programmazione senza un gruppo
apposito vota per it.comp.lang su it.news.votazioni.

 sembra una buona idea.
No. Non si puň. Stefano l'ha sparata. Gli operatori possono essere
definiti solo per classi e per enum. Ottimo il diagnostico di Comeau a
questo proposito:
Comeau C/C++ 4.2.45.2 (Apr 12 2001 10:06:52) for ONLINE_EVALUATION
Copyright 1988-2001 Comeau Computing.  All rights reserved.
MODE:strict errors C++
"5650.c", line 4: error: nonmember operator requires a parameter with
class or
          enum type
  inline C* operator++(C*&r, int)
            ^
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

No. Non si puň.
Ah ecco mi sembrava :-)


         *R++
Purtroppo anche questa istruzione non fa quello che ti aspetteresti.
Infatti l'operator ++ ha precedenza su *, quindi
viene prima restituito il valore di *R, e poi viene incrementato R,
puntanto all'elemento successivo
qualcosa del genere:
 
        temp <- *R;     // uso questa notazione
        R <- R+1 ;      // per via dei miei problemi    
        return temp;    // con il carattere di uguale
che non e' esattamente quello che volevamo.
in breve, servono le parentesi:


Stefano wrote:

La cosa non ha molto senso...
Tanto per cominciare riusciresti provare a definire solo l'operatore di 
pre-incremento (per quello di post-incremento non sapresti che puntatore
tornare).
Ma ammesso e non concesso che il compilatore ti lasci passare un tentativo
del genere:
        R * operator++(R *r) {  ++(*r); return r; }
(Cosa che non ti lascera' fare visto che operator ++ vuole solo un argomento
di tipo class o enum)
Ti sei chiesto cosa succede a un codice del genere ?
R vec[10];
R* r (vec);  // qui dovrei usare l'uguale ma ho dei problemi ;-)
while(r < vec+10)
{
        r->qualcosa();
        ++r;
} 
facendo l'overload dell'operatore ++ sui puntatori cambieresti in maniera
disastrosa il comportamento di questo codice!


 disastrosa il comportamento di questo codice!
A parte che ci sono linguaggi in cui cambiare il comportamento
predefinito è possibile e se lo fai lo fai a tuo rischio, in C++ questo
non è possibile proprio per questo motivo.


 
Mi riferivo comunque all'operatore prefisso (quindi senza il 
secondo parametro int).
Per quello postfisso sarebbe stato necessario ritornare un indirizzo
a un R che puntava al vecchio valore di r. Cosa praticamente impossibile
(a meno di fare una new a perdere).
Per quello prefisso non so se il reference sarebbe stato necessario 
dovendo comunque operare sul valore puntato e non sul puntatore stesso.
Comunque sono discussioni di lana caprina (tanto non si puo fare)


 Infatti l'operator ++ ha precedenza su *, quindi
a dirla tutta l'operatore * unario e l'operatore ++ hanno la stessa 
precedenza, solo che associano a destra.
