Newsgroup: it.comp.lang.delphi
Titolo: TComponent, ereditarietà, owner, costruttori

Cerco di spiegare qual'è il problema nel quale mi sono imbattuto:
definisco le seguenti classi:
type  T1=class(TComponent)
               A: TA;
               Create (AOwner: TPersistent);  override;
        end;
        T2=class(T1)
              B: TB;
             Create (AOwner: TPersistent);  override;
       end;
       T3=class(T2)
             C: TC;
             Create (AOwner: TPersistent); override;
      end;
Io vorrei creare oggetti sia di tipo T3 che T2 e T1.
Vorrei che quando definisco un oggetto di tipo T3, diciamo  O3,  indicando
l'oggetto X come owner,
l'owner di O3 sia X, ma l'owner di C, B e A sia O3
Come devo definire i costruttori Create?
constructor T3.Create (AOwner: TPersistent);
begin
    inherited Create(?);
   C:=TC.Create(Self);
end;
Cosa devo mettere al posto del punto di domanda?
AOwner o Self?
Oppure non è possibile in questo modo?
Stesso discorso vale per constructor T2.Create.
Spero di essere stato abbastanza chiaro.
Grazie anticipate per l'aiuto.
Ciao!


    ABLS Team (
www.abls.it
)
········································

 spazio occupato in memoria.
Tornando al caso esposto nel primo messaggio se definisco le Create cosě
 constructor T3.Create (AOwner: TPersistent);
 begin
     inherited Create(AOwner);
    C:=TC.Create(Self);
 end;
 constructor T2.Create (AOwner: TPersistent);
 begin
     inherited Create(AOwner);
    B:=TB.Create(Self);
 end;
 constructor T1.Create (AOwner: TPersistent);
 begin
     inherited Create(AOwner);
    A:=TA.Create(Self);
 end;
 e quindi istanzio l'oggetto O3 con owner nil
var O3: T3;
.....
O3:=T3.Create(nil);
quando faccio
O3.Free;
viene liberata la memoria anche di O3.B e O3.A ?
Ora mi viene in mente un altro modo per spiegare il mio dubbio:
T3 invoca il costruttore di T2, il costruttore di T2 invoca il costruttore
di B passando come owner Self;
questo Self č l'oggetto di tipo T3 che sto instanziando?
E se faccio
O3.B.Free;
viene liberato anche O3.A  ?
Grazie.
Ciao!

TComponent.
In che senso "enormemente" piu` comodi ?
La tua classe dovrebbe derivare da TComponent solo se ce n'e` un reale
bisogno e non credo che nel tuo caso ce ne sia bisogno, o no ?


Effettivamente "enormemente" è un po' esagerato.
Diciamo che piaceva l'idea di non dover ridefinire i distruttori.
Ciao!

 viene liberato anche O3.A  ?
Diciamo che ho perso completamente il filo dei tuoi ragionamenti, tra TC,
A2, 03... :-)
Tento di esemplificarti ciò che penso brevemente, poi magari altri
aggiungeranno successivamente la loro opinione.
Innanzitutto, crea le tue classi ereditando direttamente da quella più
consona ai tuoi scopi. Una volta definita tale classe, dovrai valutare quali
campi privati e quali metodi servono alla tua classe per adempiere al
proprio compito, nonchè i metodi della classe base da "scavalcare" per
estendere eventualmente le funzionalità ereditate. Tra questi metodi,
potrebbero esserci (ma non è detto) il costruttore e il distruttore, Create
e Destroy. Non dimenticare mai la clausola *override* sul metodo
distruttore. Questi due metodi dovrebbero essere aggiunti in base alle
esigenze di inizializzare variabili, ma non solo: anche creare nuove istanze
di classi di supporto (in Create) e distruggerle opportunamente (in
Destroy). Ricorda di richiamare il metodo ereditato in ciascuno di questi
metodi tramite la parola chiave *inherited*: siccome "scavalchi" il metodo
che verrebbe generalmente richiamato, devi provvedere tu a richiamare il
"vecchio" metodo omonimo della classe base affinchè tutto funzioni a dovere.
Bisogna ammettere che questi concetti sono più facili da capire che da
spiegare.
Se hai bisogno di classi di supporto all'interno della tua classe, creane le
istanze e distruggile rispettivamente nei metodi Create e Destroy; se si
tratta di componenti (o discendenti), è meglio non basarsi (in quel
frangente) sul meccanismo di Ownership, in modo da avere più autonomia e
controllo sul codice del componente.
Se è vero che sei alle prime armi come dici, magari dovresti approcciare a
questi concetti con più calma senza andare allo sbaraglio o magari trarre
conclusioni affrettate.
Se vuoi fare prove tecniche sulla programmazione ad oggetti, crea una unit
in cui sviluppare le classi che andrai poi ad istanziare magari nella form
principale, inserendo metodi di esempio con una semplice chiamata ad una
ShowMessage...potrai verificare da subito gli effetti derivati dalla
disposizione e dai legami delle tue classi.


Grazie per i consigli.
Ciao!