Newsgroup: it.comp.lang.c++
Titolo: globali?!

Salve ,vorrei sapere come faccio ad utilizzare alcune var definite in file
da un altro file sempre contenuto nello stesso progetto
uso vc6++
Grazie mille

 
it's simple :)
definisci la variabile come in un file di intestastazione e infine
includi il file di intestazione su entrambi i sorgenti che la utilizzano
poi metti nel sorgente "extern variabile"! non è strettamente necessario ma
se il compilatore non trova la variabile di cui hai bisogno genererà un
errore di compilazione
così dovrebbe funzionare alla grande
-- 
Wave++, member of EventOrizon software
http://members.xoom.it/wavexx

 uso vc6++
Evitalo, se appena appena puoi.  I dati globali sono una
fetenzia.
Se proprio devi, aggiungi *DICHIARAZIONE* di quei dati (*NON*
ulteriore *DEFINIZIONE*, ovviamente!!! vale la 1-definition rule)
in un tuo file di header (chiamato imieisporchiglobali.h, magari)
di cui farai #include in tutti i sorgenti in cui ti serve proprio.
Alex

 errore di compilazione
Nel SORGENTE?!  L'uso di "extern" implica normalmente una dichiarazione
(a meno che non vi sia contestualmente anche una inizializzazione) e
quindi e` quello che andra` nel file di header.
La dichiarazione, una e una sola volta, andra` in un file-sorgente.
L'errore in caso di definizione assente o ripetuta e` tipicamente dato
dal linker, che gira dopo la fine della compilazione "vera e propria".
Alex

cosě dovrebbe funzionare alla grande
Invece non funziona... anzi probabilmente
avrai grossi problemi (vale la "one definition rule").
Se proprio necessario, conviene mettere nell'header
una dichiarazione extern e definire la variabile
nel corrispondente file .cpp.
Sara` il linker a risolvere ogni riferimento.
Occhio, le var globali sono pericolose e vanno
limitate al massimo. Raramente e` necessario utilizzarle
nella quasi totalita` dei casi e` possibile farne a meno.
Paolo
--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
--------------------------------------------------

...
WE! Calma.. :).. hai perfettamente ragione, in effetti il compilatore dà errore
perchè trova + definizione!
Ho risposto così perchè io utilizzo questo sistema, con l'aggiunta però
delle direttive di compilazione per la serie:
#begin filedaincludere.h#
#ifndef __filedaincludere_h
#define __filedaincludere_h
// codice
#endif
#end filedaincludere.h#
e poi includo il file in tutti i mieri sorgenti, così posso essere sicuro che
tutte le variabili siano state definite...
dimenticanza... capirete _l'ora_!!! Per un tipo notturno le 13 è notte fonda =)


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

 dimenticanza... capirete _l'ora_!!! Per un tipo notturno le 13 č notte
fonda =)
Io sospetto invece che il problema sia una confuzione fra definizioni
e dichiarazioni, che in C++ (standard) non e` ammissibile.
Prova.  Sostituisci "// codice" nello schema di cui sopra con qualcosa
che e` sicuramente una definizione, tipo:
    int pippo = 23;
poi includi questo file di header in almeno due .cpp e prova a farne
il link entro lo stesso modulo o programma che dir si voglia.
Alex

 [CUT]
Ok, stavolta ci ho voluto vedere chiaro e ho preso alla mano il
compilatore! Allora in un include "include.hpp" ho inserito la
dichiarazione "extern int var".
Successivamente, in un file separato "file1.cpp" ho inserito la funzione
main che settava un valore per tale variabile e chiamava la funzione
"funz()" nel secondo file "file2.cpp" che includeva a sua volta
l'include.h! funz non fà altro che visualizzare il valore di var. Ovvio
che devo inserire la definizione di var e la inserisco nel file1.cpp senza
ripeterla nel 2° file!
Ora linko i file:
	g++ -c file1.cpp g++ -c file2.cpp g++ -o file file1.o file2.o
E avviando ./file non ho problemi!!! Personalmente (!) odio questo sistema
perchè non si sà mai dove si ha definito tale variabile... Preferisco di
gran lunga il sistema di dichiarare nell'include la variabile come
statica! In questo modo la definizione è all'interno dell'include e la
compilazione avviene sempre senza problemi e si può utilizzare il
"trucchetto" dell #ifndef
Ne ho fatto di casino :|, avrei dovuto prendere sotto mano i sorgenti di
quando
"al tempo" usavo le var globali, che cmq sono una tecnica di
programmazione da
evitare, in quanto si evita l'incapsulazione e si è soggetti ad errori!
"__FORTUNATAMENTE__" mi ero persino dicamenticato l'utilizzo
vabbuò dai... una rispolveratina
thx


 "trucchetto" dell #ifndef
E le variabili non sono globali, bensi` particolari e separate
in ciascun sorgente .cpp che compili.
Che non era cio` che si chiedeva, ma una semantica drasticamente
diversa.
Le variabili globali sono cose delicate, e da evitare il piu`
possibile, ma, se e quando servono, non e` certo con "il
sistema di dichiarare nell'include la variabile come statica"
che puoi avere la sia pur minima utilita`.
Alex

statica! 
Ma cosi', pero', non e' globale ! 
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
-----------------------------------------------------
"There is nothing better for understanding a kangaroo
 than seeing it jump." [D.Grune, C.J.H. Jacobs]
-----------------------------------------------------

 
già... mi ero dimenticato dell'origine
cmq, visto che siamo in tema, come sono dichiarate e o definite le classi
standard tipo cin cout cerr? ho provato a guardare l'iostream.h e almeno
per quello che ho trovato vedo:
	extern _IO_ostream_withassign cout, cerr;
ma dato tutto il discorso questa è una dichiarazione... dov'è la
definizione?


 definizione?
Nelle librerie di runtime della tua implementazione C++, certamente
in posti "vicini" a quelli in cui sono definite le varie funzioni
(membro e non) che hanno effetto sugli iostream svariati.
Alex

definizione?
Nelle librerie, presuppongo.


uso vc6++
Lo vuoi un consiglio? Evita le variabili globali in casi come questi.
Alla lunga ti danno più problemi che vantaggi. Usale magari con il VB,
ma non in C++. Ad ogni modo, se tanto ti piacciono ste benedette
variabili globali creati un file .h e definiscile all'interno di esso,
poi includi questo file all'interno dei moduli ove vuoi usarle e
dichiarale come extern.
Il Ghenio
-----
Jesse: Preparatevi a passare dei guai.
James: Dei guai molto grossi!!!
(Team Rocket)
-----