[c++] composizione con classe astratta

[Akkawe]

Salve,
E' possibile creare una relazione di composizione tra due classi se la classe figlio è astratta?
Come?
Grazie

[passasooz]

dipende, cosa intendi per composizione?

[ramy89]

Spiegati meglio, la classe figlio da che classe deriva?

[Akkawe]

Originariamente inviato da ramy89
Spiegati meglio, la classe figlio da che classe deriva?

Hai ragione,
ho sbagliato proprio la domanda.

Io vorrei fare una relazione di composizione (@passasooz: io ho trovato questo termine studiando in libri di c++, e' un tipo di relazione has-a) tra due classi che sono astratte.
Esempio relazione di composizione tra due classi astratte A e B:

class A {

public:
virtual double foo()=0;
}

class B {
private:
A mA
public:
virtual double foo()=0;
}

questo codice non funziona perche' non posso instanziare l oggetto mA di A perche' A e' una classe astratta.
Allora dovrei mettere:

A *mA

ma cosi diventa una relazione di aggregazione perche' non ne controllo il lifetime di mA.
Se pero' mettessi nel distruttore:

B::~B(void){
delete *mA;
}

cosi ne controllerei il lifetime. Vi pare corretto? Inoltre sempre nell'ottica di relazione di composizione, mA va instanziato nel corpo del costruttore o nella initialitation list?
cosa cambia?
grazie

[ramy89]

Premetto che non sono sicuro di quello che sto dicento perchè sono abituato con java.
Ma se A è una classe astratta, non è istanziabile, quindi il distruttore non ha senso perchè non ci sarà mai un oggetto di tipo A.
L' unica cosa che puoi fare è, tramite il riferimento *ma, istanziare una classe concreta derivata da A.Quindi se B fosse concreta potresti fare:

ma=new B();

Ma non essendo concreta tramite il riferimento *ma non puoi istanziare nulla, ammenochè non ci sia una classe che derivi da A o da B, e che sia concreta.
Tutto questo con grande margine di dubbio perchè non uso c++ da tanto.

[Akkawe]

Originariamente inviato da ramy89
Premetto che non sono sicuro di quello che sto dicento perchè sono abituato con java.
Ma se A è una classe astratta, non è istanziabile, quindi il distruttore non ha senso perchè non ci sarà mai un oggetto di tipo A.
L' unica cosa che puoi fare è, tramite il riferimento *ma, istanziare una classe concreta derivata da A.Quindi se B fosse concreta potresti fare:

ma=new B();

Ma non essendo concreta tramite il riferimento *ma non puoi istanziare nulla, ammenochè non ci sia una classe che derivi da A o da B, e che sia concreta.
Tutto questo con grande margine di dubbio perchè non uso c++ da tanto.

hai ragione.
effettivamente, io dichiarerei

A *mA

nella classe astratta (in .h)
ma lo farei instanziare e cancellare dalla classe derivata (esempio se A e B sono astratte, A_figlio e B_figlio sono le rispettive classi derivate che dovranno implementare come istanziare e come cancellare). Dunque ogni classe derivata deve implementare queste due istanze.
Cosi funziona, non so se a livello di design sia la strada corretta. Hai in mente qualcosa su cui studiare questi argomenti?

EDIT:
posso implementare delete *mA nel distruttore della classe astratta. Infatti dopo che la classe derivata viene distrutta, viene chiamato il distruttore della relativa classe base astratta, e dato che il puntatore e' stato dichiarato nella classe base allora e' ancora presente, cosi lo cancello.

[ramy89]

Se hai intenzione di creare una classe derivata da B, allora il costruttore lo puoi dichiarare anche nella classe astratta.
Se ad esempio dichiari:

ma=new B();

E poi dal costruttore della sottoclasse (supponiamo si chiami C) dichiari:

super();

Dovrebbe istanziarti in ma un oggetto di tipo B.
Sempre tenendo conto che potrei sbagliarmi.

[ramy89]

In teoria anche in A potresti fare un costruttore, e in B un costruttore che chiama il costruttore della superclasse A.
Così da un' eventuale classe C derivata da B se chiami super(), chiami il costruttore di B, che a sua volta chiama il costruttore di A().