Variáveis e Tipos de Dados em C++: Guia Completo sobre int, double, char, string, bool

Variáveis em C++

Em C++, uma variável é um local de armazenamento nomeado que permite ao programador armazenar e manipular dados. Toda variável possui um tipo explícito que determina sua ocupação de memória, faixa de valores permitidos e as operações que podem ser realizadas sobre ela.

Este tutorial abrange:

• Variáveis em C++
• Tipos básicos de variáveis
• Regras de declaração
• Hierarquia de tipos de dados
• Identificadores e convenções de nomenclatura
• Qualificador const
• Regras de escopo
• Conversão de tipos implícita e explícita
• Variáveis register
• Comentários e sequências de escape

Tipos Básicos de Variáveis em C++

int – Números inteiros sem parte fracionária ou exponencial (ex.: 120, -90).

double – Números de ponto flutuante de precisão dupla (ex.: 11.22, 2.345).

char – Literais de caractere único entre aspas simples (ex.: 'a', 'm', 'F', 'P', '}').

float – Valores de ponto flutuante de precisão simples (ex.: 1.3, 2.6).

string – Sequência de caracteres entre aspas duplas (ex.: "Como vai você?").

bool – Armazena true ou false.

Regras para Declarar Variáveis em C++

• Nomes podem conter letras, dígitos e sublinhados.
• Não podem começar com dígito.
• Prática convencional favorece minúsculas; maiúsculas no início geralmente denotam constantes.
• Nomes não devem colidir com palavras-chave da linguagem (ex.: int).
• Começar com sublinhado é permitido, mas desencorajado devido a regras de identificadores reservados.

Tipos de Dados de Variáveis em C++

O C++ oferece um rico conjunto de tipos primitivos. O tipo void não tem valor e é tipicamente usado como tipo de retorno de função quando nada é retornado.

Tipos aritméticos dividem-se em duas categorias:

1. Tipos de ponto flutuante: float (≈32 bits), double (≈64 bits) e long double (≈96/128 bits dependendo da implementação).
2. Tipos integrais: inteiros, caracteres e bool. Tipos integrais podem ser signed ou unsigned.

Tipos signed representam valores negativos, zero e positivos. Por exemplo, um char signed de 8 bits varia de –127 a 127.

Tipos unsigned armazenam apenas valores não negativos. Um char unsigned de 8 bits varia de 0 a 255.

Nomes de Variáveis ou Identificadores

Identificadores podem conter letras, dígitos e sublinhados. O comprimento é ilimitado e diferenciam maiúsculas de minúsculas:

int guru99, gurU99, GuRu99, GURU99;

Palavras-chave reservadas não podem ser reutilizadas como identificadores. Adotar convenções claras de nomenclatura melhora a legibilidade: use minúsculas para variáveis, camelCase ou snake_case para nomes compostos, e capitalize nomes de classes.

Exemplos de Declaração e Definição

int a = 5;
int b;
char c = 'A';
int a, b;
a = b = 1000;
int a(5);
int b{5};

Qualificador const em C++

Use const quando um valor deve permanecer inalterado após a inicialização:

const int bufSize = 512; // tamanho do buffer de entrada

Uma variável const deve ser inicializada; caso contrário, o compilador emite erro.

const int i = get_size(); // OK: inicialização em tempo de execução
const int j = 42;         // OK: inicialização em tempo de compilação
const int k;              // erro: const não inicializada
int i = 42;
const int ci = i;         // OK: cópia de i

Escopo de Variáveis em C++

Escopo define onde um nome é visível. Variáveis são acessíveis a partir de seu ponto de declaração até o fim do bloco envolvente.

#include <iostream>
int main() {
    int sum = 0;
    for (int val = 1; val <= 10; ++val)
        sum += val;
    std::cout << "Soma de 1 a 10 inclusive é " << sum << std::endl;
    return 0;
}

• main tem escopo global.
• sum tem escopo de bloco dentro de main.
• val tem escopo local dentro do laço for.

Escopo Aninhado

#include <iostream>
using namespace std;
int reused = 42; // escopo global
int main() {
    int unique = 0; // escopo de bloco
    cout << reused << " " << unique << endl; // 42 0
    int reused = 0; // reuso local oculta o global
    cout << reused << " " << unique << endl; // 0 0
    cout << ::reused << " " << unique << endl; // 42 0
    return 0;
}

Conversão de Tipos de Variáveis

O C++ realiza conversões implícitas sob certas condições. Regras principais incluem:

• Não-bool para bool: 0 torna-se false; qualquer outro valor torna-se true.

  bool b = 42; // b é true

• bool para aritmético: true torna-se 1, false torna-se 0.

  bool b = true;
  int i = b; // i é 1

• Ponto flutuante para inteiro: trunca em direção a zero.

  int i = 3.14; // i é 3

• Inteiro para ponto flutuante: parte fracionária é perdida.

  int i = 3;
  double pi = i; // pi é 3.0

• Overflow de unsigned: valor faz wrap-around módulo a base.

  unsigned char c = -1; // 255 em chars de 8 bits

• Overflow de signed: comportamento indefinido.

Ao misturar inteiros signed e unsigned, valores signed negativos podem converter-se inesperadamente em grandes valores unsigned.

Variáveis Register

Use a palavra-chave register para sugerir que uma variável acessada frequentemente seja armazenada em um registrador da CPU. Compiladores modernos geralmente ignoram a dica, realizando suas próprias otimizações.

register int i;

Comentários

Comentários são ignorados pelo compilador e servem para documentar o código:

• Linha única – inicia com //.
• Múltiplas linhas – delimitados por /* ... */.

/* Isto é um comentário */
/* Comentários C++ também podem
   abranger múltiplas linhas */

Sequências de Escape

Sequências de escape representam caracteres não imprimíveis ou especiais:

Escape	Descrição
\n	Nova linha
\t	Tabulação horizontal
\\	Barra invertida
\b	Backspace
\r	Retorno de carro
\v	Tabulação vertical
\f	Avanço de página
\a	Alerta (beep)
\"	Aspas duplas
\'	Aspas simples
\?	Ponto de interrogação

cout << '\n'; // nova linha
cout << "\tguru99!\n"; // tab + texto + nova linha

Sequências generalizadas usam valores hexadecimais ou octais:

\7   // beep
\12  // nova linha
\40  // espaço
\x4D // 'M'

Resumo

• Variáveis fornecem armazenamento nomeado e são tipadas.
• Tipos primários: int, double, char, float, string, bool.
• Escopo define visibilidade; escopos aninhados podem sombrear nomes.
• Conversões implícitas e explícitas existem, mas devem ser usadas com cuidado.
• Dicas de register podem melhorar performance, mas são apenas sugestões.
• Comentários e sequências de escape auxiliam legibilidade e saída correta.