Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.
Aprenda Compreendendo Ponteiros | Introdução a Ponteiros Inteligentes
C++ Smart Pointers
course content

Conteúdo do Curso

C++ Smart Pointers

C++ Smart Pointers

1. Introdução a Ponteiros Inteligentes
2. Ponteiros Únicos
3. Ponteiros Compartilhados
4. Ponteiros Fracos
5. Tópicos Avançados

book
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 &.

h

pointer

copy
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.

h

null_pointer

copy
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.

h

reassigning_pointers

copy
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.

h

pointer_arithmetic

copy
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!

question mark

O que um ponteiro armazena?

Select the correct answer

Tudo estava claro?

Como podemos melhorá-lo?

Obrigado pelo seu feedback!

Seção 1. Capítulo 1
Sentimos muito que algo saiu errado. O que aconteceu?
some-alt