Newsgroup: it.comp.lang.c++
Titolo: constructor ereditato?

Se derivo una classe da un'altra di base, il contructor e il
destructor della classe di base diventano automaticamente della nuova
classe o devo esplicitamente chiamarli? Cioč per esempio:
class CNuova : public CVecchia 
{
public:
	CWave():CArray() {};
...
...

>classe o devo esplicitamente chiamarli?
Vengono chiamati automaticamente. Se il costruttore ha dei parametri devi chiamarlo tu se definisci un tuo costruttore attraverso la sintassi:
ClasseDerivata::ClasseDerivata(): ClasseBase(x, y)
{
}
Antonio Donatiello

...
Puoi anche non chiamare alcun costruttore della classe base,
in tal caso il compilatore inserisce automaticamente una chiamata
al costruttore di default della classe base, che ovviamente deve
pero` esistere. Nel caso del costruttore di copia il costruttore di 
classe base invocato automaticamente e` pero` quello di copia
(per ovvi motivi).
Per quanto riguarda il distruttore, fa invece tutto il compilatore
(ovvero nessuna chiamata esplicita e` necessaria).
Nota che questo non significa pero` che ctor e dtor vengano
ereditati, cosa assolutamente falsa.
Paolo
-----------------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------------------------

Vengono chiamati automaticamente.
Sicuro?
Ciao, Giuseppe
---------------------------------------------------------------------------
_Guybrush su IRCNet canale #programmazione
ICQ: 42227764
---------------------------------------------------------------------------


Domanda: perché i costruttori del tuo esempio si 'chiamano' in maniera
diversa dalle classi??? Non dovrebbe essere:
 class CNuova : public CVecchia
 {
 public:
 CNuova():CVecchia() {}     // senza ; dopo la graffa,
        ...                                   // che io sappia, ma forse
        ...                                   // non fa nulla mettercelo
?
A parte questo vediamo un po' quello che mi ricordo sulle classi Ereditate:
==>Viene invocato prima il costruttore senza argomenti della classe base e
poi il costr. della classe derivata (a meno che il costr. della derivata non
chiami con lista di inizializzazione, come hai fatto nell'esempio, il costr.
della base che gli serve!).
Al contrario, per il distruttore:
==>Viene invocato prima il distr. della derivata e poi il distr. della base.
Es.:
(tieni presente che ho il Borland C++ 3.1 - forse un po' stagionato, visto
che è del '90)
#include<iostream.h>
class CVecchia
{ public:
     CVecchia() { cout<<"Ciao, sono la Vecchia"<<endl; }
    ...
};
class CNuova : public CVecchia
{ public:
     CNuova() { cout<<"Ciao, io sono la Nuova!"<<endl; }
    ...
};
// cliente di CNuova:
CNuova n;
// stampa a schermo:
Ciao, sono la Vecchia
Ciao, io sono la Nuova!
Attenzione: se nella classe base non c'è il costr. senza argomenti,
CVecchia(), se non c'è nessun costruttore allora esiste il costr. senza arg.
che il C++ passa gratis, altrimenti se hai definito un costr. con argomenti
ti ritrovi un bell'errore
class B
{ public:
    B(int);
    ...
};
class D : public B
{ public:
    D(int);    // ERRORE: il costr. D cercherà in B il costr. B()
                   // che non esiste!
                   // SE l'intenzione era di usare B(int) allora:
                   //            D(int x):B(x) {}
    ...
};
Piccolo problema per l'Ereditarietà multipla:
class B1
{ public:
    int f();
    ...
};
class B2
{ public:
    int f();
    ...
};
class D:public B1, public B2
{
    ...
};
// cliente dela classe D
D d;
int a=d.f();
// quale cazzo chiama?  B1::f() o B2::f() ?  Da errore ? Mi sa proprio di
// sì: l'unica è int a=d.B1::f()  oppure  int a=d.B2::f() , che io sappia.
// Se qualcuno ne sa di più, mi piacerebbe 'ascoltarlo'.
--
      Ciao da Pavelo ;o)
 
pi....@bigfoot.com
             HomePage
http://web.tiscalinet.it/pavelo
"Considerando l'apertura alare e la frequenza del battito
delle ali rapportata al peso,è scientificamente provato
che un coleottero non può volare.Vola perché non lo sa ."
(frase scritta all'ingresso della facoltà di
ingegneria aeronautica dell'università di Cambridge )

> ...
Purtroppo non vedo il msg originale, quindi rispondo a
questo livello del thread.
Innanzi tutto il costruttore di una classe in C++ deve avere lo
stesso nome della classe. Il distruttore segue la stessa regola
salvo che il suo nome e` preceduto da ~ (tilde).
Detto questo, costruttori e distruttori non vengono ereditati.
E` pero` possibile richiamare un costruttore di classe base dal
costruttore di classe derivata per controllare il processo
di inizializzazione di una istanza di classe derivata; questo lo fai
utilizzando la lista di inizializzazione. Se nessun costruttore di
classe base e` specificato nella lista di inizializzazione, viene
invocato automaticamente quello di default.
Il distruttore di classe base e` invece invocato automaticamente
alla distruzione dell'istanza di classe derivata.
Per maggiori info, su 
www.programmazione.it
 c'e` un mio tutorial.


// quale cazzo chiama?  B1::f() o B2::f() ?  Da errore ? 
Da errore, e` ambiguo.
Puoi risolvere la cosa specificando la classe del metodo che ti
interessa:
int a = d.B1::f();
