VARIABLES GLOBALES Y LOCALES

octubre 1, 2007

VARIABLES GLOBALES Y LOCALES

VARIABLES GLOBALES

Hasta ahora hemos diferenciado a las variable segun su “tipo” (int, char double, etc), el cual se refería, en última instancia, a la cantidad de bytes que la conformaban. Veremos ahora que hay otra diferenciación de las mismas, de acuerdo a la clase de memoria en la que residen.

Si definimos una variable AFUERA de cualquier función (incluyendo esto a main() ), estaremos frente a lo denominado VARIABLE GLOBAL. Este tipo de variable será ubicada en el segmento de datos de la memoria utilizada por el programa, y existirá todo el tiempo que esté ejecutándose este.

Este tipo de variables son automáticamente inicializadas a CERO cuando el programa comienza a ejecutarse.

Son accesibles a todas las funciones que estén declaradas en el mismo, por lo que cualquiera de ellas podrá actuar sobre el valor de las mismas.

Por ejemplo:

 

#include <stdio.h>

double una_funcion(void);

double variable_global ;

main()

{

double i ;

printf(“%f”, variable_global );             /* se imprimirá 0 */

i = una_funcion() ;

printf(“%f”, i );                                     /* se imprimirá 1 */

printf(“%f”, variable_global );               /* se imprimirá 1 */

variable_global += 1 ;

printf(“%f”, variable_global );               /* se imprimirá 2 */

return 0 ;

}

double una_funcion(void)

{

return( variable_global  += 1) ;

}

 

 

int y; /* Global. Conocida tanto por main() como por MiFuncion() */

 

main ()

{

     int x;                                               /* Esta x es local a main () */

     y = 100;

     x = 1;

     printf (“x=%d, y=%d”, x, y)        /* Visualiza x=1, y=100 */

     {                                                      /* Comienza bloque */

          int x;                                           /* Esta x es local al bloque */

          x = 2;

          printf (“x=%d, y=%d”, x, y)               /* Visualiza x=2, y=100 */

          MiFuncion ()                              /* Visualiza x=3, y=100 */

          printf (“x=%d, y=%d”, x, y)               /* Visualiza x=2, y=100 */

     }                                                      /* Fin del bloque */

     printf (“x=%d, y=%d”, x, y)        /* Visualiza x=1, y=100 */

}

 

MiFuncion ()

{

     int x;                                               /* Local a MiFuncion() */

     x = 3;

     printf (“x=%d, y=%d”, x, y)        /* Visualiza x=3, y=100 */

}

 

Observemos que la variable_global está definida afuera de las funciones del programa, incluyendo al main(), por lo que le pertenece a TODAS ellas. En el primer printf() del programa principal se la imprime, demostrandose que está automaticamente inicializada a cero .

Luego es incrementada por una_funcion() que devuelve ademas una copia de su valor, el cual es asignado a i ,la que, si es impresa mostrará un valor de uno, pero tambien la variable_global ha quedado modificada, como lo demuestra la ejecución de la sentencia siguiente. Luego main() tambien modifica su valor , lo cual es demostrado por el printf() siguiente.

Esto nos permite deducir que dicha variable es de uso público, sin que haga falta que ninguna función la declare, para actuar sobre ella.

VARIABLES LOCALES


A diferencia de las anteriores, las variables definidas DENTRO de una función, son denominadas VARIABLES LOCALES a la misma, a veces se las denomina también como AUTOMÁTICAS, ya que son creadas y destruidas automáticamente por la llamada y el retorno de una función, .

respectivamente.

Estas variables se ubican en la pila dinámica (stack) de memoria , destinándosele un espacio en la misma cuando se las define dentro de una función, y borrándose cuando la misma devuelve el control del programa, a quien la haya invocado.

Este método permite que, aunque se haya definido un gran número de variables en un programa, estas no ocupen memoria simultáneamente en el tiempo, y solo vayan incrementando el stack cuando se las necesita, para luego, una vez usadas desaparecer, dejando al stack en su estado original.
El identificador ó nombre que se la haya dado a una variable es sólo relevante entonces, para la función que la haya definido, pudiendo existir entonces variables que tengan el mismo nombre, pero definidas en funciones distintas, sin que haya peligro alguno de confusión .
La ubicación de estas variables locales, se crea en el momento de correr el programa, por lo que no poseen una dirección prefijada, esto impide que el compilador las pueda inicializar previamente. Recuérdese entonces que, si no se las inicializa expresamente en el momento de su definición, su valor será indeterminado (basura).

Anuncios

Una respuesta to “VARIABLES GLOBALES Y LOCALES”

  1. Sergio Sanchez said

    muchas gracias

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión /  Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión /  Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión /  Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión /  Cambiar )

w

Conectando a %s

A %d blogueros les gusta esto: