Diferença entre variables ​​estáticas, automáticas, globais e locais no contexto de c e c ++

Eu tenho um pouco de confusão sobre variables static , auto , global e local .

Em algum lugar eu li que uma variável static só pode ser acessada dentro da function, mas elas ainda existem (permanecem na memory) depois que a function retorna.

No entanto, também sei que uma variável local também faz o mesmo, então qual é a diferença?

Existem dois conceitos separados aqui:

  • escopo , que determina onde um nome pode ser acessado e
  • duração do armazenamento , que determina quando uma variável é criada e destruída.

Variáveis locais (pedantemente, variables ​​com escopo de bloco ) são acessíveis apenas dentro do bloco de código no qual elas são declaradas:

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

Variáveis globais (pedantemente, variables ​​com escopo de arquivo (em C) ou escopo de namespace (em C ++)) são acessíveis a qualquer momento após sua declaração:

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

(Em C ++, a situação é mais complicada, pois os namespaces podem ser fechados e reabertos, e escopos diferentes do atual podem ser acessados, e os nomes também podem ter escopo de class. Mas isso está ficando muito fora do tópico.)

Variáveis automáticas (pedantemente, variables ​​com duração de armazenamento automático ) são variables ​​locais cujo tempo de vida termina quando a execução deixa seu escopo e são recriadas quando o escopo é reinserido.

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

Variáveis estáticas (pedantemente, variables ​​com duração de armazenamento estático ) têm uma vida útil que dura até o final do programa. Se forem variables ​​locais, seu valor persistirá quando a execução deixar seu escopo.

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

Observe que a palavra-chave static tem vários significados além da duração do armazenamento estático. Em uma variável ou function global, ela fornece uma binding interna para que não seja acessível a partir de outras unidades de tradução; em um membro da class C ++, significa que há uma instância por class, em vez de uma por object. Além disso, em C ++, a palavra auto chave auto não significa mais a duração do armazenamento automático; agora significa tipo automático, deduzido do inicializador da variável.

Primeiro de tudo eu digo que você deve google isso como é definido em detalhes em muitos lugares

Local
Essas variables ​​existem apenas dentro da function específica que as cria. Eles são desconhecidos para outras funções e para o programa principal. Como tal, eles são normalmente implementados usando uma pilha. As variables ​​locais deixam de existir quando a function que as criou é concluída. Eles são recriados toda vez que uma function é executada ou chamada.

Global
Essas variables ​​podem ser acessadas (ou seja, conhecidas) por qualquer function que compõe o programa. Eles são implementados associando locais de memory a nomes de variables. Eles não são recriados se a function for recuperada.

 /* Demonstrating Global variables */ #include  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 

O escopo das variables ​​globais pode ser restrito colocando-se cuidadosamente a declaração. Eles são visíveis da declaração até o final do arquivo de origem atual.

 #include  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:
Objeto estático é um object que persiste desde o momento em que é construído até o final do programa. Portanto, os objects stack e heap são excluídos. Mas objects globais, objects no escopo de namespace, objects declarados como estáticos dentro de classs / funções e objects declarados no escopo do arquivo são incluídos em objects estáticos. Objetos estáticos são destruídos quando o programa pára de ser executado.
Eu sugiro que você veja esta lista de tutoriais

AUTO:
C, C ++

(Variáveis ​​automáticas chamadas.)

Todas as variables ​​declaradas dentro de um bloco de código são automáticas por padrão, mas isso pode ser explicitado com a palavra-chave auto. [Note 1] Uma variável automática não inicializada tem um valor indefinido até que seja atribuído um valor válido de seu tipo.

Usar o registro de class de armazenamento em vez de auto é uma dica para o compilador armazenar em cache a variável em um registrador de processador. Além de não permitir que o operador de referência (&) seja usado na variável ou em qualquer um de seus subcomponentes, o compilador está livre para ignorar a dica.

Em C ++, o construtor de variables ​​automáticas é chamado quando a execução atinge o local de declaração. O destruidor é chamado quando atinge o final do bloco de programa fornecido (os blocos de programa são cercados por chaves). Esse recurso costuma ser usado para gerenciar a alocação de resources e a desalocação, como abrir e fechar automaticamente os arquivos ou liberar memory. VER WIKIPEDIA

A diferença é que as variables ​​estáticas são aquelas variables: o que permite que um valor seja retido de uma chamada da function para outra. Mas no caso de variables ​​locais, o escopo é até o tempo de vida do bloco / function.

Por exemplo:

 #include  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; } 

Variáveis ​​locais são inexistentes na memory após o término da function.
No entanto, static variables static permanecem alocadas na memory durante toda a vida do programa, independentemente de qualquer function.

Além da sua pergunta, static variables static podem ser declaradas localmente no escopo de class ou function e globalmente no namespace ou no escopo do arquivo. Eles são alocados a memory do começo ao fim, é apenas a boot que acontece mais cedo ou mais tarde.

static é uma palavra muito sobrecarregada em C e C ++. variables static no contexto de uma function são variables ​​que mantêm seus valores entre as chamadas. Eles existem para a duração do programa.

Variáveis ​​locais persistem apenas pelo tempo de vida de uma function ou qualquer que seja seu escopo. Por exemplo:

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

Às vezes, esse escopo é usado propositalmente com { } blocos:

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

existem variables ​​globais para a duração do programa.

auto é agora diferente em C e C ++. auto em C era um modo (supérfluo) de especificar uma variável local. Em C ++ 11, o auto agora é usado para derivar automaticamente o tipo de um valor / expressão.

Quando uma variável é declarada estática dentro de uma class, ela se torna uma variável compartilhada para todos os objects dessa class, o que significa que a variável é mais específica para qualquer object. Por exemplo: –

 #include #include class test { void fun() { static int a=0; a++; cout<<"Value of a = "< 

Este programa gerará a seguinte saída:

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

O mesmo vale para a variável estática declarada globalmente. O código acima irá gerar a mesma saída se declararmos a variável como uma function externa void fun ()

Considerando que se você remover a palavra-chave static e declarar a como uma variável local / global não estática, a saída será a seguinte:

 Value of a = 1 Value of a = 1 Value of a = 1 
Intereting Posts