Ponteiros em

Sobre Ponteiros

Tal como muitas outras linguagens, o C++ tem ponteiros. Já sabes que as referências e os ponteiros são semelhantes, mas pensa neles como estando 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 a alocação dinâmica de memória e uma manipulação eficiente de dados em C++.

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

São uma parte fundamental do C++, por isso dedica algum tempo a compreendê-los mesmo bem. A versão mais básica apresentada neste conceito também é chamada de dumb pointer ou raw pointer. Com o C++ moderno existem também os smart pointers; o tipo básico não é nada inteligente e tens de fazer todo o trabalho manualmente.

Antes de entrares nos detalhes, vale a pena perceber para que servem os 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 grandes razões:

1. Tal como as referências, os ponteiros evitam cópias e ajudam a reduzir o consumo 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, de momento, não apontam para nenhum objeto.

Sintaxe geral

Uma declaração de ponteiro em C++ implica 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 guarda habitualmente um valor indeterminado, muitas vezes designado por «endereço de lixo». Embora alguns compiladores possam inicializar os ponteiros a nullptr, esse comportamento não é garantido em todos os compiladores, por isso é essencial não contar com ele. A boa prática é inicializar explicitamente os raw pointers e verificar se não são nulos antes de os utilizares, para evitar potenciais problemas.

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

Para atribuir o endereço de uma variável a um ponteiro, usas o operador de endereço (&). A derreferenciação de um ponteiro faz-se 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 derreferenciação tem de ser feita explicitamente, enquanto as referências funcionavam simplesmente como um alias.

Aritmética de ponteiros

A aritmética de ponteiros permite-te efetuar operações aritméticas sobre ponteiros, o que é especialmente útil quando trabalhas com arrays. Somar um número inteiro a um ponteiro faz com que este 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 exemplo breve, 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 «Laço da Verdade» 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;

// Memory cleanup:
delete dianaPrince;

Ponteiros vs. referências

Tanto os ponteiros como as referências permitem o acesso indireto a objetos, mas diferem nas suas capacidades e nas considerações de segurança. Os ponteiros oferecem a flexibilidade de mudar o objeto para o qual apontam e podem receber o valor nulo. No entanto, essa flexibilidade introduz riscos, como derreferenciar ponteiros nulos ou criar ponteiros pendentes. As referências, por outro lado, não podem ser nulas e ficam ligadas a objetos válidos no momento da criação, o que evita esses riscos. Dada a sua natureza mais segura, deves preferir as referências aos ponteiros, a menos que as funcionalidades adicionais que os ponteiros oferecem sejam necessárias.

// There is a dark mark bearer, but who is it?
std::string* darkMarkBearer{nullptr};
// It is Bellatrix!
darkMarkBearer = new std::string{"Bellatrix Lestrange"};
// She has been defeated
delete darkMarkBearer;
// Reset pointer to null, symbolizing there is no more darkMarkBearer at the moment
darkMarkBearer = nullptr;