Variáveis locais e globais

Já tivemos oportunidade de trabalhar com variáveis locais e globais sem, contudo, entrar em detalhes acerca de suas particularidades.

Comecemos pelas variáveis locais. Imaginemos o seguinte bloco de códigos com as respectivas mensagens de erro na forma de comentários:

void __fastcall TForm1::Button1Click(TObject *Sender)
{ // início do primeiro bloco (bloco externo)

    // [C++ Error] Unit1.cpp(20): E2451 Undefined symbol 'a'.
   Label1->Caption = a; 

        { // início do segundo bloco (bloco interno)

        int a = 10, b = 20;
        Label2->Caption = a + b; // Ok. Label2 enxerga as variáveis "a" e "b"

        // [C++ Error] Unit1.cpp(24): E2451 Undefined symbol 'c'.
        Label3->Caption = a + b + c; // Erro. Label3 não enxerga "c"

         // [C++ Error] Unit1.cpp(25): E2238 Multiple declaration for 'c'.
        int c = 30;
        } // fim do bloco interno

    //[C++ Error] Unit1.cpp(27): E2451 Undefined symbol 'c'.
   Label4->Caption = c;

} // fim do bloco externo

Analisemos o código. No exemplo acima visualizamos dois blocos de código: um externo e outro interno.

1 - O componente Label1 não enxerga a variável porque sua chamada encontra-se antes e fora do bloco da declaração de a;

2 - não temos qualquer problema com o componente Label2 porque sua chamada se encontra no mesmo bloco e após as declarações das variáveis a e b;

3 - Embora a chamada a Label3 se encontre no mesmo bloco, é anterior à declaração da variável c.

4 - Label4 não enxerga a variável c pelo fato de estar fora do bloco onde tal variável é declarada.

Conclusão: podemos entender como locais as variáveis que se encontram declaradas dentro de determinado bloco, com a ressalva de que essas variáveis são visíveis apenas dentro desse bloco e a partir do local de sua declaração:

Já as variáveis globais devem ser declaradas antes e fora de qualquer função, uma vez que elas serão visíveis somente pelas instruções posteriores à sua declaração. Logo se você quiser que uma variável seja "vista" por todas as funções de uma determinada Unit, pode declará-la na região dos include. A seguir ilustramos um exemplo que demonstra a o relacionamento existente entre as variáveis globais e locais:

//--------------------------------------------------------------------------- 
// Unit1.cpp 

#include <vcl.h> 
#pragma hdrstop 

#include "Unit1.h" 
//--------------------------------------------------------------------------- 
#pragma package(smart_init) 
#pragma resource "*.dfm" 
TForm1 *Form1; 
//--------------------------------------------------------------------------- 
int global_1 = 50; // declara e inicializa variável global 
//--------------------------------------------------------------------------- 

__fastcall TForm1::TForm1(TComponent* Owner) 
: TForm(Owner) 
{ 
} 
//--------------------------------------------------------------------------- 

void __fastcall TForm1::Button1Click(TObject *Sender) 
{ 
/*o código abaixo apresentará um erro, pois 
Button1Click não enxerga global_2 */ 

Label1->Caption = global_1 + global_2; 
} 
//--------------------------------------------------------------------------- 


int global_2; //variável que será visível somente pelas funções abaixo dela

void __fastcall TForm1::Button2Click(TObject *Sender)
{ 
global_2 = 45; // aqui essa variável adquire característica de global 

int local_de_Button2Click = 12; // variável local 

// não haverá erro 
Label1->Caption = global_1 + global_2 + local_de_Button2Click; 

} 
//--------------------------------------------------------------------------- 

void __fastcall TForm1::Button3Click(TObject *Sender) 
{ 
// ERRO: local_de_Button2Click não pode ser visualizada 
// pelo evento OnClick de Button3. ELA É LOCAL A Button2Click 

Label1->Caption = global_1 + global_2 + local_de_Button2Click; 
} 
//--------------------------------------------------------------------------- 

Muito importante: as variáveis locais são criadas pelo aplicativo cada vez que sua declaração é encontrada pela execução do programa e são destruídas cada vez que a execução sai do bloco em que elas se encontram; já as variáveis globais são criadas uma única vez no início do programa e destruídas uma única vez no encerramento do programa.

O resultado da observação acima é que, cada vez que uma variável local for destruída, se ela for criada novamente, não terá conservado o valor que possuía no momento em que foi destruída. Será inicializada novamente com o valor que lhe for atribuído no momento apropriado.

Quanto às variáveis globais, seus valores vão sendo alterados durante a execução do programa, sendo que cada vez que tal variável for chamada trará em si o valor resultante da última operação em que foi tratada.