¿Cómo acceder a la variable global correcta en C?

digamos que tengo una var global GLOBAL en main.c, pero mi main.c tiene un #include “other.h”. Pero other.h tiene var global GLOBAL también.

¿Cómo le hago saber al comstackdor a cuál me refiero cuando escribo GLOBAL en main? ¿Hay una palabra clave “esto” que pueda usar?

Supongo que ha definido la variable en el progtwig y no en el preprocesador utilizando un #define.

Si desea referirse al creado en main.c, simplemente escriba global. Para referirse a aquellos en su archivo de encabezado, use la palabra clave extern.

Sería mejor declararlos como dos nombres de variables separados, aunque para ser honestos.

No puede tener dos variables globales con el mismo nombre en el progtwig C. C podría permitir múltiples definiciones en el mismo ámbito de archivo a través de la regla de definición provisional , pero en cualquier caso todas las definiciones se referirán a la misma variable. Entonces, aparentemente su pregunta se basa en premisa incorrecta. No hay problema de “cuál” aquí. Sólo tienes una variable.

Por ejemplo, puede tener una secuencia de definiciones de scope de archivo en la unidad de traducción C

 int i; int i; int i; 

Esto es legal en C (a diferencia de C ++) y todas estas definiciones en realidad definen la misma variable, no tres variables diferentes.

Por supuesto, si una de las variables se define como una variable local (si es así, tiene que declararla en su pregunta) (Por cierto, ¿por qué se llama GLOBAL entonces?), Entonces ocultará el nombre de la variable definida en El scope del archivo (o cualquier scope superior). En este caso, no hay forma de acceder al nombre oculto en C. Cambie el nombre de la variable local para evitar ocultar el global.

Lo que quiere decir con “otro.h también tiene la variable” tampoco está claro. ¿Qué significa “tiene” en este caso? ¿La variable está definida en other.h? ¿O acaba de declarar ? Si se acaba de declarar, entonces realmente no lo “tiene”. Si está definido allí … bueno, entonces la pregunta real es: ¿por qué estás definiendo variables en archivos .h?

En realidad no tienes dos variables. Solo hay uno, obtendrá un error de comstackdor (o vinculador) si dos módulos declaran el mismo global con el mismo nombre, o el comstackdor / vinculador decidirá que usted quiso que estas declaraciones fueran redundantes de una sola variable y las fusionara .

Como han mencionado otros, evite usar los mismos nombres de funciones / variables globales. Tome el hábito de prefijarlos con el nombre del módulo. Es decir, MODULE1_state, MODULE2_state, etc.

Si una variable global solo se va a utilizar dentro de un archivo de origen, no lo declare en el archivo de encabezado correspondiente. En su lugar, declare en la parte superior del archivo de origen y use la palabra clave static . Las variables que deben ser accesibles a otros módulos deben declararse en el archivo de encabezado usando la palabra clave extern . Lo mismo se aplica a las funciones globales. Ayuda a mantener la misma disciplina pública / privada que usaría normalmente en un lenguaje orientado a objetos como C ++, Java, C #, etc.

Ejemplo:

En el módulo.h:

 #ifndef MODULE_H /* Header guard */ #define MODULE_H /* Declarations for entities that CAN be accessed by other modules, ie "public". */ extern int MOD_publicVariable; extern void MOD_publicFunction(int arg); #endif // MODULE_H 

En el módulo.c:

 /* Definitions for entities that CAN be accessed by other modules, ie "public". */ int MOD_publicVariable = 42; void MOD_publicFunction(int arg) {...} /* Declarations for entities that CAN'T be accessed by other modules, ie "private". */ static double MOD_privateVariable = 12.34; static void MOD_privateFunction1(void); static void MOD_privateFunction2(void); /* Function definitions. */ void MOD_privateFunction1(void) { int localVariable; /* This doesn't need the module prefix. */ .... } void MOD_privateFunction2(void) { .... } 

El prefijo del módulo (MOD_) se puede nombrar directamente después de su módulo, o puede usar una abreviatura. Experimenta, y eventualmente te conformarás con una convención que te guste. El uso constante de un prefijo como este emula el concepto de una clase / módulo / espacio de nombres en idiomas OO.

Asegúrese de conocer la diferencia entre statement frente a definición y extern frente a estática.

Me molesta que los libros de texto y los cursos en C ignoren o pasen por alto el arte de la progtwigción de múltiples módulos.

EDITAR: Olvidé mencionar que generalmente no debe hacer que las variables globales sean accesibles a otros módulos (es decir, hacerlos “privados”). Si otros módulos necesitan acceder a esa variable, proporcione las funciones “public” “setter” y / o “getter”.

Solo puede tener una definición por módulo de objeto. El segundo, si tiene el mismo contenido, será ignorado. Si difiere, se producirá un error de comstackción.

Puede que esta no sea la respuesta que está buscando, pero ¿por qué no trata de evitar este tipo de situaciones en primer lugar (y potencialmente el uso (excesivo) de los globales)?

En primer lugar, si este es un problema en primer lugar, está utilizando una biblioteca de mierda y debería volver a escribir / cambiar si es posible. Si no puedes, puedes hacer algo como esto:

otro.h:

 int GLOBAL; //...other stuff 

C Principal

 int GLOBAL; #define GLOBAL OTHER_GLOBAL #include "other.h" #undef GLOBAL int main(int argc,char** argv) { printf("%i %i",GLOBAL,OTHER_GLOBAL); getchar(); return 0; } 

sin embargo, si como lo indican las mayúsculas, GLOBAL es #define ed, esto podría no funcionar. (Pero vale la pena intentarlo de todos modos).