Newsgroup: it.comp.lang.delphi
Titolo: ci vuole <classe>...

...per lavorare con le CLASSI.
Per questo vi chiedo:
1) mettiamo abbia
 
type   pluto=class
	         public
	      	constructor Create;
	      	destructor Destroy; override;
               	     end;
 
- perche' si deve specificare <OVERRIDE> soltanto al distruttore e non
anche al costruttore?
2) mettiamoci ora in questo caso:
type   a=class
         public
                function f(g:integer):integer;
         end;
     b=class(a)
         public
                function f(g:integer):integer;
         end;
Perche' non ho dovuto specificare "OVERRIDE" alla funzione f della
classe b?
3) Che differenza c'e' tra  Destroy e Free?
Grazie
~Guybrush~

 3) Che differenza c'e' tra  Destroy e Free?
Questo lo so per certo: destroy e' il metodo che chiami per distruggere un
oggetto creato, mentre Free e' un metodo speciale, cio' che fa e'
controllare se l'oggetto e' nil e in caso contrario chiamare Destroy. E'
molto ultile quindi, perche' lo si puo' chiamare anche con oggetti non
inizializzati, ed e' quindi molto sicuro. Se chiami destroy con un oggetto
non inizializzato, ottieni il classico Access violation ffff:ffff ecc ecc
ciao !


Riformulo la domanda (anche per gli altri):
perche' Create e' un metodo STATICO mentre Distroy e' VIRTUALE?
[se qualcuno mi refresha il cervello con la definizione di VIRTUALE e'
meglio...!!!]
Ciao
~Guybrush~

 ha scritto nel messaggio
news:qg0kdt8bdgfnpv9or...@4ax.com...


Nel frattempo ti saluto, ciao!
Credo ora di aver capito.
In ogni caso gradirei vedere i tuoi dummy-project.
Puoi mandarli in posta.
Grazie 1000
Ciao
Francesco 
~Guybrush~

meglio...!!!]
Il perche' e' stato fatto non lo so, cmq la differenze tra virtuale e
statico e' che nel primo caso e' il tipo a run-time dell'oggetto che
decide quale procedura eseguire, nel secondo e' il tipo a
compile-time.
Esempio:
TPippo = class
	procedure Prova; virtual;
end;
TSuperPippo = class(TPippo)
	procedure Prova; override;
end;
var p: TPippo;
Se scrivi:
p:=TSuperPippo.Create;
p.Prova;
...viene eseguito il metodo di TSuperPippo nonostante la variabile sia
di tipo TPippo (polimorfismo, determinato a runtime), ma se non ci
fossero state le parole chiave virtual e override, sarebbe stata
eseguita la procedura di TPippo (determinata a compile time).
Spero sia chiaro
Saluti
--
Piero Bonanno
bop...@libero.it
pie...@tiscalinet.it
bpie...@hotmail.com
______________________________________________
"Madame, lei ha tra le gambe uno strumento
che puo' offrire piacere a migliaia di persone,
e tutto quello che sa fare e' grattarlo"
- Sir Thomas Beechan a una violoncellista


Vorrei aggiungere alla tua gia' esaustiva spiegazione che il metodo Create
e' un costruttore e quindi la sua "virtualita'" ha senso solo nell'ambito
della classe, e non dell'oggetto.
Mi spiego meglio.
Il metodo Create viene usato nella forma:
TObject.Create
ovvero viene chiamato quando l'oggetto ancora non esiste.
In Delphi e' possibile implementare i metodi virtual di oggetto e di classe,
che hanno funzionamenti differenti.
I costruttori virtuali servono (o perlomeno vengono utilizzati cosi' da
Delphi) per l'unstreaming.
Quando il sistema di streaming legge una form, vengono caricate, per ogni
componente, le informazioni RTTI. Da queste si risale alla classe e quindi
alla sua tabella VMT, nella quale e' possibile individuare e chiamare (in
sicurezza) i medodi di classe (detti static in C++) che, in Delphi, possono
essere anche virtuali.
Questo significa, nel caso specifico, che io posso ipotizzare di caricare
sempre dei TComponent, ma quando chiamero' il metodo
TComponent.Create(AOwner: TComponent), l'indirizzo di questo verra' cercato
nella VMT, in modo da creare l'oggetto corretto.
Alfine direi che l'utilita' di un costruttore virtuale sta tutta qui, ovvero
in un sistema di streaming di una gerarchia di classi ben definita, come e'
quella della VCL.
Personalmente non vedo altri utilizzi pratici.
Saluti,
Stefano Carboni