Hola, tengo un archivo de cabecera donde defino numerosas macros para el proyecto, a partir de la directiva de preprocesador #define.

Pero para definir strings no puedo usar la directiva, por ello creo que es mejor usar "extern const string variable_global", pero en un archivo de cabecera no puedo inicializarla.

Entonces surge el problema.

Si la inicializo en otro archivo sea cual sea, quedará inicializada con ese  valor para todos los demás ¿no?.

Si en el main inicializo todas, o a partir de otra función, esa variable queda definida ya para todos los .cpp ¿no?

Saludos y gracias.

Edito: O poner en el archivo header las variables como:

extern const string str1;
extern const string str2;

Y en el .cpp poner:

extern const string str1 = "idudifu";
extern const string str2="difaodhfio";

Al compilar el proyecto y añadir el header en todos los .cpp estos podrán usar las macros ya inicializadas no?

Edito: O bueno siempre se puede usar la opción sencilla y mala, de declararlas directamente en el header como string o lo que sean e incluir el header para cada .cpp que lo necesite, en ese caso se compilarán para cada .cpp varias veces (supongo que #define hará lo mismo), pero sería mucho más sencillo.

He probado a declarar el extern y me ha dado 300 fallos not the way.

En un archivo de cabecera no se deben implementar clases ni inicializar variables, solo se pueden declarar, es lo más correcto.

Partiendo de ahí, quería poner unas variables globales para todo el proyecto, las declaro en un archivo macro.h, luego voy a macro.cpp y las inicializo.

Luego si añado macro.h al main, ¿tendré el valor con las que las inicialice en macro.cpp?, esa es la pregunta.

De todas formas, me he dado cuenta de que lo estaba haciendo mal, porque había usado un archivo .h lleno de #define con cosas de configuración, lo correcto sería dividirlo para cada .h, tengo que cambiarlo.

Saludos.

La verdad he estado un poco ocupado entre horas, pero lo que he acabado haciendo ha sido distribuir las macros entre los distintos headers para que así no haya macros en códigos que no se vayan a utilizar, lo malo que para cambiarlas tengo que ir de cabecera en cabecera.

Me he dado cuenta que extern no vale para nada:

extern int casa = 5;

Pues es lo mismo que decir

int casa = 5;

Y declararla como global en una cabecera, para usarla debes incluir su cabecera en el código, luego es lo mismo, que no poner extern, luego es useless.

Entonces las variables globales que si use en varios archivos tengo 2 opciones o copiarlas para cada header, o crear un header y añadir el header a los headers.

Ahora que lo pienso seguramente usando las directivas de preprocesador quizás podamos hacer que se añadan las que queramos dependiendo del header a las que las estemos añadiendo, es decir crear un header con variables globales compartidas:

header_global.h

#ifdef CASAS
#define  casa;
int const casita;
#else
...

Y en los headers que añadiría header_global.h, pondría #define CASAS  si quiero añadir casa y casita, y no poner nada si quiero añadir las demás por poner un ejemplo, aunque no se si valdrá para declarar variables globales en plan "const int casa", o solo macros con #define, que seguramente sea solo lo segundo, pero es algo que mejora la calidad del código en mi opinión hacerlo así.

Gracias y un saludo.

Ya veo, aunque hay que incluit los código fuente o cabeceras en el código fuente que queramos usar la variable, luego es lo mismo que si declaramos una variable en un header y vamos incluyendo el header en códigos, tendremos acceso a ella, sino me equivoco que no estoy seguro pues siempre suelo usar #define.

Aunque no me acaba de convencer esto del extern, mejor considero usar variables globales, y diferenciar variables a definir para cada cabecera como puse anteriormente, porque eso de tener una variable, declararla en un lado inicializarla en otro, luego en otro que ya no sabes ni lo que vale etc XD, mejor variables globales XD.

Saludos.

Ah vale, es que pense que como ponías lo del "a.cpp" y "b.cpp", pensé que lo necesitaban ok.

Saludos y gracias XP