🔒 Ponteiros e const · Segurança e Imutabilidade · C/C++

🔒 Ponteiros e const

"A combinação de ponteiros com o qualificador const permite controlar o que pode ser modificado: o valor apontado, o próprio ponteiro, ou ambos."

O qualificador const é uma ferramenta poderosa para garantir a integridade dos dados e comunicar intenções no código. Quando combinado com ponteiros, a posição do const determina exatamente o que é imutável. Dominar essa sintaxe é essencial para escrever código seguro e bem documentado.

📌 As Quatro Combinações Possíveis

Declaração	Ponteiro modificável?	Valor apontado modificável?
`int* p`	✅ Sim	✅ Sim
`const int* p`	✅ Sim	❌ Não
`int* const p`	❌ Não	✅ Sim
`const int* const p`	❌ Não	❌ Não

🔹 Ponteiro para Constante (const int* p)

O valor apontado não pode ser modificado através deste ponteiro, mas o ponteiro pode apontar para outro lugar.

int a = 10;
int b = 20;

const int* p = &a;   // Ponteiro para constante

// *p = 30;          // ERRO: não pode modificar o valor apontado

p = &b;                // OK: o ponteiro pode mudar
cout << *p << endl;   // 20

a = 100;                // OK: a variável original pode ser modificada diretamente

💡 Sintaxe equivalente: const int* p é o mesmo que int const* p. A posição de const em relação ao tipo base não importa — o que importa é que está antes do asterisco.

🔹 Ponteiro Constante (int* const p)

O ponteiro não pode ser modificado para apontar para outro endereço, mas o valor apontado pode ser alterado.

int a = 10;
int b = 20;

int* const p = &a;   // Ponteiro constante (deve ser inicializado!)

*p = 30;                // OK: pode modificar o valor apontado
cout << a << endl;      // 30

// p = &b;             // ERRO: o ponteiro não pode mudar
  

🔹 Ponteiro Constante para Constante (const int* const p)

Nada pode ser modificado: nem o ponteiro, nem o valor apontado através dele.

int a = 10;

const int* const p = &a;   // Ponteiro constante para constante

// *p = 30;           // ERRO: não pode modificar o valor
// p = &b;             // ERRO: não pode modificar o ponteiro

cout << *p << endl;      // 10 (apenas leitura)

📋 Tabela Resumo

Declaração	Lê-se	Ponteiro	Valor
`int* p`	Ponteiro para inteiro	🔓 Modificável	🔓 Modificável
`const int* p`	Ponteiro para inteiro constante	🔓 Modificável	🔒 Constante
`int* const p`	Ponteiro constante para inteiro	🔒 Constante	🔓 Modificável
`const int* const p`	Ponteiro constante para inteiro constante	🔒 Constante	🔒 Constante

📤 Ponteiros e const em Parâmetros de Funções

O uso de const em parâmetros de função que são ponteiros comunica claramente a intenção e previne modificações acidentais.

// A função se compromete a NÃO modificar o conteúdo do array
void imprimirArray(const int* arr, int tamanho) {
    for (int i = 0; i < tamanho; i++) {
        cout << arr[i] << " ";
        // arr[i] = 0;  // ERRO: arr é const
    }
}

// A função modifica o ponteiro, mas não o valor (útil para busca)
const int* encontrar(const int* arr, int tamanho, int valor) {
    for (int i = 0; i < tamanho; i++) {
        if (arr[i] == valor) return &arr[i];
    }
    return nullptr;
}
  

🔄 Conversões entre Ponteiros e const

Existem regras importantes sobre conversões entre ponteiros com e sem const.

int a = 10;
int* p1 = &a;
const int* p2 = p1;   // OK: adicionar const é seguro (conversão implícita)

const int b = 20;
const int* p3 = &b;
// int* p4 = p3;      // ERRO: remover const é perigoso (não permitido implicitamente)
int* p4 = const_cast<int*>(p3);   // OK, mas perigoso! (const_cast)
  

⚠️ Cuidado com const_cast! Remover const de um objeto que foi originalmente declarado como const e depois modificá-lo resulta em comportamento indefinido. Use const_cast apenas quando tiver certeza de que o objeto original não é constante, como em APIs legadas que não usam const corretamente.

🧵 const e Strings Literais

Strings literais são armazenadas em área de memória somente leitura. O tipo correto para apontar para elas é const char*.

// Correto (recomendado)
const char* msg = "Olá, mundo!";

// Obsoleto, mas ainda compila por compatibilidade (evitar!)
char* oldStyle = "Olá, mundo!";   // Perigoso: tentar modificar causa crash

// oldStyle[0] = 'X';   // CRASH! (tentativa de escrever em memória somente leitura)
  

📊 Quando Usar Cada Combinação

Declaração	Quando Usar
`const int* p`	Funções que apenas leem dados (imprimir, buscar, comparar).
`int* const p`	Ponteiros que representam recursos fixos (ex.: buffer de hardware).
`const int* const p`	Constantes globais que apontam para dados imutáveis (ex.: tabelas de lookup).

💡 Boas Práticas

✅ Use const sempre que possível — ele documenta intenções e previne erros.
✅ Em parâmetros de função, prefira const int* se a função não precisa modificar os dados.
✅ Para strings literais, sempre use const char*.
✅ Evite const_cast a menos que seja absolutamente necessário para interoperar com código legado.
✅ Lembre-se: const é uma promessa — não a quebre sem um bom motivo.

🔗 Conclusão

A combinação de ponteiros com const é uma ferramenta essencial para escrever código C/C++ seguro e auto-documentado. Saber distinguir entre const int*, int* const e const int* const permite controlar precisamente o que pode ser modificado. Use const generosamente — seu "eu do futuro" (e seus colegas) agradecerão.

⏭️ Próximo: Funções...