Newsgroup: it.comp.lang.c++
Titolo: Override

Salve
potreste dirmi come fare l'override dei metodi?
Ad es.:
#include <iostream>
class base {
        public :
        void metodo () {
                std::cout << "base" << std::endl;
        };
};
class der : public base {
        public :
        void metodo () {
                std::cout << "der" << std::endl;
        };
};
base obj;
int main () {
        obj.metodo();
        return 0;
}
Devo fare in modo che l'output sia "der" cioč chiamare il medoto della 
classe der con l'oggetto della classe "base".
Grazie
-- 
Luigi
--
bug windows [5] = {"95", "98", "NT", "Me", "2000"};

classe der con l'oggetto della classe "base".
base *obj_p ;
der Mia_Derivata ;
int main() {
 
    obj_p = &MiaDerivata ;
    obj_p->metodo() ;
    return 0 ;
}     
--
Walkie...@Libero.It (ICQ# 8143647)

     obj_p->metodo() ; // E ottenere il metodo di quell'indirizzo, cioč 
della classe derivata, giusto?


 classe der con l'oggetto della classe "base".
Ciao!
per il tuo problema devi usare il polimorfismo...
le tue classi diventano:
 class base {
         public :
         virtual void metodo () {//<--------------------notare virtual!
                 std::cout << "base" << std::endl;
         };
 };
 class der : public base {
         public :
         void metodo () {
                 std::cout << "der" << std::endl;
         };
 };
e il main:
 base* obj;//ma perche' globale? :-)
 int main () {
         obj=new der();
         obj->metodo();
         return 0;
 }
--
Ciao by Beppe

          return 0;
Aspetta, ma non era come ha detto Walkie Talkie?
cioč 
base* ptr;
der obj;
ptr = &obj;
ptr -> metodo();
?????
forse sono equivalenti?
grazie


 forse sono equivalenti?
Prima una precisazione senno' mi ca**iano! prima della conclusione del main
ci va "delete obj;" :-)
per la tua domanda:
alla fine, __in questo caso__, il risultato e' analogo, pero' mentre con il
mio metodo utilizzi l'heap
(infatti ci va la delete!) con il metodo di Walkie Talkie si usa la memoria
"locale" della funzione main.
In pratica sono due metodi diversi di uso del polimorfismo...
piacerebbe anche a me sapere da qualcuno piu' ferrato di me le possibili
differenze "teoriche" dei due metodi!
--
Ciao by Beppe

ci va "delete obj;" :-)
Il tuo codice contiene un errore piu' grave di quello.
Se dimentichi di fare la delete quello che succede e'
che l'oggetto verra' "dimenticato" sullo heap senza
che il suo distruttore venga invocato.
Tu pero' hai dimenticato di dichiarare il distruttore
come virtuale e questo e' un problema anche piu' serio:
se il tipo del puntatore passato a delete non corrisponde
con il tipo dell'oggetto puntato (come in questo caso)
e il distruttore dell'oggetto non e' dichiarato virtuale
allora il comportamento e' indefinito (ovveto potrebbe
succedere di tutto). Normalmente quello che succede e'
che viene eseguito il codice di distruzione di "base" e
non quello di "der" (questo e' gia' in generale un
problema) ma potrebbe succedere anche di peggio.
Bisogna ricordarsi che il distruttore che viene
dichiarato automaticamente dal compilatore NON e'
virtuale a meno che sia virtuale il distruttore
di una delle sue classi base.
HTH
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 come virtuale e questo e' un problema anche piu' serio:
[cut]
sorry x la dimenticanza! e dire che mentre scrivevo, a mente mi ero fatto
tutto
il discorso del perche' il distruttore e' virtual! Bah! :-)
cmq gia' che sei intervenuto che ne pensi della differenza dei due metodi
proposti?
--
Ciao by Beppe

proposti?
Secondo me il fattore che in genere discrimina e' quanto deve
durare l'oggetto creato. Se la sua durata e' limitata ad uno
scope di funzione allora e' preferibile dichiarare semplicemente
l'istanza... se invece la durata dell'oggetto deve superare
quella della funzione si usa in genere new.


quella della funzione si usa in genere new.
Anche se, secondo me, non e' bene che il delete di un oggetto sia
fatto al di fuori della funzione che lo istanzia in modo dinamico.
O mi sbaglio ?
--
Walkie...@Libero.It (ICQ# 8143647)

}
attento che in questo caso viente cmq chiamato il metodo della classe
base, in quanto l'istanza obj è del tipo base. Per usare il
polimorfismo usa i puntatori (o i reference):
int main() {
	base* obj = new der;
	obj->metodo();
}
Ciao Anto
--
Antonio Cuni, 19 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

 O mi sbaglio ?
Ti sbagli.  Una design pattern tipica e molto raccomandata e`
ad esempio quella della "funzione fabbrica" (o metodo-fabbrica
di una classe, ecc), dove "la funzione che istanzia in modo
dinamico" un componente lo restituisce (via puntatore, di solito,
ma auto_ptr<> puo` essere preferibile, ecc, ecc) come proprio
valore di ritorno.  Lo specifico ruolo di questa "fabbrica" e`
proprio quello di scegliere la classe (concreta) "giusta" per
una data istanza di un oggetto (rappresentato per il codice
cliente dalla sua interfaccia astratta, che e` cosa buona e
giusta), liberando il codice-cliente da qualsiasi dipendenza
dalle classi-concrete che implementano le interfacce-astratte
che sole esso usa.  Oltre a "Design Patterns", il piu` grande
classico della progettazione OO (a mio vedere, ma non sono il
solo a pensarla cosi`:-) raccomando tutti i testi di Martin
disponibili al suo sito 
www.objectmentor.com
, nonche` il testo
di Lakos (disponibile ahime` solo come costoso librone, ma, se
devi sviluppare software DAVVERO grosso, merita...!-).
E` chiaro che la funzione-fabbrica NON puo` sensatamente
"fare il delete dell'oggetto" che istanzia per conto del
codice-cliente (se no, che torna...?-).  Questo controesempio
(importantissimo di suo) dovrebbe bastare a sfatare l'antica
e diffusa (ma infondata) leggenda che raccomanda che il new
e il delete di un oggetto si trovino "insieme".
Possiamo poi dare un milione di altri controesempi che
mostrano come spesso e volentieri sia appropriato che la
durata di vita di un oggetto creato con new sia superiore
a quella della funzione che lo crea.  Ma uno dovrebbe,
spero, bastare:-).
Alex (MVP di Brainbench per il C++)