Variável Local, Global, Constante Global e Variável estática

Neste tutorial de nossa apostila de C++, vamos aprender um pouco mais da relação entre funções e variáveis, conhecendo os tipos locais, global, constantes e estáticas.

Variável Local

Quando declaramos uma variável dentro de uma função, dizemos que ela é local.
Isso se deve ao fato dela 'existir' apenas pra quem está dentro da função, ou seja, só ali dentro podem enxergar ela e seu valor.

Outros comandos, em outras funções, não podem acessar ela normalmente.

Para ilustrar isso, vamos declarar a variável myVar com valor 1, dentro da main().
Em seguida, vamos chamar a função imprime(), que vai imprimir o valor de myVar:

#include <iostream>
using namespace std;

void imprime()
{
    cout<<myVar;
}

int main()
{
    int myVar=1;
    imprime();
    return 0;
}

Esse código nem compilado é, aparece o erro:
" ‘myVar’ was not declared in this scope|"

Ou seja, a variável myVar não está dentro do escopo da função imprime(), é como se ela não existisse.
Vale o contrário também:

#include <iostream>
using namespace std;

void imprime()
{
    int myVar=1;
}

int main()
{
    cout<<myVar;
    return 0;
}

Ou seja, nem mesmo a função main() consegue visualizar o conteúdo interno da função imprime().

Agora vamos declarar a myVar tanto dentro da imprime() quanto dentro da main(), e vamos imprimir os dois valores:

#include <iostream>
using namespace std;

void imprime()
{
    int myVar=1;
    cout << "Na imprime() = "<<myVar<<endl;
}

int main()
{
    int myVar=2;
    cout << "Na main() = "<<myVar<<endl;
    imprime();
    return 0;
}

O resultado é:

Ou seja, podemos declarar variáveis de nomes iguais, mas em funções diferentes.
E as funções só 'enxergam' aquilo que está dentro da função, ok?

Variável Global

Existe uma maneira de fazer com que uma mesma variável seja vista e acessada por diversas funções, basta fazê-la ser uma variável global.

Para isso, basta declarar ela fora do escopo das funções.
Por exemplo, vamos declarar a variável pi, e armazenar o valor do pi.

Em seguida, vamos pedir o valor do raio ao usuário, e através de outras duas funções, calculamos o perímetro e a área do círculo:

#include <iostream>
using namespace std;
float pi = 3.14;

float perimeter(float r)
{
    return 2*pi*r;
}

float area(float r)
{
    return pi*r*r;
}

int main()
{
    float rad;

    cout<<"Raio: ";
    cin>>rad;

    cout<<"Perímetro: " << perimeter(rad)<<endl;
    cout<<"Área     : " << area(rad)<<endl;

    return 0;
}

Veja que usamos a variável pi nas funções, sem ter declarado dentro do escopo delas.
Se fossemos usar variáveis locais, teríamos que declarar a pi mais de uma vez, o que não seria muito eficiente.

Use variáveis globais quando elas forem necessárias em vários trechos diferentes de seu código.
E você pode usar o mesmo nome para uma variável local e global. Nesse caso, a variável local vai ter prioridade.

Constantes Globais

Muitíssimo cuidado ao usar variáveis globais. Em programas complexos, é fácil 'perder o controle' de variáveis globais, visto que elas podem ser alteradas em qualquer lugar do código.

Na maioria dos casos, dê prioridade para o uso de argumentos mesmo.
Porém, caso queira usar variáveis globais que não devam ser alteradas, use a palavra-chave const antes declarar a variável:

• const float pi = 3.14

Vamos supor que um hacker invadiu seu sistema, e inseriu uma função chamada muda(), que vai alterar o valor do pi para 4, sabotando seu projeto:

#include <iostream>
using namespace std;
const float pi = 3.14;

void muda()
{
    pi = 4;
}

int main()
{
    muda();

    return 0;
}

Como a variável foi declarada com a keyword const, vai dar o erro:
"|7|error: assignment of read-only variable ‘pi’| "

Ou seja, a variável é somente para leitura, não pode alterar o 'pi'. E, de fato, em nenhum programa se deve alterar o pi, logo, faz sentido ele ser global e constante, concorda?

Vamos supor que você vai criar um sistema para uma grande rede de supermercados, e vai definir o preço do desconto em 10%, faça:

• const float desconto = 0.1;

Pronto. Agora, milhares de funções podem acessar o valor do desconto.
E caso você queira aumentar o desconto pra 20%?
Moleza, só fazer:

• const float desconto = 0.2;

Veja que você alterou só uma coisinha, só uma variável. Mas, automaticamente, modificou diretamente os cálculos das milhares de funções que usam essa variável.

Altera só uma vez, e a alteração ocorre em vários cantos.
Se tivesse feito isso de maneira local, teria que ir em cada função e alterar variável por variável...ia levar horas ou dias.

Mas com variável global constante, não. Altera só uma vez. E tudo muda.
Sacou a utilidade de variáveis globais e constantes?

Variável estática local

Quando declaramos uma variável dentro de uma função, ela é criada e reservada na memória do computador no início da função e é destruída, ao término da execução da função.

No exemplo de código abaixo, inicializamos a variável myVar com valor 1, imprimimos, incrementamos em uma unidade e terminamos a função.

#include <iostream>
using namespace std;

void test()
{
    int myVar=1;

    cout<<myVar<<endl;

    myVar++;
}

int main()
{
    test();
    test();

    return 0;
}

Chamamos a função test() duas vezes, e o que aparece na tela é sempre o mesmo: o valor 1.
Cada vez que a função roda, a variável é criada, inicializada e o valor 1 é exibido. Ela é incrementada, mas depois a função termina e a variável morre, simplesmente.

Dizemos então que as variáveis locais são não-persistentes. Ou seja, elas não 'persistem', elas são criadas e destruídas, junto com a função.

Existe uma maneira de fazer com que a variável seja persistente, ou seja, que ela seja criada de início e não seja destruída, ou seja, seu endereço e valor na memória se mantém. São as variáveis estáticas.

Para declarar uma variável como sendo estática, basta usarmos a keyword static antes da declaração:

• static int myVar;

Veja:

#include <iostream>
using namespace std;

void test()
{
    static int myVar=1;

    cout<<myVar<<endl;

    myVar++;
}

int main()
{
    test();
    test();
    test();
    test();

    return 0;
}

Pronto. Não importa quantas vezes você chama a função test(), a variável myVar que você vai usar é declarada e inicializada apenas uma vez. Quando a função terminar, ela ainda vai persistir e quando chamar novamente a função, ela já vai pegar o valor anterior da variável, pra imprimir e incrementar.

Assim como as variáveis globais, as estáticas locais sempre são inicializadas com valor 0, caso você não inicialize explicitamente. E caso inicialize, essa inicialização vai ocorrer somente uma vez, como você viu no exemplo de código anterior, ok?