Ponteiros e Endereços de Memória em C++

Ponteiros e Endereços de Memória em C++

Um ponteiro é uma variável especial que armazena o endereço de memória de outra variável. Imagine a memória do seu computador como uma rua com casas numeradas — cada variável vive em uma casa, e um ponteiro sabe exatamente qual é o número dessa casa.

Por que usar ponteiros?

Ponteiros são fundamentais em C++ porque permitem:

• Acessar e modificar dados indiretamente
• Criar estruturas de dados dinâmicas (listas, árvores)
• Passar variáveis por referência para funções
• Alocar memória dinamicamente

Declarando um Ponteiro

Para declarar um ponteiro, usamos o símbolo * após o tipo de dado:

int x = 42;           // Uma variável inteira normal
int* ptr = &x;       // Um ponteiro que aponta para x
                     // O símbolo & significa "endereço de"

Leia assim: "ptr é um ponteiro para um inteiro que aponta para o endereço de x".

Obtendo o Endereço: O Operador &

O operador & (chamado de "operador de endereço") retorna o endereço de memória de uma variável:

int idade = 25;
int* ptr_idade = &idade;  // ptr_idade agora contém o endereço de idade

std::cout << &idade;      // Imprime algo como: 0x7fff5fbff8ac
std::cout << ptr_idade;   // Imprime o mesmo endereço

Acessando o Valor: O Operador *

O operador * (chamado de "desreferenciação") permite acessar o valor armazenado no endereço para o qual o ponteiro aponta:

int numero = 100;
int* ptr = №

std::cout << *ptr;        // Imprime 100 (o valor de numero)
*ptr = 200;               // Modifica numero para 200
std::cout << numero;      // Imprime 200

Observe que *ptr e numero referem-se ao mesmo valor na memória!

Entendendo a Memória

Vamos visualizar o que acontece na memória:

int x = 50;
int* p = &x;

// Na memória:
// Endereço: 0x1000  |  Variável: x    |  Valor: 50
// Endereço: 0x2000  |  Variável: p    |  Valor: 0x1000 (aponta para x)

A variável p não armazena 50 — ela armazena o endereço onde 50 está guardado!

Exemplo Prático Completo

#include <iostream>
using namespace std;

int main() {
    int temperatura = 25;
    int* ptr_temp = &temperatura;
    
    cout << "Valor: " << temperatura << endl;        // 25
    cout << "Endereço: " << &temperatura << endl;    // 0x...
    cout << "Ponteiro aponta para: " << ptr_temp << endl;  // 0x...
    cout << "Desreferenciando: " << *ptr_temp << endl;     // 25
    
    *ptr_temp = 30;  // Mudamos o valor através do ponteiro
    cout << "Novo valor: " << temperatura << endl;   // 30
    
    return 0;
}

Erros Comuns

Confundir * na declaração com * na desreferenciação:

int* ptr;      // Declaração: ptr é um ponteiro para int
*ptr = 5;      // Desreferenciação: acessa o valor apontado

Esquecer o & ao obter o endereço:

int x = 10;
int* ptr = x;   // ERRADO! Falta o &
int* ptr = &x;  // CORRETO!

Ponteiros e Funções

Ponteiros são especialmente úteis para passar variáveis por referência:

void aumentar(int* num) {
    *num = *num + 1;  // Modifica o valor original
}

int main() {
    int valor = 5;
    aumentar(&valor);  // Passa o endereço
    cout << valor;     // Imprime 6
}

Sem o ponteiro, a função receberia apenas uma cópia do valor, e a modificação não afetaria a variável original.