Newsgroup: it.comp.lang.delphi
Titolo: Classi ereditate

Salve, dovrei creare una classe ereditata da due classi base; guardando
sull'help di Delphi ho visto che si può fare ricorrendo al polimorfismo,
però non ci sono riuscito.
Queste sono le due classi base:
TBase1Class = Class
    public
        procedure ProcBase1();
    end;
TBase2Class = Class
    public
        procedure ProcBase2();
    end;
Questa la classe derivata dalle due classi base (in pseudocodice):
TDerivClass = Class(TBase1Class, TBase2Class)
    public
        procedure ProcBase1();
        procedure ProcBase2();
    end;
Sapete come risolvere il problema?
Grazie in anticipo.
Alessandro

Alessandro
	Ciao
	MassimoB
 
---------------------------
http://www.massimobeschi.it/

    end;
TDerivClass = Class()
    public
        Base1: TBase1Class;
        Base2: TBase2Class;
    end;
nel costruttore di TDerivClass (o li dove ti servono)
istanzi i due oggetti Base1 e Base2 in maniera da avere
a disposizioni i loro metodi, poi nel distruttore (o li
dove non ti servono più), sempre di TDerivClass, li
devi distruggere con un Free o FreeAndNill(...), in
maniera da non avere un memory leak (istanze vaganti in
memoria fino alla chiusura dell'applicazione).
Spero di essermi ricordato tutto. :P


 Alessandro
Andrea

 però non ci sono riuscito.
Stai facendo un pò di confusione con i concetti base della OOP.
Ereditarietà è una cosa, polimorfismo è un'altra cosa, sono due aspetti
correlati ma distinti della programmazione orientata agli oggetti.
In ogni caso, in Delphi non è possibile ereditare una classe da due
superclassi come avviene, ad esempio, in C++.  Una valida alternativa,
però, si ottiene con le interfacce.  La tua classe può ereditare da una
superclasse e, in più, "implementare" un'interfaccia.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 superclasse e, in piů, "implementare" un'interfaccia.
Come si usano le interfacce?
Ho provato a guardare l'help ma non ci sono riuscito.

 Ho provato a guardare l'help ma non ci sono riuscito.
Eh, vero, tante volte si blocca il tasto F1 sulla tastiera... <g>
Andrea

 Ho provato a guardare l'help ma non ci sono riuscito.
Guarda la sezione "Implementing interfaces" della guida.


 classe che ha più "importanza" dell'altro
Nella libreria standard del C++ c'è la classe iostream che eredita sia da
istream che da ostream.  In questo caso, come in moltissimi altri, non c'è
un aspetto "preminente" della classe.  Per avere ereditarietà multipla,
però, è assolutamente necessario che venga supportata l'ereditarietà
virtuale.  In C++, ad esempio, le classi istream e ostream ereditano
entrambe da ios, ma per propagare una sola istanza della classe ios nelle
loro classi figlie (cosa strettamente necessaria perché il codice funzioni
correttamente), devono necessariamente ereditare in modo virtuale (il C++
supporta la "virtual inheritance", mentre Delphi no).  Il problema,
generalmente, è che, se ho le classi B1 e B2 all'interno di una gerarchia
che ereditano dalla classe A e voglio costruire una classe C ereditata sia
da B1 che da B2, B1 e B2 *devono* ereditare in modo virtuale da A.  Le
classi B1 e B2, però, potrebbero essere state progettate prima di C e,
siccome l'ereditarietà virtuale è sempre da evitare se non strettamente
necessaria, potrebbero non essere "pronte" perché C erediti da esse.
In questo caso, va modificata la gerarchia, perché le cose funzionino
correttamente.


 correttamente.
IMHO, non è detto: usare una classe base ed un'aggregazione, due
aggregazioni, una base ed una interfaccia magari nella stessa
classe oppure due interfacce, non credo cambi di troppo i termini
della questione.
Ciao,
Andrea

 una classe concreta?
No, se vuoi capire che cos'è l'ereditarietà virtuale, scarica il secondo
volume di Thinking in C++ e leggi il capitolo sulla "multiple inheritance".
C'è una trattazione molto ben fatta.
