5.2: Alcance

El alcance tiene que ver con dónde se “ven” las variables. Ya hemos mencionado la idea de global y local en trabajos anteriores pero es momento de profundizar un poco más. Generalmente, las variables solo existen dentro del bloque en el que se declaran. Si bien es legal declarar variables dentro de un bloque condicional o bucle, normalmente declaramos variables al comienzo mismo de una función. En consecuencia, estas variables son conocidas dentro de la función. Es decir, su ámbito de referencia está dentro de la función. Nada fuera de la función sabe nada de ellos. Así, decimos que son locales, o quizás localizados, a la función. Por ejemplo, considere los dos fragmentos de función a continuación:

void func1( void )
{
    int x;
    int y;
    //...some code here...
}

void func2( void )
{
    int y;
    int z;
    //...some other code here...
}

No hay forma directa de acceder a la variable z de func2 () desde func1 (). De igual manera, no existe una forma directa de acceder a la variable x de func1 () desde func2 (). Más interesante, ¡las variables y de func1 () y func2 () son completamente diferentes! No se refieren a la misma variable. Esto a veces puede resultar confuso para los nuevos programadores pero es esencial para programas grandes. Imagina que estabas trabajando con un equipo de personas en un programa muy grande, quizás decenas de miles de filas de largo. Si la idea del alcance local no existiera, ¡tendrías que asegurarte de que cada variable del programa tuviera un nombre único! Esto crearía una pesadilla de confusión. Al usar el alcance local, estás diciendo: “Solo necesito esta variable para un trabajo dentro de esta función. Como sólo necesita existir dentro de esta función, su nombre sólo tiene sentido dentro de esta función”.

Si se necesita algún tipo de elemento de datos “universalmente conocido”, podemos recurrir a lo global. Los Globales actúan más o menos como la estática y generalmente se almacenan de la misma manera. Si tienes un programa que consiste en un solo archivo, puedes declarar tus globales enumerándolos al inicio del programa antes (y fuera de) cualquier función. De esta manera serán leídos por el compilador primero y por lo tanto serán “conocidos” por todas las funciones que siguen. No te acostumbras a declarar todas las variables como globales. Esto se considera un método de codificación malo e ineficiente. Adquiera el hábito de usar a los lugareños como norma y recurra a los globales solo cuando se le pide.

Si tiene un proyecto de múltiples archivos, ¿cómo obtiene las funciones en el segundo archivo para reconocer los globales declarados en el primer archivo? En este caso, crearás un archivo de encabezado y usarás la directiva #include. Por ejemplo, supongamos que su proyecto consta de dos archivos fuente C llamados foo.c y bar.c.

En foo.c declaras lo siguiente global:

int m;

Para que las funciones en bar.c “vean” m, crearás un archivo de encabezado, tal vez llamado foo.h. foo.h contendrá lo siguiente:

extern int m;

Lo que significa que un entero llamado m ha sido declarado externamente (es decir, en otro archivo). En la parte superior de bar.c agregarás la línea:

#include <foo.h>

Entonces, cuando se compila bar.c, el compilador primero abrirá foo.h Verá que la variable m ha sido declarada en otra parte y la pone en una “lista de variables conocidas”. Luego continúa compilando el resto de tu código. Cuando se encuentra con m en alguna función, el compilador “entiende” que esta es una variable que fue declarada en otro archivo. ¡No hay problema!

Entonces, ahora puede ver que los archivos de encabezado están compuestos en gran parte de definiciones y declaraciones de otros lugares, a saber, datos externos y prototipos de funciones.