Newsgroup: it.comp.lang.c++
Titolo: Classi con funzioni virtuali pure.

Vi espongo il mio problema subito con un esempio (metto solo
l'implementazione delle classi):
class Base {
private:
       virtual void Carge() =0;
       virtual void UnCarge() =0;
      virtual char Tip() = 0;
public:
     Base();
     ~Base();
};
Base::Base () { Carge(); }
Base::~Base() { UnCarge(); }
class Derived : public Base {
       virtual void Carge();
       virtual void UnCarge();
      virtual char Tip();
} ;
void Derived::Carge() {
// Serie di operazioni
}
void Derived::UnCarge() {
// serie di operazioni
}
char Derived::Tip(){
//serie di operazioni
}
Il linker mi dice che non riesce a trovare gli external Base::Carge() e
Base::UnCarge(), ma queste, essendo virtuali pure, non dovrebbero essere
prese dalle classi derivate (considerando il fatto che io cmq allocco solo
classi derivate, e richiamo le funzioni di queste, essedo esse
polimorfiche).
cosa c'e' che non va nel mio ragionamento??
grazie per le risposte, un saluto a tutti :)
----------------------------------------------------
                                   Joshi
                       JoshiLg[pd] on B.Net
----------------------------------------------------
               "...And then there was silence
             just a voice from the otherworld
                  like a leaf in a icy world
                     memories will fade..."
----------------------------------------------------

 cosa c'e' che non va nel mio ragionamento??
non c'è niente che non va nel tuo ragionamento. Visto che il
compilatore non ti dà errori, forse ti sei solo dimenticato di
compilare i vari file .cpp e linkarli assieme correttamente. Hai
provato a controllare?

 provato a controllare?
Ho provato. forse e' meglio se gli faccio ricompilare tutto da 0.
Grazie.
Joshi

 
Premessa: quando il costruttore o il distruttore di una classe base
vengono eseguiti, l'oggetto, se è un'instanza di una classe derivata, non
è del tutto costruito: nel primo caso perchè ancora non sono stati
inizializzati i membri della porzione più derivata e non è stato eseguito
il relativo costruttore, nel secondo caso perchè i membri della parte
derivata sono già stati distrutti e il distruttore relativo è gia stato
eseguito.
Per rispondere alla tua domanda, quello che non va nel tuo ragionamento è
che ti aspetti che venga eseguito un overrride definito una classe
derivata su un oggetto la cui porzione relativa a quella classe non esiste
ancora o non esiste più. Per ovvi motivi, questo non può essere
consentito.
Per questa ragione, lo Standard dispone che le chiamate a funzioni
virtuali durante l'esecuzione di un costruttore o di un distruttore
vangono risolte con le funzioni definite nel contesto della classe che si
sta costrutendo o distruggendo, o definite in una sua classe base.
Se le funzioni sono dichiarate *virtuali pure* il comportamento è
*indefinito*.
Max

 wrote in message
news:Pine.LNX.4.21.020907...@localhost.localdomain...

molto giusto. Suggerisco all'OP (e soprattutto a me stesso), di
leggere il punto [23.3] della C++ faq LITE che si trova all'indirizzo
http://www.parashift.com/c++-faq-lite/
.

 Base::Base () { Carge(); }
questa non va bene. Le chiamate alle funzioni virtuali nei costruttori 
non funzionano nel modo consueto: quando Base::Base() viene richiamato 
l'oggetto di tipo "Derived" non e` ancora stato completamente costruito 
(infatti il costruttore di Derived deve essere ancora invocato); questo 
significa che solo il sotto-oggetto di tipo Base e` disponibile e 
saranno chiamati i suoi metodi virtuali, che pero` non esistono in 
quanto sono metodi astratti. Un discorso analogo si puo` fare per i 
distruttori.
ciao Anto
-- 
Antonio Cuni, 20 anni, studente
Brainbench C++ Master: 4.73, higher than 99% of all previous test takers.
C Language: 3.79, higher than 92% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it


Come ti hanno gia' risposto non e' possibile chiamare delle funzioni di
inizializzazione che non siano locali alla classe che si sta'
costruendo.
Ma con tecniche (complicate) e' possibile aspettare che tutta la
gerachia di classi sia costruita e quindi chiamare delle funzioni di
inizializzazione virtuali.
Vedi il link:
 
http://www.eptacom.net/pubblicazioni/pub_it/nl_8.html
ciao e buona fortuna.
Cesare

 
http://www.eptacom.net/pubblicazioni/pub_it/nl_8.html
Accidenti, mi sono cacciato in un bel ginepraio! :)))
Alla fin fine, credo sia meglio se le Carge() e UnCarge() le implemento
direttamente nei costruttori/distruttori delle classi derivate... a questo
modo non ci dovrebbero essere problemi o sbaglio?
Grazie a tutti! Ciau :)
Joshi