Newsgroup: it.comp.lang.c++
Titolo: L'uso che faccio di extern è corretto?

Supponiamo di aver definito una classe aereo, un file main.cpp in cui
avviene l'istanziazione di un oggetto di questa classe (es. aereo
Boing_747(200);  ), ed un altro file Aereoporto.cpp in cui ho definito
un'altra classe, ad es. Aereoporto, che utilizza l'oggetto Boing_747.
Per fare in modo che i valori assunti dalle variabili private di Boing_747,
mediante i suoi metodi, vengano correttamente visti anche in Aereoporto.cpp,
cioè che l' OGGETTO SIA CONDIVISO TRA DUE FILES, MAIN.CPP ed AEREOPORTO.CPP,
dando cosi a Boing_747 linkage esterno (credo ?!? Ho un po di nebbia nel
cervello su questo concetto...) è:
1)
-Generare un file .h, ad es. variabili.h, in cui dichiaro:
   Aereo Boing_747;  // Senza chiamare alcun costruttore, almeno credo...
- includere questo file sia in main.cpp che in Aereoporto.h
-  in main.cpp la definizione :     aereo Boing_747(200);
2) Le stesse cose del punto 1), solo che utilizzo la keyword extern
- extern aereo Boing_747;   ( in variabili.h)
- aereo Boing_747(200);     (in main.cpp)
- in Aereoporto.h, oltrechè   #include "Aereo.h", aggiungere l'istruzione
  extern aereo Boing_747;
------------Aereo.h-----------
class aereo{
                   int  numero_posti_a_sedere_totale;
                   int  numero_posti_a_sedere_disponibili;
                   /....../  // altre variabili private...
                   public:
                   N.B. Non ho definito alcun costruttore di default
                  aereo(int Numero_di_posti_dell_aereo);
                  void Imbarca_passegero(void);
                   /......../
                   altri metodi...
                 };
----------END_of_Aereo.h-------------
------------Aereo.cpp---------------
/............/
aereo:: aereo(int Numero_di_posti_dell_aereo){
                   numero_posti_a_sedere_totale= Numero_di_posti_dell_aereo;
numero_posti_a_sedere_disponibili=numero_posti_a_sedere_totale;
                   }
void aereo:: Imbarca_passegero(void){
                  numero_posti_a_sedere_disponibili--;
                  }
----------------END_of_Aereo.cpp-----------
---------Aereoporto.h------------
#include "Aereo.h"
enum Nome_aereoporto {Fiumicino, Linate, Fontanarossa,Capodichino}
class Aereoporto{
                           Nome_aereoporto nome;
                           /............./
                           public:
                           Aereoporto(int Nome);
                           void Procedura_di_imbarco(void);
                           /............/
                           };
-----------END_of_Aereoporto.h------------
----------Aereoporto.cpp-----------
#include "Aereoporto.h"
/........../
void Aereoporto:: Procedura_di_imbarco(void){
                             Boing_747.Imbarca_passegero();  <-----------
Questa cosa è lecita?
                             /.........../
                             }
--------END_of_Aereoporto.cpp---------------

 
-- 
"a` parte isso, tenho em mim
 todos os sonhos do mundo"

Prova comunque a considerare un altro approccio che non utilizzi variabili
globali...all'inizio è un pò più difficile, ma col tempo ti ritroverai ad
ottenere codice molto più semplice da modificare e mantenere.
MM

 - aereo Boing_747(200);     (in main.cpp)
Esattamente, a patto che l'oggetto Boing_747 sia una variabile globale
(esterna ad ogni funzione).
EMG

un'altra classe, ad es. Aereoporto, che utilizza l'oggetto Boing_747.
Dichiari
     extern Aereo Boing_747;
in tutti i file dove devi usarlo (o in un include) e in uno solo dei
file .cpp scrivi:
      Aereo Boing_747(200); // Qui viene chiamato il costruttore
In questo modo tutti possono scrivere ad esempio
      Boing_747.Decolla();
e si riferiscono tutti alla stessa istanza.
Nota pero' che devi stare attento al costruttore di Aereo... infatti
se ci sono diverse istanze globali l'ordine di inizializzazione puo'
portare a dei problemi.
Tutti questi oggetti globali vengono inizializzati prima della prima
istruzione di main() in un ordine quasi casuale (e' definito solo
l'ordine di creazione/distruzione all'interno di ciascun file
.cpp ma non l'ordine di creazione globale)
In generale si dovrebbe cercare di limitare al massimo l'uso
delle globali per questa ragione e anche per ragioni piu'
filosofiche di OOD (coupling).
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff