Compreendendo Ponteiros

O que é um Ponteiro

Você pode pensar em ponteiros como coordenadas. Eles nos apontam para locais específicos na memória e nos permitem acessar dados armazenados nesses locais.

Quando você declara um ponteiro, você cria uma variável que contém o endereço de memória de outra variável. Você pode criar um ponteiro usando os operadores * e &.

pointer


              1234
            
int value = 42;

// `p_value` now holds the memory address of `value`
int* p_value = &value;

Ponteiros Nulos

Você pode usar palavras-chave especiais usadas para representar um ponteiro nulo null ou nullptr. Um ponteiro nulo não aponta para nenhum endereço de memória válido. É essencialmente um ponteiro sem alvo.

Você também pode inicializar o ponteiro inteiro para null (ou nullptr). Fazemos isso quando não queremos associar o ponteiro a um valor específico imediatamente.

null_pointer


              123
            
int* p_int = null; // `p_int` is initialized to be null

double* p_double = nullptr; // `p_double` is initialized to be null

Reatribuindo Ponteiros

Ponteiros podem ser reatribuídos para apontar para diferentes endereços de memória. No entanto, reatribuir um ponteiro sem o gerenciamento adequado pode levar a problemas como vazamentos de memória ou ponteiros pendentes.

reassigning_pointers


              12345
            
int x = 42; // Create an integer variable and assign a value to it
int y = 43; // Create another integer variable

int* p_int = &x; // Make the `p_int` variable point to the address of the integer variable `x`
p_int = &y; // Reassign the `p_int` variable to `y`

Aritmética de Ponteiros

A aritmética de ponteiros é um aspecto fascinante dos ponteiros. Permite que você percorra a memória incrementando ou decrementando o endereço mantido por um ponteiro.

Por exemplo, considere o seguinte código onde criamos um array de inteiros e, em seguida, definimos um ponteiro para armazenar o endereço do array. Como um array contém múltiplos elementos, um ponteiro, por padrão, armazena o endereço do primeiro elemento, que neste caso é o inteiro 1.

pointer_arithmetic


              1234567891011
            
// Defining an array of integers
int arr[5] = {1, 2, 3, 4, 5};

// The pointer holds the memory address of the first element in the array
int* p_int = arr; 

// Incrementing the pointer makes the pointer point to the second value
p_int = p_int + 1;

// Dereference the pointer to get the actual second value
int second_element = *p_int; // Equals to `2`

Para acessar o segundo elemento, incremente o ponteiro em 1 e, em seguida, desreferencie-o usando o operador (*). Desreferenciar retorna o valor armazenado no endereço de memória mantido pelo ponteiro (neste caso, o inteiro 2). Siga os comentários no código para entender cada passo!

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 1. Capítulo 1