Ponteiros em C++ – Prof. Felipe Túlio de Castro

Conteúdo da página

No cerne da Ciência da Computação reside o gerenciamento rigoroso dos recursos de hardware. Dentre as abstrações fundamentais fornecidas por linguagens de programação de sistemas como C e C++, os ponteiros destacam-se como o mecanismo primordial de interação direta com o subsistema de memória principal.

O domínio desse conceito permite ao desenvolvedor compreender a anatomia da arquitetura de Von Neumann, na qual dados e instruções coabitam o espaço de endereçamento da máquina (Tanenbaum; Austin, 2013). Em aplicações analíticas e científicas, a alocação e o acesso eficiente via ponteiros previnem cópias custosas na pilha de execução (call stack), minimizam a latência de processamento e garantem previsibilidade temporal.

Segundo Kernighan e Ritchie (1989, p. 83), “um ponteiro é uma variável que contém o endereço de outra variável”. Embora a premissa seja básica, suas ramificações afetam diretamente a localidade de referência espacial e temporal dos processadores modernos, influenciando o comportamento das memórias cache L1, L2 e L3. Conforme assevera Stroustrup (2013), a linguagem C++ foi concebida para fornecer abstrações de custo zero (zero-overhead principle), o que exige que o desenvolvedor tenha a capacidade de trabalhar próximo ao hardware quando eficiência for um requisito não funcional crítico.

O que é um ponteiro?

Em termos conceituais e arquiteturais, a memória principal de um computador pode ser modelada como uma sequência linear contígua de células (bytes), cada uma identificada por um índice numérico exclusivo denominado endereço de memória (Tanenbaum; Austin, 2013).

Um ponteiro é um tipo de dado primitivo cujo valor representa o endereço de memória de outro objeto. Em uma arquitetura x86-64 típica, um ponteiro ocupa exatamente 8 bytes (64 bits), independentemente do tipo de dado apontado — seja um char de 1 byte ou uma estrutura complexa de centenas de bytes. O tipo associado ao ponteiro (ex.: float*) informa ao compilador a granularidade da leitura/escrita e como interpretar a sequência de bits a partir daquele endereço base.

A manipulação de ponteiros fundamenta-se em dois operadores unários complementares:

Operador de Endereço (&): aplicado a uma variável de valor, obtém a sua localização física na memória virtual do processo.
Operador de Dereferenciamento ou Indireção (*): Aplicado a uma variável ponteiro, acessa e permite manipular diretamente o conteúdo armazenado no endereço contido naquele ponteiro.

Declaração de ponteiros

Um ponteiro é declarado indicando o tipo de dado para o qual ele aponta. Assim, um ponteiro para float deve apontar para o endereço de uma variável float.

Considere o cenário em que registramos o peso de uma pessoa em quilogramas utilizando o tipo de ponto flutuante de precisão simples float (ocupando 4 bytes de memória). Se peso é uma variável do tipo float, então &peso representa o endereço em que esse valor está armazenado.

float peso = 72.5f;
float* ponteiroPeso = &peso;

Nesse exemplo, ponteiroPeso armazena o endereço da variável peso. O tipo float* significa “ponteiro para float”. Isso é importante porque o compilador precisa saber quantos bytes deve considerar ao acessar ou deslocar esse ponteiro. Um ponteiro para float não é tratado da mesma forma que um ponteiro para int, char ou uma struct.

Agora, considere o código abaixo:

cout << peso << endl;
cout << ponteiroPeso << endl;

O valor impresso será 72.5na primeira linha e algo semelhante a 0x7ffd... na segunda linha. A segunda linha é uma representação do endereço de memória onde está armazenado o conteúdo da variável peso. O endereço pode mudar a cada execução do programa, pois o sistema operacional decide onde alocar os dados em memória.

Formalmente, isso separa duas ideias: o conteúdo da variável e o local onde esse conteúdo está armazenado. Essa separação é essencial para entender ponteiros. Quando uma variável comum é usada, o programador trabalha com o valor. Quando um ponteiro é usado, o programador trabalha com a localização desse valor.

Dereferenciamento

Dereferenciar um ponteiro significa acessar o valor armazenado no endereço para o qual ele aponta. Em C++, isso é feito com o operador *.

float peso = 72.5f;
float* ponteiroPeso = &peso;

cout << *ponteiroPeso;

Nesse caso, *ponteiroPeso acessa o conteúdo da variável peso. Se o programador fizer uma atribuição usando o dereferenciamento, o valor original da variável será alterado. Suponha o código abaixo:

*ponteiroPeso = 73.0f;

Depois dessa instrução, a variável peso passa a valer 73.0. Esse comportamento explica por que ponteiros são frequentemente usados para permitir que funções modifiquem dados externos a elas.

Ponteiros e arrays tradicionais

Arrays tradicionais em C++ têm uma relação direta com ponteiros. Quando o nome de um array é passado para uma função, ele se comporta como um ponteiro para o primeiro elemento. Assim, em um array pesos, a expressão pesos aponta para pesos[0].

float pesos[5] = {72.5f, 80.2f, 68.9f, 91.3f, 77.8f};

A expressão *(pesos + 0) acessa o primeiro elemento. A expressão *(pesos + 1) acessa o segundo. Essa operação é chamada aritmética de ponteiros. O deslocamento não ocorre byte a byte de forma manual pelo programador; o compilador considera o tamanho do tipo apontado. Como pesos é um array de float, pesos + 1 avança para o próximo float.

Essa lógica é relevante porque muitos algoritmos clássicos operam sobre coleções indexadas. Cormen et al. (2012) afirmam que algoritmos estão no coração da computação e enfatizam a eficiência como critério de projeto.

Ponteiros para structs

Construir uma struct é uma forma de se agrupar dados relacionados. Por enquanto, considere uma pessoa submetida a um teste físico. Os dados dela – representados por nome e peso – podem ser agrupados na struct PessoaTesteFisico.

struct PessoaTesteFisico {
    string nome;
    float peso;
};

Quando usamos um ponteiro para uma struct, podemos acessar seus campos com o operador ->.

PessoaTesteFisico participante = {"Ana", 72.5f};
PessoaTesteFisico* ponteiroPessoa = &participante;

cout << ponteiroPessoa->nome;
cout << ponteiroPessoa->peso;

A expressão ponteiroPessoa->peso equivale conceitualmente a (*ponteiroPessoa).peso. O operador -> apenas torna a escrita mais simples. Esse tipo de acesso é a base para estruturas encadeadas, nas quais cada registro possui dados e ponteiros para outros registros. Martins mostra esse princípio ao apresentar listas dinâmicas, nas quais variáveis como inicio, fim e aux são ponteiros para endereços de memória de registros (Martins, 2009).

Exemplo em C++

Para o exemplo deste artigo, considere um programa que armazena o nome e o peso de pessoas que estão sendo submetidas a um cenário de teste físico. O campo nome é uma string, enquanto o campo pesos é float.

#include <iostream>
#include <iomanip>
#include <string>

using namespace std;

const int QUANTIDADE_PESOS = 5;

struct PessoaTesteFisico {
    string nome;
    float peso;
};

void demonstrarEnderecoEDereferenciamento(float peso) {
    float* ponteiroPeso = &peso;

    cout << "1) Endereco e dereferenciamento\n";
    cout << "Valor original da variavel peso: " << peso << " kg\n";
    cout << "Endereco armazenado no ponteiro: " << ponteiroPeso << "\n";
    cout << "Valor acessado por dereferenciamento: " << *ponteiroPeso << " kg\n";

    *ponteiroPeso = *ponteiroPeso + 0.5f;

    cout << "Valor apos alterar usando o ponteiro: " << peso << " kg\n\n";
}

void imprimirPesosComPonteiro(const float* pesos, int tamanho) {
    cout << "2) Ponteiro percorrendo array tradicional\n";

    for (int i = 0; i < tamanho; i++) {
        cout << "Posicao " << i
             << " | endereco: " << (pesos + i)
             << " | valor: " << *(pesos + i) << " kg\n";
    }

    cout << "\n";
}

float calcularMedia(const float* pesos, int tamanho) {
    float soma = 0.0f;

    for (int i = 0; i < tamanho; i++) {
        soma = soma + *(pesos + i);
    }

    return soma / tamanho;
}

float encontrarMaiorPeso(const float* pesos, int tamanho) {
    float maior = *pesos;

    for (int i = 1; i < tamanho; i++) {
        if (*(pesos + i) > maior) {
            maior = *(pesos + i);
        }
    }

    return maior;
}

void aplicarAjusteNaBalanca(float* pesos, int tamanho, float ajuste) {
    for (int i = 0; i < tamanho; i++) {
        *(pesos + i) = *(pesos + i) + ajuste;
    }
}

void demonstrarStructComPonteiro(PessoaTesteFisico* pessoa) {
    cout << "4) Ponteiro para struct\n";
    cout << "Nome: " << pessoa->nome << "\n";
    cout << "Peso registrado: " << pessoa->peso << " kg\n";

    pessoa->peso = pessoa->peso - 0.2f;

    cout << "Peso apos correcao no registro: " << pessoa->peso << " kg\n\n";
}

void imprimirResumo(const float* pesos, int tamanho) {
    cout << "3) Resumo dos pesos do teste fisico\n";
    cout << fixed << setprecision(2);
    cout << "Media dos pesos: " << calcularMedia(pesos, tamanho) << " kg\n";
    cout << "Maior peso: " << encontrarMaiorPeso(pesos, tamanho) << " kg\n\n";
}

int main() {
    float pesoInicial = 82.4f;
    float pesos[QUANTIDADE_PESOS] = {72.5f, 80.2f, 68.9f, 91.3f, 77.8f};

    PessoaTesteFisico participante = {"Josefina", 72.5f};

    demonstrarEnderecoEDereferenciamento(pesoInicial);
    imprimirPesosComPonteiro(pesos, QUANTIDADE_PESOS);
    imprimirResumo(pesos, QUANTIDADE_PESOS);

    cout << "Aplicando ajuste de calibragem da balanca: +0.1 kg\n\n";

    aplicarAjusteNaBalanca(pesos, QUANTIDADE_PESOS, 0.1f);

    imprimirPesosComPonteiro(pesos, QUANTIDADE_PESOS);
    imprimirResumo(pesos, QUANTIDADE_PESOS);
    demonstrarStructComPonteiro(&participante);

    return 0;
}

Explicação do funcionamento do código

A função demonstrarEnderecoEDereferenciamento recebe um peso, cria um ponteiro para essa variável local e mostra três elementos: o valor armazenado, o endereço de memória e o valor acessado pelo ponteiro. Quando executa *ponteiroPeso = *ponteiroPeso + 0.5f, ela altera o conteúdo da variável apontada.

A função imprimirPesosComPonteiro recebe const float* pesos, isto é, um ponteiro para dados do tipo float que não devem ser modificados pela função. Dentro do laço, (pesos + i) representa o endereço do elemento na posição i, enquanto *(pesos + i) representa o valor armazenado nessa posição.

As funções calcularMedia e encontrarMaiorPeso mostram uso de ponteiros em algoritmos simples de análise de dados. Esse ponto dialoga com a noção de que programas são formulações concretas de algoritmos abstratos, baseados em representações específicas de dados (Ziviani, 2006).

A função aplicarAjusteNaBalanca recebe float* pesos, sem const, porque precisa modificar os valores do array. Esse detalhe é importante: quando a função apenas lê os dados, usa-se const float*; quando a função precisa alterar os dados, usa-se float*.

Por fim, a função demonstrarStructComPonteiro recebe o endereço de uma struct e acessa seus campos com ->. Esse padrão prepara o estudante para estruturas mais avançadas, como listas encadeadas, nas quais cada nó armazena dados e ponteiros para outros nós.

Cuidados comuns ao usar ponteiros

Ao utilizarmos ponteiros em nossos programas, precisamos ter uma boa dose de cautela. Antes de mais nada, o primeiro cuidado é nunca dereferenciar um ponteiro que não aponta para um endereço válido. Um ponteiro não inicializado pode conter lixo de memória, e acessá-lo pode causar comportamento indefinido.

O segundo cuidado é distinguir ponteiros constantes de ponteiros para dados constantes. Em funções que apenas leem arrays, como calcularMedia, o uso de const float* comunica ao compilador e ao leitor que os dados não serão alterados.

O terceiro cuidado é evitar acessar posições fora do limite do array. Em um array de tamanho 5, as posições válidas são 0, 1, 2, 3 e 4. Acessar pesos + 5 significa tentar ler uma posição fora do array, o que pode gerar erro lógico grave.

O quarto cuidado é lembrar que ponteiros aumentam o poder expressivo da linguagem, mas também aumentam a responsabilidade do programador. Conforme Stroustrup (2013), a linguagem C++ permite programação de alto desempenho e controle fino dos recursos computacionais, mas esse controle exige disciplina no uso de memória.

Conclusão

Dominar ponteiros é um passo importante para compreender a programação em C++ para além da sintaxe básica. Ponteiros conectam variáveis, arrays, structs, funções e memória. Sem esse domínio, você pode até escrever programas simples, mas terá dificuldade para compreender estruturas de dados dinâmicas, passagem eficiente de parâmetros, manipulação de arrays e implementação de listas, pilhas, filas e árvores.

Obrigado pela leitura e bons estudos!

Referências

CORMEN, Thomas H.; LEISERSON, Charles E.; RIVEST, Ronald L.; STEIN, Clifford. Algoritmos: teoria e prática. 3. ed. Rio de Janeiro: Elsevier, 2012.

KERNIGHAN, B. W.; RITCHIE, D. M. C: a linguagem de programação padrão ANSI. Tradução de Daniel Vieira. Rio de Janeiro: Campus, 1989.

MARTINS, Paulo Roberto. Algoritmos e estrutura de dados: análise e desenvolvimento de sistemas. São Paulo: Pearson Prentice Hall, 2009.

STROUSTRUP, Bjarne. The C++ Programming Language. 4. ed. Boston: Addison-Wesley, 2013.

TANENBAUM, A. S.; AUSTIN, T. Organização Estruturada de Computadores. 6. ed. São Paulo: Pearson Prentice Hall, 2013.

ZIVIANI, Nivio. Projeto de algoritmos: com implementações em Java e C++. 2. ed. São Paulo: Cengage Learning, 2006.