Club Builder

[Andrés]

Antes que nada, hola! Un saludo para la gente de este foro.

Mi consulta es la siguiente: cómo hago una variable global para todos los formularios??
Sólo pude hacer variables globales para cada cpp, o usar el atributo Tag del formulario principal (que existe durante todo el programa), pero no me sirve del todo, porque necesito otros tipos de variables.
En la ayuda no encontré nada.

Gracias de antemano!

Andrés

[fmmarzoa]

Bueno, yo tuve problemas para hacer lo mismo porque el enlazador se hacía el lío ya que, pese a haber incluido los #ifndef... de rigor en el .h donde estaban las variables que pretendían ser globales, el "ioputa" las redefinia una vez por cada módulo... supongo que se podrá hacer algo con extern o static o vaya Vd. a saber... tampoco encontré el método de hacerlo, aunque tampoco busqué mucho...

Al final opté por definir las variables sólo para un módulo y añadir funciones que permitieran el acceso a esas variables, mas o menos como haces para las propiedades de un componente.

Así en, digamos, Globales.h tengo declarado:

[Andrés]

Muchas gracias por tu respuesta!
Pero..... no tenés que incluir el .cpp en vez del .h?

Al incluir este sistema, no te queda una variable distinta en cada módulo, al estar definida al incluir el cpp en cada formulario? O sea, la línea "int MiVariable;" no se va a ejecutar al inicio de cada módulo?

[Andrés]

Bueno, ya lo logré... creo!
Declaré la variable en el cpp del proyecto, fuera del WinMain, y luego, en los cpps que la usan, le puse un "extern nombre;" y listo.... esa variable pasa a ser global para ese cpp, y el valor es único para toda la aplicación.
Lo que ahora quiero hacer es lo mismo pero con una definición de estructura....
O se, tengo hecha una estructura y quiero que este nuevo tipo de dato sea global. Extern no funciona, creo que tendría que incluir un .h en todos los cpp... aunque estoy pensando en hacerlo "como corresponde" y hacerlo con un objeto y listo.

[Enrique]

Hola, andabas bien encaminado. Yo tengo algunas estructuras definidas en el fichero Grafos.h (y sus funciones definidas en Grafos.h e implementadas en Grafos.cpp). Como las necesito en algunas de las unidades de mi proyecto las declaro en el Principal.cpp y coloco la directiva #include "Grafos.h" en su cabecera (Principal.h). Luego declaro una variable en el Principal.cpp y declaro la misma variable como extern en el .cpp de las unidades que las necesitan, y en ese mismo .cpp pongo la directiva #include "Principal.h", con lo que se incluyen en esa unidad todas las cabeceras que tengo en el Principal.h (como Utilidades.h y otras).

El invento funciona y me evita el clásico olvido de incluir cabeceras en cada unidad, lo que no sé (y creo que no es así viendo cómo actúa el IDE del Builder con los #include, que los pone en todos lados incluso repetidos) es si estoy "recargando" el problema al incluir en algunas unidades cabeceras de otras que no utilizo, creo que me explico.

Bueno, suerte en tus intentos.

[WinMan]

La forma mas ordenada de hacerlo es crear un archivo c/cpp que incluye las variables globales y las definiciones en el .h, algo como esto:

archivo: GlobalsUnit.h

//---------------------------------------------------------------------------
#ifndef GlobalsUnitH
#define GlobalsUnitH
//---------------------------------------------------------------------------
#include <vcl.h>
//---------------------------------------------------------------------------
struct stTemp{
int i;
};

extern int iGlobal;
extern char cGlobal;
extern AnsiString strGlobal;
extern stTemp Temp;
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------

Archivo: GlobalsUnit.cpp

//---------------------------------------------------------------------------
#include "GlobalsUnit.h"

int iGlobal;
char cGlobal;
AnsiString strGlobal;
stTemp Temp;
//---------------------------------------------------------------------------

Despues de crear estos archivos, tienes que incluirlos en tu proyecto y el .h en cada archivo que vas a hacer referencia a alguna de las variables globales,

Aqui tienes que tener en cuenta lo siguiente, esto es independiente de c++ builder, es la forma en que esta definido tanto el lenguaje C como C++

- Cualquier variabiable (y/u objeto en C++) que se encuentre fuera de cualquier bloque u ambito (entre las llaves {}, cada grupo {} define un ambito para definición de variables) se considera como una "Definición", o sea, aqui se esta diciendo que hay que crear espacio en el programa para dicha variable (y/u objeto)

- Solo puede existir una "Definición" por cada variable (y/u objeto) en cada ambito, hay que tener en cuenta que si defines una variable dentro de algun bloque o ambito, y el nombre de esa variable existe en algun bloque que contenga al nuevo, esta nueva variable oculta a la del bloque externo mas cercano.

ej.
int x;

int x; // error de compilación, definición de 2 variable con
// el mismo nombre en el mismo ambito (global)

void yy(void)
{
x = 5; // x global
{
char x;
x = 'a'; // se oculta la x global y solo se puede usar la local
// bloque a menos que se use el operador de
// resolución de ambito ::
: = 10; // uso de la x global
}
}


- La palabra reservada extern (no define, solo "Declara") le "Declara" al ligador que existe la definición de la variable que le sigue en algun lado, se usa para que el compilador sepa el tipo de la variable y pueda hacer el chequeo de tipos cuando se utilice dicha variable.

- La palabra reservada "struct" se utiliza para "Declarar" nuevos tipos, por lo tanto se puede usar en cualquier lado varias veces y no genera error de compilación el .h del principio se pudo haber escrito como sigue sin generar errores de compilación:

archivo: GlobalsUnit.h

//---------------------------------------------------------------------------
#ifndef GlobalsUnitH
#define GlobalsUnitH
//---------------------------------------------------------------------------
#include <vcl.h>
//---------------------------------------------------------------------------
struct stTemp{
int i;
};

extern int iGlobal;
extern char cGlobal;
extern AnsiString strGlobal;
extern stTemp Temp;

struct stTemp{
int i;
};

extern int iGlobal;
extern AnsiString strGlobal;

//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------


Como puedes ver, en cuanto al manejo de definiciones y declaraciones hay mucha tela de donde cortar, esta es la base, todavia hay mucho mas, pero para las cosas sencillas creo que con esto es suficiente, si te interesa el tema te recomiendo el libro de "El lenguaje de Programación C 2da edición" de Kernigan/Ritchie, dan una excelente explicación sobre esto, y para las particularidades de C++ esta el libro "El lenguaje de programación C++" de Bjarne Stroustrup (el diseñador del lenguaje).

Espero haber ayudado y no enredar mas las cosas.

Suerte

[Andrés]

Todo lo de los alcances de las variables lo sé... me leí 3 libros de C allá por el 95/96, incluyendo el libro de Kernigan y Ritchie.
Como lo logré ahora, es sin poner ningún include más ni crear otro archivo, pero por el tema de la prolijidad y mejor programación, voy a ver si queda bien haciéndolo con un objeto (porque es una estructura y tengo ya varias funciones que la trabajan). Ahí sí estoy "obligado" a hacer un h y cpp nuevos, y se justificarían un poco más si los hago por un objeto.

Entonces no puedo hacer un extenr sobre un tipo de dato definido en el cpp principal, no? O sea, en la línea de abajo de la declaración de la variable global, defino un tipo de estructura. En el cpp de un formulario, pongo el extern y puedo acceder a la variable, pero no puedo acceder a la definición de la estructura para crear una variable de ese tipo... no queda otra que incluir un h calculo.

[Invitado]

Por cierto, no fueron Kernigan y Ritchie los creadores del lenguaje?? Siempre escuché eso!

[WinMan]

Cuando "Declaras" un tipos usando struct o class solo haces eso, declarar el tipo, no se genera ningun tipo de información para el proceso de ligado, por eso si declaras un strcut o class en un cpp y luego lo quieres usar en otro cpp, tienes que definirlo de nuevo, una "Declaración es local al modulo (o archivo) en el que se incluye, por eso se requieren de los archivos .h

Si observas los archivos que genera el c++ builder, puedes observar que la "Declaración" de la clase TForm esta en el .h y no en el CPP, esto lo hacen para que con incluir el .h puedas compartir la declaración de la clase con cualquier otro modulo. Si lo quieres ver de esta forma, las "Declaraciones" no generan codigo que se incluira en el ejecutable, solo sirven para el manejo de tipos y ottra información que requiere el compilador, las "Definiciones" son las que si se incluyen en el ejecutable, por eso puedes incluir montones de .h en un cpp y no crece tu ejecutable, solo alenta el tiempo de compilado.

Kernigan y Ritchie crearon el lenguaje C
Bjarne Stroustrup creo el lenguaje C++ basado en el Ansi C