Newsgroup: it.comp.lang.c++
Titolo: problema extern

ho un programma composto da 2 classi , nel programma principale genero 
la classe A come globale e nella classe B la aggancio tramite extern . 
Il programma funzione bene ma L'IDE mi mostra la presenza di 2 classi A 
perchè mi vede prima quella dichiarata globale e poi l'extern ! C'è una 
maniera per risolvere il problema! Se non metto l'extern il programma mi 
dice classe doppia! se la ometto mi dice che non trova l'oggetto 
richiesto! Qual'è il trucco?
Lavoro con il GNU in ambiente LINUX
GRAZIE
<<SAX>>

 ha scritto nel messaggio
news:MPG.1b5c723a2...@news.tin.it...

Inanzitutto un po' di precisione:
1) le classi non si generano, bensì si istanziano, ovvero si creano oggetti
di una data classe; la classe di per sè è sempre unica
    (non confondere la classe, che è un "tipo", con gli oggetti di quella
classe, che sono "variabili di quel tipo".
2) "dichiarare" un oggetto di una classe è cosa differente dal "definirlo".
Per esempio:
    A ogg;    // "definisce", ovvero crea, un oggetto della classe A, nel
senso che alloca memoria per esso
    external A ogg; // "dichiara" che ogg è un oggetto di classe A definito
da qualche altra parte nel programma
In un programma una variabile o un oggetto può essere "dichiarata" quante
volte si vuole ma deve essere "definita" una e una sola volta. Quindi la
tecnica da usare, qualora si voglia avere una variabile globale, è la
seguente:
    - "definire" la variabile in un unico punto, all'interno di un file di
implementazione (quelli con estensione .c o .cpp)
    - "dichiarare" la variabile stessa, usando extern, tutte le volte che si
ha bisogno di usarla; tipicamente la dichiarazione extern viene messa in un
header file (il file con estensione .h)
L'errore da evitare è quello di "definire" la variabile nel .h: infatti in
questo caso se l'header file viene incluso in almeno due punti del programma
la definizione della variabile comparirà in altrettanti punti, e il linker
ti darà errore. La conclusione è che negli header files le variabili vanno
soltanto dichiarate, e non definite.
Ciao,
Plautus

 soltanto dichiarate, e non definite.
Su quest'ultimo punto nn sono daccordo esiste un potente meccanismo nel c++
che ti consente di includere tutti gli header file che vuoi in un file .cpp
a condizione che tu preveda che questo header possa essere incluso in piu
file cpp per cui dovresti usare la precompilazione condizionata :
esempio :
/**************************************************************************
 *  Wrapper header file used to select STL via defines.
 *  Default is STLport.
 **************************************************************************/
#ifdef _USE_OLD_RW_STL
# include <oldstl\iostream.h>
#else
# include <stlport\iostream>
/* Define __STD_IOSTREAM__ here to cause sysclass.h to define
   VCL_IOSTREAM which causes certian iostream operators to get defined
*/
#define __STD_IOSTREAM__
#endif
#if !defined(__USING_STD_NAMES__) && defined(__cplusplus)
using namespace std;
#endif /* __USING_STD_NAMES__ */
Ciao
Antonio.


Ciao,
Walter

 piu file cpp per cui dovresti usare la precompilazione condizionata :
No. Ti stai confondendo. La tecnica delle macro 'guardie' negli header serve
a evitare *dichiarazioni* multiple nella stessa unità di compilazione, ma
non ha alcun potere contro la possibilità di *definizioni* multiple
nell'arco delle varie unità di compilazione che compongono il programma.
Quello che ha detto Plautus è corretto: negli header si dichiara ma non si
definisce, a meno tu non sia sicuro che un certo header è incluso soltanto
in una singola unità di compilazione.
Max

 compilazione.
Una piccola precisazione: una dichiarazione può comparire anche più volte
nella stessa unità di compilazione, l'importante è che sia sempre la stessa;
per esempio se in un file scrivo:
int a;
e poi, nello stesso file scrivo due volte:
extern int a;
extern int a;
il tutto è corretto;
se invece scrivo:
extern int a;
extern char a;
ottengo un errore in compilazione.
Ciao :-)
Walter


La discussione partita da questo post mi ha fatto riflettere su una cosa.
La frase "istanziare una classe" è effettivamente ambigua.
Da un lato si può infatti intendere tale espressione equivalente a
    "istanziare un oggetto della classe";
d'altro canto la stessa espressione viene utilizzata per indicare la
generazione della definizione di una classe a partire da un template; si
dice infatti "istanziare una classe template";
E'chiaro quindi che c'è un'ambiguità, poichè in un caso ci si riferisce alla
creazione di un oggetto, nell'altro alla definizione di una classe.
Walter