Si está siguiendo nuestra serie de tutoriales de programación en C, debe conocer el concepto de variables. Si bien hemos discutido los conceptos básicos de las variables, hay otro aspecto importante relacionado con las variables que discutiremos aquí:alcance de las variables .
Comencemos con el código de intercambio de valores que usamos en uno de nuestros tutoriales anteriores:
#include <stdio.h>
void swap (int val1, int val2)
{
int temp = 0;
temp = val1;
val1 = val2;
val2 = temp;
printf("\nSwapped values are: %d and %d", val1,val2);
}
int main()
{
int a=0, b=0;
printf("Enter two integer values\n");
scanf("%d %d",&a,&b);
printf("Entered values are: %d and %d", a,b);
swap(a,b);
return 0;
}
Aquí, en este fragmento de código, las variables 'val1' y 'val2' tienen alcance local, lo que significa que cobran vida cuando se llama a la función 'swap' y mueren tan pronto como finaliza la llamada a 'swap'. Simplemente no puede acceder a 'val1' y 'val2' antes o después de la llamada a la función 'swap'. De manera similar, el alcance de las variables 'a' y 'b' también es local:local para la función 'principal'.
Tenga en cuenta que estas variables de ámbito local también se conocen como variables automáticas.
Ahora bien, mientras que las variables con alcance local se limitan al bloque en el que se declaran, existe otro tipo de variables cuyo alcance es global. Como sugiere el nombre, las variables de alcance global se pueden usar en todas las funciones. Por ejemplo, la variable 'var' es una variable entera global y se puede usar en las funciones 'principal' y 'intercambiar'.
#include <stdio.h>
int var;
void swap (int val1, int val2)
{
int temp = 0;
temp = val1;
val1 = val2;
val2 = temp;
printf("\nSwapped values are: %d and %d", val1,val2);
}
int main()
{
int a=0, b=0;
printf("Enter two integer values\n");
scanf("%d %d",&a,&b);
printf("Entered values are: %d and %d", a,b);
swap(a,b);
return 0;
}
Por defecto, el valor '0' se asigna a las variables globales. Pero ese no es el caso con las variables locales:debe asignarles un valor cuando se definen, de lo contrario, tienen un valor basura. Por ejemplo, en el siguiente programa:
#include <stdio.h>
int var;
int main()
{
int a;
printf("Local variable 'a' currently holds: %d", a);
printf("\n Global variable var currently holds: %d", var);
return 0;
}
Hay muchas posibilidades de que obtenga un valor distinto de cero para 'a'. 'var' por otro lado, siempre será cero al principio.
Continuando, ¿puede haber variables globales y locales del mismo nombre? Bueno, la respuesta es sí. Bien, entonces, ¿qué producirá el siguiente fragmento de código en la salida:
#include <stdio.h>
int var = 5;
int main()
{
int var = 10;
printf("Local variable 'a' currently holds: %d", var);
printf("\n Global variable var currently holds: %d", var);
return 0;
}
Bueno, la salida será '10' en ambos casos. La razón es que la variable local 'var' anulará la 'var' global. Entonces, ahora la siguiente pregunta lógica es, ¿cómo acceder a la 'var' global dentro de 'main' en este caso? Lamentablemente, la respuesta es no. De hecho, debe evitar meterse en situaciones como estas cuando trabaje con lenguaje C.
Luego viene el concepto de variables 'externas'. En términos simples, al usar la palabra clave 'extern' con cualquier declaración de variable, le está diciendo al compilador que esta variable ya está declarada/definida en otro lugar y solo la estamos usando aquí. Por ejemplo, en el siguiente fragmento de código, el compilador no sabe que existe 'var' cuando intenta compilar la instrucción printf dentro de la función principal.
#include <stdio.h>
int main()
{
printf("\n Global variable var currently holds: %d", var);
return 0;
}
int var = 5;
Es por eso que aparece un error como el siguiente durante la compilación:
main.c: In function ‘main’:
main.c:14:58: error: ‘var’ undeclared (first use in this function)
printf("\n Global variable var currently holds: %d", var);
^
main.c:14:58: note: each undeclared identifier is reported only once for each function it appears in
Pero si declara 'var' como externo aquí, verá que todo funciona bien. Eso es porque el compilador finalmente llega a la declaración 'var' original.
#include <stdio.h>
int main()
{
extern int var;
printf("\n Global variable var currently holds: %d", var);
return 0;
}
int var = 5;
Y obtienes el resultado correcto:
Global variable var currently holds: 5
Así es como funciona extern. Las variables externas a menudo se usan cuando su programa/proyecto se divide en varios archivos de código fuente y quiere, por ejemplo, usar en 'archivo1', una variable definida en 'archivo2'.
Y finalmente, como estamos discutiendo los alcances de las variables, sería mejor si discutiéramos aquí también las variables 'estáticas'. Las variables estáticas son especiales en el sentido de que conservan su valor incluso después de salir del alcance. Esto significa que se inicializan solo una vez, que es la primera vez.
static int counter
A continuación se muestra un fragmento de código que utiliza una variable estática para contar el número de veces que se llama a una función.
#include <stdio.h>
int swap (int val1, int val2)
{
static int counter = 1;
int temp = 0;
temp = val1;
val1 = val2;
val2 = temp;
printf("\n Function called %d times\n", counter);
counter++;
}
int main()
{
int a=9, b=4;
swap(a,b);
swap(a,b);
swap(a,b);
return 0;
}
Aquí está el resultado:
Function called 1 times
Function called 2 times
Function called 3 times
Como puede ver, la variable 'contador' mantuvo su valor incluso después de salir del alcance. Al igual que las variables globales, las variables estáticas también tienen un valor predeterminado de '0'.
En este tutorial, discutimos varios conceptos importantes, todos relacionados con el alcance de las variables en el lenguaje de programación C. No olvide crear sus propios programas para comprender mejor la diferencia entre variables externas, estáticas, globales y locales. Y como siempre, ante cualquier duda o consulta, deja un comentario más abajo.