Newsgroup: it.comp.lang.c++
Titolo: dubbio su ereditarietà e override

guardate questo codice:
long p;
class MAMMA {
public:
    void Create() { p = this; }
    virtual void foo() { }
};
class FIGLIA : public MAMMA {
public:
    void foo() { /* ... */ }
};
FIGLIA prova1;
prova1.Create();
MAMMA *pMamma = reinterpret_cast<MAMMA *> (p);
pMamma->foo();
è corretto?
con l'ultima linea di codice sono andato a chiamare il metodo ridefinito (FIGLIA::foo) o quello originale (MAMMA::foo)?
grazie
ciao
xaero -sto impazzendo :)-


Stai chiamando FIGLIA::foo, poiché MAMMA::foo è virtual. Se togli virtual,
allora chiami MAMMA::foo.
Ciao!

 Ciao!
ok, grazie.
ho realizzato negli ultimi minuti da dove sono spuntati fuori molti problemi :)
ciao
xaero

 sono sicuro al 100% che il programma lo compilo con un compilatore a 32
bit.. ;-)
Perche` mai "long p" dovrebbe essere ``piu` comodo'' di "void* p"...?  E
da dove viene la tua sicurezza che troverai senza problemi tutte queste
"comodita`" (per rimuoverle con gran fatica...) la prima volta che ti serve
ricompilare il programma su Alpha, Itanium, ecc, ecc?
La stessa (assurda) caccia alla "comodita`" costo` migliaia di anni-uomo
di lavoro sprecato al tempo (non poi cosi` lontano) del passaggio graduale
da macchine a 16 bit, ad altre a 32.  E` veramente bello vedere che la
natura umana non e` affatto cambiata e che sprechi dello stesso ordine
di grandezza sono prevedibili nell'attuale graduale passaggio a 64.
E` in nome della "comodita`" che, secondo me, si perpetrano oggi i
peggiori mostri di programmazione.  E` (ancora) una bella gara con
"l'ottimizzazione", che un tempo deteneva l'ambita palma, ma a mio
parere "la comodita`" ha ormai raggiunto e superato "l'ottimizzazione"
in questa classifica.
Alex (MVP Brainbench per il C++)

> Perche` mai "long p" dovrebbe essere ``piu` comodo'' di "void* p"...?  E
perchè GetWindowLong vuole un parametro long, tutto qua, così evito di scrivere (long)p... ;-)
dato che non sto facendo niente di sensato, ma solo esperimenti per verificare le mie conoscenze, e il programma che compilo appena
funziona va a finire nel dimenticatoio.
anche GetWindowLong sta per essere deprecata, e l'SDK dice di usare GetWindowLongPtr per la compatibilità con le architetture a
64bit.... ma finchè non ho bisogno di scrivere qualcosa di serio posso scrivere anche:
void main()
{
if(true) goto err;
exit(0);
err:
....
hehehe  ;oP
altrimenti quando devo scrivere un'applicazione a cui potrò dedicare in futuro un minimo di attenzione (o qualcuo al posto mio...)
cerco di mantenere uno stile il più pulito possibile, uso le macro TEXT("...") e i tipi di dati giusti, da bravo programmatore ;-)
capisco che il tuo disappunto non era rivolto a me, ma in generale a chi fa queste cose quotidianamente, xò ho sentito
l'irrefrenabile bisogno di mettere i puntini sulle i... :-D
ciao
xaero

....
ROTFL! Gran.. pezz.. di codic... ^____^
Luc.

A parte 'long p' il resto va bene.
devi togliere il reinterpret_cast: non fa quello che credi ed è
inutile, infatti esiste una conversione implicità da puntatore a
derivata a puntatore a base. Se vuoi renderlo esplicito, usa
static_cast. Se invece vuoi fare il processo inverso (da base a
derivata) usa dynamic_cast.
Anto
--
Antonio Cuni, 18 anni, studente
Brainbench Certification: 
Master C++: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
http://www.brainbench.com/transcript.jsp?pid=1301688

 derivata) usa dynamic_cast.
Anto', perdi colpi: p è un long!
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

 hehehe  ;oP
Nota che non e' portabile: un compilatore decente ti da errore per il void del
main
;-P
