Manipulando ponteiros: ponteiros duplos, aritmética e vetores

Vamos lá galera!

Essa é uma questão pra gente interpretar o código! Então vamos entende-lo linha por linha.

Pra começar, da linha 01 a 05 é apenas a estrutura básica do C++, então vamos nos concentrar no restante do código.

Na linha 06 temos três declarações: primeiro uma variável inteira inicializada com o , segundo um ponteiro , e terceiro é declarado um ponteiro duplo chamado

Na linha 07 fazemos o ponteiro apontar para o endereço de memória da variável .

E na linha 08 utilizamos o ponteiro duplo para apontar para o endereço de memória de do ponteiro .

Por fim, vamos pra linha 10: onde utilizamos o comando para imprimir o resultado de . E basta você lembrar que quando usamos em um ponteiro duplo nós acessamos o valor contido na variável .

Assim, concluímos que o resultado desse código é imprimir a expressão “Valor de pp: 100” na tela.

E aí pessoal. Vamos lá resolver essa questão. Esse é um exercício bem direto, então vamos começar sem demora.

Primeiro de tudo vamos declarar as duas variáveis inteiras, vamos chama-las de e .

Perceba o seguinte, estamos declarando e como variáveis distintas, então elas sempre terão endereços de memória diferentes!

Agora vamos criar um ponteiro para cada uma das variáveis. Um ponteiro que aponta pro endereço de , e um ponteiro que aponta para o endereço de .

Certo! Agora vamos usar o comando para pedir que o usuário insira o valor das variáveis e com o guardamos cada valor na variável adequada.

Agora vamos entrar no centro da questão: vamos comparar os endereços de memória.

Para comparar dois ponteiros não tem segredo, basta usar o operador de comparação adequado, que é o próprio “”. Então, vamos comparar os endereços de e de e imprimir o valor contido no maior endereço. Para isso vai ser necessário utilizar uma expressão .

Lembre-se, devido a forma como declaramos as variáveis e é impossível que elas tenham o mesmo local de memória, então não precisamos nos preocupar com esse caso.

O código fica da seguinte forma:

E assim finalizamos a questão.

E aí pessoal, tudo bem? Vamos para mais uma questão sobre manipulação de ponteiros.

Pra resolver essa questão a gente precisa ter em mente duas coisas: a relação entre ponteiros e vetores e também o funcionamento da aritmética de ponteiros.

Precisamos lembrar que um vetor pode ser tratado como um ponteiro! Quando utilizamos um vetor sem os colchetes nós temos um ponteiro para a primeira posição do vetor. Seguindo essa lógica, quando fazemos uma soma do tipo podemos tratar isso como uma aritmética de ponteiros.

Sobre a aritmética de ponteiros precisamos lembrar que: quando somamos um ponteiro com um inteiro, a soma é proporcional a quantidade de bytes do tipo do ponteiro. Então, no nosso caso, somar ao ponteiro é equivalente a somar no endereço de memória.

Certo, então agora vamos efetuar os nossos cálculos.

O endereço de memória de pode ser obtido simplesmente chamando o vetor sem os colchetes assim: . Porém, se a gente quiser obter este endereço de memória através de aritmética de ponteiros podemos expressar da seguinte maneira: .

De forma análoga, para obter o endereço de memória de podemos fazer . Porém, ao somar unidade ao ponteiro, nós adicionamos ao endereço de memória:

E podemos ampliar este raciocínio para todas as outras posições do vetor. Ao adicionar unidades ao ponteiro, é equivalente a adicionar ao endereço de memória

E por fim, adicionando unidades ao ponteiro, o resultado é adicionar no endereço de memória.

Vamos lá pessoal.

Basicamente, a questão quer que a gente analise a expressão da linha 10. Essa é uma expressão envolvendo ponteiros, ponteiros duplos e vetores. Então vamos tomar cuidado para não cometer nenhum erro.

Antes de começar, vamos dar uma revisada nas regras de precedência:

Note que os operadores de ponteiro e tem precedência bem alta. E vamos tomar cuidado para não confundir um operador de ponteiro com uma multiplicação.

Agora vamos pensar em pra onde cada ponteiro está apontando.

Sempre que a gente encontrar o vetor sem os colchetes podemos considera-lo como um ponteiro para .

Já é um ponteiro para a primeira posição do vetor. Ou seja, o ponteiro aponta para .

Por fim, o ponteiro é um ponteiro duplo que aponta para o ponteiro .

Com tudo estabelecido, vamos resolver a expressão. Pra começar vamos escrever a expressão e analisa-la.

Vamos olhar primeiro pras expressões dentro dos parêntesis destacados abaixo:

Tanto quanto são ponteiros para a primeira posição do vetor. Na expressão laranja o ponteiro é incrementado com o operador passa a apontar para a segunda posição do vetor, em seguida é somado , o resultado aponta para a quarta posição do vetor. A expressão é uma referência à . O operador acessa o valor contido neste endereço que é igual à

Na expressão em vermelho, é um ponteiro para a primeira posição do vetor. Ao adicionar somos enviados para a próxima posição. é uma referência a segunda posição do vetor. O operador acessa o valor contido neste endereço que é igual à

Por sua vez, é um ponteiro duplo que aponta para , que aponta para . Quando utilizamos dois operadores de desreferência em nós recebemos o valor contido em como resposta. Ou seja: , então a expressão em azul é:

Assim, a expressão é reduzida à:

Efetuando as somas temos:

Para garantir que nossa resposta está correta vamos executar o programa:

O que mostra que chegamos na resposta correta.

Vamos nessa, galerinha. Essa questão quer que a gente exercite a indexação de vetores através de ponteiros. Então vamos precisar criar um ponteiro, um vetor e, para efetuar o loop, vai ser necessário uma variável de iteração.

Então vamos começar criando um vetor chamado com elementos inteiros. Você pode iniciar esse vetor com qualquer valor, eu vou usar múltiplos de .

Em seguida vamos declarar um ponteiro chamado que aponta para . Lembre-se que para declarar o ponteiro de um vetor o operador de referência (&) é opcional

Para criar o nosso loop precisamos de uma variável inicializada com o valor 0.

Vamos criar um loop para o nosso vetor.

Para poder indexar um vetor vamos começar a contar a partir do de um em um até .

Agora vamos atualizar a nossa array. Para cada iteração precisamos acessar a posição , ou seja, quando acessaremos a posição , quando vamos acessar a posição e assim por diante. Para acessar o valor contido em cada endereço de memória vamos utilizar o operador de desreferenciação (). E para adicionar ao valor vamos usar o operador .

Em código fazemos:

Em seguida vamos utilizar o para imprimir o valor atualizado da posição:

E é isso, a questão está concluída. Até logo, pessoal.

E aí, pessoal!

Vamos começar a questão analisando o código do enunciado.

Na primeira linha são declaras duas variáveis inteiras e .

Em seguida são declarados dois ponteiros para inteiro e

E fazemos esses ponteiros apontarem para as variáveis:

Assim o conteúdo do ponteiro é o endereço de memória de

Agora vamos analisar a expressão: . Aqui temos uma comparação “o conteúdo armazenado em é igual ao endereço de memória de ”.

Lembre-se que o ponteiro armazena o endereço de , então a comparação é verdadeira!

No C++ quando uma comparação é verdadeira o resultado é que representa o valor lógico

1. 1

E aí, pessoal!

Vamos começar a questão analisando o código do enunciado.

Na primeira linha são declaras duas variáveis inteiras e .

Em seguida são declarados dois ponteiros para inteiro e

E fazemos esses ponteiros apontarem para as variáveis:

Assim o conteúdo do ponteiro é o endereço de memória de

A expressão que vamos analisar é Essa é uma expressão aritmética envolvendo ponteiros.

A maior dificuldade está na presença do símbolo asterisco várias vezes ao longo da expressão, em alguns momentos ele representa o operador de desreferência, e em outros momentos representa o operador de multiplicação.

A dica pra não confundir é lembrar que a precedência do operador de desreferência é maior do que a precedência do operador de multiplicação. Então, se o estiver ao lado de um ponteiro ele vai ser considerado como um operador de desreferência.

Vamos dar uma olhada nas regras de precedência.

Analisando a tabela de precedência, primeiro vamos calcular as operações de ponteiro, depois as operações aritméticas

Agora vamos analisar a expressão:

Aqui podemos ver duas operações de ponteiros:

Um ao lado um ponteiro retorna o valor contido no endereço apontado. O ponteiro aponta para , então . Já aponta para , então a operação é igual a :

E agora vamos resolver a multiplicação:

Agora temos essa divisão entre dois inteiros. Lembre-se que no C++ divisão entre dois inteiros ignora a parte decimal, então é igual a , e não ! Assim temos:

Logo o resultado final é:

E aí, galerinha!

Nessa questão vamos precisar criar uma array, receber os valores da array e imprimi-los. O detalhe é que também vamos imprimir os endereços de memória de cada posição da array.

Para acessar o endereço de memória de uma array, é só a gente usar o vetor sem os colchetes. Um vetor sem colchete funciona como endereço de memória para a primeira posição. E se a gente adicionar um, apontaremos para a segunda posição. Se adicionar dois, vamos apontar para a segunda posição, e assim por diante...

Mas antes, vamos começar com o cabeçalho do código.

A primeira coisa a fazer é a gente criar uma array de inteiros. Então dentro da vamos declarar o vetor com dimensão

Para preencher esse array vamos usar um loop que vai executar dez iterações, começando em 0 e indo até 10 de um em um.

Em cada rodada vamos pedir pro usuário inserir um valor, e armazenamos o valor inserido na posição do vetor.

Show de bola. Agora vamos pra parte mais importante da questão.

O que precisamos fazer é imprimir o índice do vetor, o endereço daquela posição, e o valor contido nessa posição. Então, pra deixar nosso programa bonitão, vamos imprimir um cabeçalho:

Beleza, agora vamos ao que interessa.

A gente precisa imprimir o índice, endereço e valor de várias posições de um vetor, então vamos usar um loop para realizar uma iteração sobre esse vetor.

Dentro do loop, primeiro vamos imprimir a posição .

Em seguida, vamos imprimir o endereço de memória. O endereço de memória da posição pode ser obtido usando .

E também vamos exibir o conteúdo do endereço . Para isso é só a gente usar o operador de desreferência , junto com os parêntesis: e obteremos o conteúdo armazenado no endereço.

E prontinho! Podemos terminar o programa.

E agora, vamos rodar e ver se funciona.

E deu tudo certo! Até mais!