Newsgroup: it.comp.lang.c++
Titolo: Costruttori e distruttori con le derivate

Se in una classe base dichiaro privati alcuni membri che inizializzo col
costruttore, quando creo una classe derivata, non eredito i membri privati e
i costruttori, ma il distruttore si. Ora:
1) Se chiamo dalla classe derivata il costruttore della classe base tramite
lista d'inizializzazione con il costruttore della classe derivata, che
succede con i membri preivati della classe base? Dovrei forse evitare di
chiamare il costruttore della classe base, inizializzando dalla derivata
anche i membri protetti della classe base, oltre che i nuovi?
2) Col distruttore, che invece viene ereditato, che succede? Anche se per il
costruttore mi comporto come sopre, il distruttore non s aspetta di trovare
alcuni alementi da azzerare (tipo della memoria allocata dinamicamente) che
però o non è stata allocata o a cui non può accedere perchè non è stata
ereditata?
--
Marco Iannaccone     
marc...@tin.it
ICQ: 18748121           Tolkien
"I've... seen things you people wouldn't believe. Attack ships on fire off
the shoulder of Orion.
I watched C-beams... glitter in the dark near the Tanhauser Gate. All
those... moments will be lost... in time..., like... tears... in... rain."
FAQ it.comp.lang.c: 
http://www.programmazione.it/linguaggi/c/itcomplangc.htm
FAQ it.comp.lang.c++: 
http://www.programmazione.it/linguaggi/c/lang_faq.htm

ereditata?
Non e' possibile evitare di chiamare un costruttore della
classe base e quindi tutti i membri della classe base saranno
correttamente inizializzati (anche i private).
Inoltre poiche' non puoi evitare di chiamara il distruttore
della base tutti i membri saranno anche automaticamente
distrutti alla fine del distruttore della classe derivata.
Considera quest'altro esempio:
  class A
  {
    private:
      int x;
    public:
      A(int xx) : x(xx) { }
  };
  class B : public A
  {
    public:
      int y;
      B(int yy) : y(yy) { } // Errore: non e' stato
                            // indicato come costruire
                            // A e non esiste un
                            // costruttore di default
      B(int yy) : A(3),y(yy)  // Ok, x sara' 3
      { }
  }
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

La premessa e` errata, una classe derivata eredita anche i membri
privati, ma non ha diretto accesso ad essi.
Paolo
-------------------------------------------
  Paolo Marotta
 
http://web.tiscalinet.it/paolo_marotta/
-------------------------------------------

                           // seguito verra' impostato a 1
Dato che non è stato specificato, viene chiamato il costruttore di default
di A, che è stato specificato (altrimenti darebbe errore di compilazione,
no?)?
Grazie per le risposte e pere la chiarezza.


no?)?
Non necessariamente. Il costruttore di default viene creato
automaticamente dal compilatore se sussistono due condizioni:
  - La classe non ha nessun altro costruttore definito
    dall'utente.
  - Tutte le basi e tutti i membri della classe
    hanno un costruttore di default accessibile.
Il costruttore di default di una classe chiama semplicemente
il costruttore di default per tutte le basi e i membri.
Quindi una classe puo' avere un costruttore di default anche
se non e' stato specificato esplicitamente.
Oltre al costruttore esistono altri metodi che vengono creati
automaticamente se non sono definiti dall'utente: in particolare
scrivere
    class A {
      int x;
    };
e' come scrivere:
  class A
  {
    private:
      int x;
    public:
      // Costruttore di default
      A() { }
      // Costruttore di copia
      A(const A& a) : x(a.x) { }
      // Distruttore (nota: NON esplicitamente virtual)
      ~A() { }
      // Assegnazione
      A& operator=(const A& a) { x=a.x; return *this; }
      // Accesso a indirizzo
      A* operator&() { return this; }
  };


 ha scritto nel messaggio
news:39c0606...@news.interbusiness.it...


 Paolo
Non voglio polemizzare e magari mi sbaglio ma mi sembra di ricordare che
una classe derivata eredita i membri privati e puo' richiedere l'accesso ad
essi
e non puo' farlo con i membri protetti.
Giacomo

      A* operator&() { return this; }
Esistono due versioni distinte generate automaticamente:
una per oggetti const e una per non-const:
     A* operator&()             { return this; }
     const A* operator&() const { return this; }
La cosa diventa rilevante se in una classe viene
fatto l'override di una sola delle due (cosa credo
sconsigliabile).
Andrea

 e non puo' farlo con i membri protetti.
Da quanto ne so direi proprio che è il contrario....


e non puo' farlo con i membri protetti.
I membri privati sono tali proprio perche` solo la classe che li
definisce ha accesso ad essi e puo` concedere ad altri
il diritto di accedervi direttamente (friend).
I membri protected sono invece accessibili anche alle classi
derivate.
