En cuanto se adquiere algo de experiencia escribiendo software se descubre que hacer todo en un ъnico fichero fuente no va a funcionar. Es como guardar toda la ropa en una ъnica caja grande - al final los calcetines acaban perdidos en el fondo. La mayorнa de programas estбn compuestos de mбs de un fichero fuente, y cada fuente contiene un "mуdulo" de funcionalidad, normalmente independientes independiente de modo que se pueda trabajar con el? por separado y (con suerte) probarlo tambiйn por separado.

Otra razуn para usar mъltiples fuentes es para poder escribir diferentes partes del programa en distintos lenguajes. Por ejemplo, gcc utiliza C para la mayorнa de los mуdulos, pero usa bison para compilar la gramбtica. Cuando se usan varios fuentes tambien se reduce el ciclo de depuraciуn, porque la mayorнa de los fuentes ya estarбn compilados cuando tengas que recompilar tu programa tras arreglar ese ъltimo bug :-)

En cualquier caso, el propуsito de esta parte de la Guнa es ayudarte a entender cуmo crear un programa que estб constituido por mбs de un fichero fuente.

La primera cosa que debes entender es el concepto de "sнmbolo global". Los Sнmbolos son cosas tales como funciones y variables. Los sнmbolos globales son aquellos que son accesibles para todo el programa. Por ejemplo:

int c;

int foo(int x)
{
  int y = x * 2 + 1 + c;
  printf("foo(%d)=%d\n", x, y);
}

En este fragmento de cуdigo, los sнmbolos c y foo son globales; c porque es una variable declarada fuera de cualquier funciуn, y foo porque es una funciуn que otras partes del programa serбn capaces de usar. Hay tambiйn otro sнmbolo global - printf. Aunque este fragmento no define printf, si usa este simbolo. La diferencia estб en que foo estб definida por nosotros y printf es exterior para nosotros.

Considera estas dos funciones, cada una en su propio fichero fuente:

int foo(int x)                  int bar(int j)
{                                 {
  return bar(x) + 47;           printf("j is %d\n", j);
}                                     return j*j;
                                   }

En este ejemplo, el fichero de la izquierda define el sнmbolo global foo y hace referencia al sнmbolo externo bar. El fichero de la derecha, en cambio, define el sнmbolo globar bar y hace referencia al sнmbolo externo printf.

Cuando compilas estos ficheros para obtener los ficheros objeto, usando "gcc -c foo.c" y "gcc -c bar.c" (adelante prъebalo), el compilador no sabe cуmo resolver esas referencias a los sнmbolos que no conoce. їQuй es lo que hace? Prбcticamente nada. Tan sуlo escribe la informaciуn que le falta en el fichero objeto, y aplaza el problema para despuйs. їCuando es despuйs? Una vez que estбn todos los ficheros compilados, hay que enlazarlos. Unix llama a esto "loading" (carga), algo como "cбrgalos todos en un programa", por lo tanto, el programa que hace esto se llama ld (de "loading"), aunque es gcc el que se encarga de llamar a ld por tн.

Cuando se combinan estos ficheros objeto (junto con la biblioteca estбndar de C, lo que sucede automбticamente), el enlazador (ld) crea una gran lista con todos los sнmbolos globales, definidos y externos, que se encuentran en todos los objetos. Despues asigna las referencias a los sнmbolos con sus definiciones. Si aъn asн hay algun sнmbolo sin definir, se produce un error - "unresolved external". Si no falta ninguno , ya tienes tu programa!

Otra cosa que hace el enlazador (linker) es asegurarse de que no haya sнmbolos definidos en dos ficheros distintos (o mбs). Por ejemplo, ningъn programa puede tener dos funciones llamadas foo - їquй sentido tendrнa? Esto se aplica tambiйn a las variables, que es donde tropieza mucha gente. Observa estos dos ficheros:

int size = 42;			extern int size;

En este ejemplo, el fichero de la izquierda define la variable size y el derecho hace referencia a la variable externa size. Cuando los enlazas juntos, todo es perfecto. Ahora considera esto:

int size = 42;			int size;

En este caso, ambos ficheros definen la variable size, asн que cuando los enlazas hay un problema. Aunque esto parece obvio, mucha gente pone la definiciуn de las variables en un fichero de encabezamiento (.h "header file"), que se incluye en mъltiples ficheros fuente, y por tanto (sin darse cuenta definen las variales) se define una vez en cada fichero. ЎUsa siempre extern en los ficheros de encabezamiento! Recuerda tambiйn que extern solo no definirб el sнmbolo. La definiciуn de la variable debe estar (tambien, por lo menos, en uno) en alguno de los fuentes.

Muy bien, ya vale de sнmbolos. їCуmo se compilan y enlazan estos ficheros? Empecemos con estos dos ficheros fuente, main.c y foo.c:

int main(void)                            int foo(int x)
{                                             {
  printf("foo(4)=%d\n", foo(4));      return 2*x+1;
  exit(0);                                   }
}

Lo primero que debemos hacer es compilar estos ficheros para obtener ficheros objeto. Usa un comando como este:

gcc -c main.c
gcc -c foo.c

Podrнas haber usado tambiйn "gcc -c main.c foo.c", los resultados son los mismos. Sin embargo, el mйtodo de los dos comandos es mejor una vez que aprendes a usar make para automatizar las compilaciones. El resultado son dos ficheros nuevos en tu directorio, main.o y foo.o. Estos son los ficheros objeto. Cada uno contiene las versiones compiladas de los fuentes, junto con las tablas de sнmbolos y otras informaciones.

Para ver las tablas de sнmbolos, prueba este comando:

nm main.o foo.o

Para generar el programa final, usa gcc de nuevo:

gcc main.o foo.o -o main.exe

Cuando ejecutes main.exe, verбs que Ўmuestra el valor correcto! Si no, puedes editar tan sуlo uno de los ficheros, recompilar sуlo ese, y simplemente enlazar los dos ficheros objetos al final. Aunque esto no parece que ahorre mucho, imagнnate tener que construir gcc. Tiene cientos de ficheros fuente y tarda unos 20 minutos para construirlo desde cero. Si se edita y compila tan sуlo uno de los ficheros fuente se tarda menos de un minuto, incluida la creaciуn del programa. Un buen ahorro їno?