Fundação Speedywagon

Como muitas outras linguagens, C++ tem ponteiros. Já sabes que referências e ponteiros são semelhantes, mas pensa neles como um nível mais próximo do funcionamento interno do teu computador. Os ponteiros são variáveis que guardam endereços de objetos. São usados para interagir diretamente com objetos, permitindo alocação dinâmica de memória e manipulação eficiente de dados em C++.

Se estás a começar com ponteiros, podem parecer um pouco misteriosos, mas depois de te habituares a eles, tornam-se bastante simples.

São uma parte crucial do C++, por isso dedica algum tempo a compreendê-los realmente. A versão mais básica neste conceito também é chamada de ponteiro simples ou ponteiro bruto. Com o C++ moderno também existem ponteiros inteligentes; o tipo básico não é nada inteligente e tens de tratar de todo o trabalho manualmente.

Antes de aprofundares os detalhes, vale a pena compreender a utilização dos ponteiros. Os ponteiros são uma forma de partilhar o endereço de um objeto com outras partes do nosso programa, o que é útil por duas razões principais:

1. Tal como as referências, os ponteiros evitam cópias e ajudam a reduzir a pegada de recursos do teu programa.
2. Ao contrário das referências, os ponteiros podem ser reatribuídos a objetos diferentes.
3. Os ponteiros também podem apontar para um valor nulo, para indicar que atualmente não apontam para nenhum objeto.

Sintaxe geral

Uma declaração de ponteiro em C++ envolve especificar o tipo de dados para o qual o ponteiro aponta, seguido de um asterisco (*) e do nome do ponteiro. Quando os ponteiros são declarados, não são inicializados automaticamente. Sem uma atribuição explícita, um ponteiro contém normalmente um valor indeterminado, muitas vezes designado por "endereço de lixo". Embora alguns compiladores possam inicializar ponteiros com nullptr, esse comportamento não é garantido em todos os compiladores, por isso é essencial não contar com isso. É boa prática inicializar explicitamente os ponteiros brutos e verificar se não são nulos antes de os utilizares, para evitares potenciais problemas.

int* ptr{nullptr}; // Declares a pointer and makes sure it is not invalid

Para atribuíres o endereço de uma variável a um ponteiro, usas o operador de endereço (&). A desreferenciação de um ponteiro é feita com o operador de indireção (*).

std::string opponent{"Solomon Lane"};
// 'ethan' points to the address of the string opponent
std::string* ethan{&opponent};
// Instead of ethan's, the opponent's name address is given to the passPort
std::string passportName{*ethan};

Atenção: a desreferenciação tem de ser feita explicitamente, ao passo que as referências funcionavam simplesmente como um alias.

Aritmética de ponteiros

A aritmética de ponteiros permite efetuar operações aritméticas com ponteiros, o que é particularmente útil quando trabalhas com arrays. Somar um número inteiro a um ponteiro faz com que aponte para um elemento diferente.

// Stargate Coordinate Code
int gateCode[] = {462, 753, 218, 611, 977};
// 'ptr' points to the first element of 'gateCode'
int* ptr{&gateCode[0]};
// Accesses the third Stargate address through pointer arithmetic
int dialedAddress{*(ptr + 2)};
// Chevron encoded! Dialing Stargate address:
openStarGate(dialedAddress);

Acesso a variáveis membro

Em C++, o operador -> é usado para aceder aos membros de um objeto através de um ponteiro para esse objeto. É uma forma abreviada que simplifica o acesso aos membros de objetos apontados por ponteiros. Por exemplo, se ptr for um ponteiro para um objeto com uma variável membro x, em vez de usares (*ptr).x, podes usar diretamente ptr->x. Este operador melhora a legibilidade do código e reduz a verbosidade quando trabalhas com ponteiros para objetos.

Eis um breve exemplo, com uma struct Superhero que tem uma variável membro superpower. A função main cria um ponteiro dianaPrince para um objeto Superhero (que representa a Mulher-Maravilha). O operador -> é usado para aceder à variável membro superpower, mostrando o icónico "Lasso of Truth" da Mulher-Maravilha.

struct Superhero {
    std::string superpower;
};
Superhero wonder_woman{};
Superhero* dianaPrince = &wonder_woman;
dianaPrince->superpower = "Lasso of Truth";
// Using the -> operator to access member variable superpower:
std::cout << "Wonder Woman, possesses the mighty " << dianaPrince->superpower;

Ponteiros vs. referências

Os ponteiros e as referências permitem ambos o acesso indireto a objetos, mas diferem nas suas capacidades e considerações de segurança. Os ponteiros oferecem a flexibilidade de alterar o objeto de destino e podem receber o valor nulo. No entanto, essa flexibilidade introduz riscos, como desreferenciar ponteiros nulos ou criar ponteiros pendentes. As referências, por outro lado, não podem ser nulas e ficam associadas a objetos válidos aquando da criação, evitando estes riscos. Dada a sua natureza mais segura, deve dar-se preferência às referências em vez dos ponteiros, a menos que as funcionalidades adicionais proporcionadas pelos ponteiros sejam necessárias.