Variáveis em C++: declaração, inicialização e escopo explicados

O que é uma variável

Uma variável é um trecho de memória com nome que contém um valor. Em C++, toda variável tem um tipo fixo - escolhido quando você a declara - e esse tipo nunca muda. É isso que torna C++ uma linguagem de tipagem estática: o compilador conhece o tipo de cada variável antes de o programa rodar e se recusa a compilar código que armazene um valor do tipo errado.

Uma declaração tem três partes: o tipo, o nome e (quase sempre) um valor inicial.

#include <iostream>
#include <string>
using namespace std;

int main() {
    int age = 30;
    string name = "Ada";
    bool isActive = true;

    cout << name << " is " << age << ", active: " << isActive << "\n";
    return 0;
}

Leia int age = 30; como "crie um int chamado age e coloque 30 nele". O ponto e vírgula encerra a instrução, exatamente como a página de comentários mostrou que toda instrução faz. Note que isActive foi impresso como 1: um bool aparece como 1/0 por padrão, algo sobre o qual a página de tipos de dados se baseia.

Inicialização vs. atribuição

As duas parecem semelhantes, mas são operações diferentes, e essa diferença é uma das ideias mais importantes desta página.

A inicialização dá à variável seu primeiro valor como parte da declaração. A atribuição muda o valor de uma variável que já existe.

#include <iostream>
using namespace std;

int main() {
    int score = 95;   // inicialização - primeiro valor, dado na declaração
    score = 100;      // atribuição - mudando uma variável existente
    score = score + 5;

    cout << score << "\n";
    return 0;
}

Você pode declarar sem inicializar e atribuir depois, mas tome cuidado:

#include <iostream>
using namespace std;

int main() {
    int score;     // declarada, mas neste momento contém lixo
    score = 95;    // agora tem um valor de verdade
    cout << score << "\n";
    return 0;
}

Isso funciona porque atribuímos score antes de lê-lo. A versão perigosa é lê-lo primeiro, o que veremos a seguir.

A armadilha da variável não inicializada

Esta é a armadilha clássica de C++ que não existe em muitas outras linguagens. Ler uma variável local que foi declarada mas nunca recebeu um valor é comportamento indefinido: a variável contém os bytes que por acaso estavam naquela memória.

int score;             // não inicializada
std::cout << score;    // comportamento indefinido - imprime lixo, ou "funciona", ou trava

O compilador construirá isso sem reclamar. Pode imprimir 0, pode imprimir 32766, e pode se comportar de forma diferente a cada execução ou em cada máquina - o que torna esses bugs terríveis de rastrear. Duas defesas:

• Sempre inicialize na declaração. int score = 0; não custa nada e elimina o problema por completo.
• Ative os avisos. Compilar com -Wall -Wextra faz o compilador apontar muitas leituras não inicializadas antes que elas te mordam.

Prefira a primeira opção para toda variável local: dê a ela um valor inicial sensato no exato momento em que a cria.

Estilos de inicialização: =, () e {}

C++ oferece algumas maneiras de escrever um valor inicial. Na maioria das vezes elas fazem a mesma coisa, mas a inicialização com chaves tem um recurso extra de segurança que vale a pena conhecer.

#include <iostream>
using namespace std;

int main() {
    int a = 5;     // inicialização por cópia
    int b(5);      // inicialização direta
    int c{5};      // inicialização com chaves (uniforme) - C++11 e posteriores

    cout << a << " " << b << " " << c << "\n";
    return 0;
}

O motivo para recorrer a {} é que ela rejeita conversões com estreitamento (narrowing): atribuições que perderiam dados silenciosamente. Com =, um valor fracionário é truncado sem aviso; com {}, o compilador te impede:

int x = 3.9;    // compila - x se torna silenciosamente 3 (o .9 é descartado)
int y{3.9};     // erro de compilação - o estreitamento de double para int não é permitido

Pegar isso em tempo de compilação é exatamente o que você quer. Um hábito moderno comum é usar {} por padrão para essa verificação extra, recorrendo a = apenas quando a inicialização por cópia se lê de forma mais natural.

Regras e convenções de nomes

C++ impõe algumas regras rígidas e, em cima delas, todos acrescentam convenções. As regras: um nome pode conter letras, dígitos e _; não pode começar com um dígito; não pode ser uma palavra reservada (como int ou return); e diferencia maiúsculas de minúsculas (age e Age são duas variáveis diferentes). Evite nomes que comecem com um sublinhado seguido de uma letra maiúscula, ou que contenham dois sublinhados seguidos: esses são reservados para a implementação.

As convenções que a maioria do código C++ segue:

• Variáveis usam snake_case ou camelCase - escolha uma e mantenha a consistência: item_count ou itemCount.
• Os nomes devem descrever o valor: count, não c; user_email, não x.

#include <iostream>
using namespace std;

int main() {
    int item_count = 3;
    double price_per_item = 4.50;
    double total_price = item_count * price_per_item;

    cout << "Total: " << total_price << "\n";
    return 0;
}

Nomes claros não são enfeite: são a forma como o seu eu do futuro lê o código. total_price = item_count * price_per_item se explica sozinho de um jeito que t = c * p nunca conseguirá.

Escopo de variáveis

Uma variável existe apenas dentro do bloco - as { ... } - onde é declarada, e é destruída na chave de fechamento. Isso é o seu escopo (scope). Uma variável declarada dentro de um laço ou de um bloco if é invisível fora dele:

#include <iostream>
using namespace std;

int main() {
    int total = 0;

    for (int i = 1; i <= 3; i++) {
        int square = i * i;   // 'square' vive apenas dentro do corpo deste laço
        total += square;
    }

    cout << "Total: " << total << "\n";
    // cout << square;   // erro - 'square' está fora de escopo aqui
    return 0;
}

Tanto i quanto square pertencem ao laço e desaparecem quando ele termina; total é declarado no bloco externo, então sobrevive. Um bloco interno também pode ofuscar (shadow) um nome de um bloco externo: uma nova variável com o mesmo nome esconde temporariamente a externa até que o bloco interno se feche, o que é uma fonte frequente de confusão, então evite reutilizar nomes entre escopos aninhados.

A lição prática: declare cada variável no menor bloco que precisar dela e inicialize-a ali. Um escopo restrito significa menos nomes competindo pela sua atenção e menos chances de ler um valor longe de onde ele foi definido.

Próximo: Tipos de dados

Toda variável desta página começou com um tipo - int, double, string, bool. A próxima página detalha os tipos de dados de C++: os tipos fundamentais e seus tamanhos, inteiros com e sem sinal, float vs. double, char, e como escolher o tipo certo para cada tarefa.