una - Diferencia entre variables estáticas, automáticas, globales y locales en el contexto de c y c++

variables globales y locales en visual basic

Question

Tengo un poco de confusión sobre variables static , auto , global y local .

En alguna parte leí que solo se puede acceder a una variable static dentro de la función, pero aún existen (permanecen en la memoria) después de que la función retorna.

Sin embargo, también sé que una variable local también hace lo mismo, entonces, ¿cuál es la diferencia?

Answer 1

Aquí hay dos conceptos separados:

• alcance , que determina dónde se puede acceder a un nombre, y
• duración de almacenamiento , que determina cuándo se crea y se destruye una variable.

Las variables locales (pedantemente, variables con alcance de bloque ) solo son accesibles dentro del bloque de código en el que están declaradas:

void f() {
int i;
i = 1; // OK: in scope
}
void g() {
i = 2; // Error: not in scope
}

Variables globales (pedantemente, variables con alcance de archivo (en C) o ámbito de espacio de nombres (en C ++)) son accesibles en cualquier momento después de su declaración:

int i;
void f() {
i = 1; // OK: in scope
}
void g() {
i = 2; // OK: still in scope
}

(En C ++, la situación es más complicada ya que los espacios de nombres se pueden cerrar y volver a abrir, y se puede acceder a ámbitos distintos del actual, y los nombres también pueden tener alcance de clase. Pero eso se está volviendo fuera del tema).

Las variables automáticas (pedantemente, variables con duración de almacenamiento automático ) son variables locales cuya duración termina cuando la ejecución abandona su ámbito, y se vuelven a crear cuando se vuelve a introducir el alcance.

for (int i = 0; i < 5; ++i) {
int n = 0;
printf("%d ", ++n); // prints 1 1 1 1 1 - the previous value is lost
}

Las variables estáticas (pedantemente, variables con duración de almacenamiento estática ) tienen una duración que dura hasta el final del programa. Si son variables locales, su valor persiste cuando la ejecución abandona su alcance.

for (int i = 0; i < 5; ++i) {
static int n = 0;
printf("%d ", ++n); // prints 1 2 3 4 5 - the value persists
}

Tenga en cuenta que la palabra clave static tiene varios significados aparte de la duración del almacenamiento estático. En una variable o función global, le da un enlace interno para que no sea accesible desde otras unidades de traducción; en un miembro de la clase C ++, significa que hay una instancia por clase en lugar de una por objeto. Además, en C ++ la palabra clave auto ya no significa duración de almacenamiento automático; ahora significa tipo automático, deducido del inicializador de la variable.

Answer 2

Cuando una variable se declara estática dentro de una clase, se convierte en una variable compartida para todos los objetos de esa clase, lo que significa que la variable es más específica para cualquier objeto. Por ejemplo: -

#include<iostream.h>
#include<conio.h>
class test
{
void fun()
{
static int a=0;
a++;
cout<<"Value of a = "<<a<<"/n";
}
};
void main()
{
clrscr();
test obj1;
test obj2;
test obj3;
obj1.fun();
obj2.fun();
obj3.fun();
getch();
}

Este programa generará el siguiente resultado:

Value of a = 1
Value of a = 2
Value of a = 3

Lo mismo ocurre con la variable estática declarada globalmente. El código anterior generará el mismo resultado si declaramos que la variable es una función externa void fun ()

Mientras que si elimina la palabra clave static y declara a como una variable local / global no estática, el resultado será el siguiente:

Value of a = 1
Value of a = 1
Value of a = 1

Answer 3

La diferencia es que las variables estáticas son esas variables: lo que permite retener un valor de una llamada de la función a otra. Pero en el caso de variables locales, el alcance es hasta la duración del bloque / función.

Por ejemplo:

#include <stdio.h>
void func() {
static int x = 0; // x is initialized only once across three calls of func()
printf("%d/n", x); // outputs the value of x
x = x + 1;
}
int main(int argc, char * const argv[]) {
func(); // prints 0
func(); // prints 1
func(); // prints 2
return 0;
}

Answer 4

Las variables locales no existen en la memoria después de la terminación de la función.
Sin embargo, las variables static permanecen asignadas en la memoria durante toda la vida del programa, independientemente de la función que sea.

Además de su pregunta, las variables static se pueden declarar localmente en el alcance de la class o de la función y globalmente en el namespace de namespace o el alcance del archivo. Se les asigna la memoria de principio a fin, es solo la inicialización que ocurre tarde o temprano.

Answer 5

static es una palabra muy sobrecargada en C y C ++. static variables static en el contexto de una función son variables que mantienen sus valores entre llamadas. Existen durante la duración del programa.

las variables locales persisten solo durante el tiempo de vida de una función o cualquiera que sea su alcance envolvente. Por ejemplo:

void foo()
{
int i, j, k;
//initialize, do stuff
} //i, j, k fall out of scope, no longer exist

A veces, este alcance se usa a propósito con { } bloques:

{
int i, j, k;
//...
} //i, j, k now out of scope

las variables globales existen durante la duración del programa.

auto ahora es diferente en C y C ++. auto en C era una forma (superflua) de especificar una variable local. En C ++ 11, ahora se usa automáticamente para derivar automáticamente el tipo de un valor / expresión.

Answer 6

En primer lugar, digo que deberías googlear esto como se define en detalle en muchos lugares

Local
Estas variables solo existen dentro de la función específica que las crea. Son desconocidos para otras funciones y para el programa principal. Como tal, normalmente se implementan usando una pila. Las variables locales dejan de existir una vez que se completa la función que las creó. Se vuelven a crear cada vez que se ejecuta o llama una función.

Global
Se puede acceder (es decir, conocer) a estas variables mediante cualquier función que comprenda el programa. Se implementan asociando ubicaciones de memoria con nombres de variables. No se vuelven a crear si se recuerda la función.

/* Demonstrating Global variables */
#include <stdio.h>
int add_numbers( void ); /* ANSI function prototype */
/* These are global variables and can be accessed by functions from this point on */
int value1, value2, value3;
int add_numbers( void )
{
auto int result;
result = value1 + value2 + value3;
return result;
}
main()
{
auto int result;
value1 = 10;
value2 = 20;
value3 = 30;
result = add_numbers();
printf("The sum of %d + %d + %d is %d/n",
value1, value2, value3, final_result);
}
Sample Program Output
The sum of 10 + 20 + 30 is 60

El alcance de las variables globales puede restringirse colocando cuidadosamente la declaración. Son visibles desde la declaración hasta el final del archivo fuente actual.

#include <stdio.h>
void no_access( void ); /* ANSI function prototype */
void all_access( void );
static int n2; /* n2 is known from this point onwards */
void no_access( void )
{
n1 = 10; /* illegal, n1 not yet known */
n2 = 5; /* valid */
}
static int n1; /* n1 is known from this point onwards */
void all_access( void )
{
n1 = 10; /* valid */
n2 = 3; /* valid */
}

Estático:
El objeto estático es un objeto que persiste desde el momento en que se construye hasta el final del programa. Entonces, los objetos stack y heap están excluidos. Pero los objetos globales, los objetos en el ámbito del espacio de nombres, los objetos declarados estáticos dentro de las clases / funciones y los objetos declarados en el alcance del archivo se incluyen en los objetos estáticos. Los objetos estáticos se destruyen cuando el programa deja de ejecutarse.
Te sugiero que veas esta lista de tutoriales

AUTO:
C, C ++

(Llamadas variables automáticas)

Todas las variables declaradas dentro de un bloque de código son automáticas por defecto, pero esto puede hacerse explícito con la palabra clave auto. [Nota 1] Una variable automática no inicializada tiene un valor indefinido hasta que se le asigna un valor válido de su tipo. [1]

Usar el registro de la clase de almacenamiento en lugar de automático es una pista para que el compilador guarde en caché la variable en un registro de procesador. Además de no permitir que el operador de referencia (&) se utilice en la variable o cualquiera de sus subcomponentes, el compilador puede ignorar la sugerencia.

En C ++, se llama al constructor de variables automáticas cuando la ejecución alcanza el lugar de declaración. Se llama al destructor cuando alcanza el final del bloque de programa dado (los bloques de programa están rodeados por corchetes). Esta característica se usa a menudo para administrar la asignación de recursos y la desasignación, como abrir y luego cerrar archivos automáticamente o liberar memoria. VER WIKIPEDIA