Na linguagem C, é possível realizar operações aritméticas com ponteiros, como incremento e decrement...

Alternativa (B) - 40 e 30

Introdução

A questão aborda um conceito fundamental na linguagem C: a aritmética de ponteiros. Este recurso permite manipular endereços de memória de forma eficiente, especialmente ao interagir com arrays e outras estruturas de dados contíguas. Compreender como os ponteiros se comportam ao serem incrementados ou decrementados é crucial para o desenvolvimento de programas em C que exigem acesso direto e performático à memória.

Desenvolvimento

Na linguagem C, um ponteiro é uma variável que armazena um endereço de memória. A aritmética de ponteiros é uma operação em que se adiciona ou subtrai um valor inteiro de um ponteiro. No entanto, essa operação não move o ponteiro simplesmente pelo número de bytes do valor inteiro. Em vez disso, o compilador escala o valor inteiro pelo tamanho do tipo de dado para o qual o ponteiro aponta (sizeof(tipo)).

Para um ponteiro p do tipo T* (ponteiro para T), a expressão p + N move o ponteiro N posições à frente, o que equivale a um deslocamento de N * sizeof(T) bytes na memória. De maneira análoga, p - N o move N * sizeof(T) bytes para trás. Isso é particularmente útil para percorrer arrays, pois p + 1 sempre apontará para o próximo elemento do array, independentemente do tamanho do tipo de dado.

Vamos analisar o código fornecido:

1. int arr[] = {10, 20, 30, 40, 50};

   • Este código declara e inicializa um array de cinco inteiros. Em C, o nome de um array (sem um índice ou o operador &) geralmente se comporta como um ponteiro para o primeiro elemento do array.
   • Os elementos do array estão armazenados em posições de memória contíguas, conforme ilustrado abaixo:
     • arr[0] contém 10
     • arr[1] contém 20
     • arr[2] contém 30
     • arr[3] contém 40
     • arr[4] contém 50

2. int *p = arr;

   • Declara um ponteiro para um inteiro chamado p.
   • Inicializa p com o endereço base do array arr. Isso significa que p inicialmente aponta para o primeiro elemento do array, arr[0], cujo valor é 10.

3. p = p + 3;

   • Esta é a operação-chave de aritmética de ponteiros. Como p é um ponteiro para int, adicionar 3 a p faz com que ele avance 3 posições de int na memória.
   • Originalmente, p apontava para arr[0]. Após p = p + 3;, p passará a apontar para arr[0 + 3], que é arr[3].
   • O valor armazenado em arr[3] é 40.

Análise

Após a execução da linha p = p + 3;, o ponteiro p agora aponta para o elemento arr[3].

Vamos determinar os valores solicitados:

1. Valor apontado por *p:

   • O operador de desreferenciação * retorna o valor armazenado no endereço para o qual o ponteiro aponta.
   • Como p aponta para arr[3], *p é o valor de arr[3].
   • O valor de arr[3] é 40.

2. Valor apontado por *(p - 1):

   • A expressão p - 1 realiza uma operação de aritmética de ponteiros, movendo o ponteiro uma posição para trás em relação à sua posição atual.
   • Como p aponta para arr[3], p - 1 apontará para arr[3 - 1], que é arr[2].
   • *(p - 1) retorna o valor armazenado em arr[2].
   • O valor de arr[2] é 30.

Portanto, os valores apontados por *p e *(p - 1) são 40 e 30, respectivamente.

Vamos avaliar as alternativas com base nesta análise:

| Alternativa | Valor de *p | Valor de *(p - 1) | Análise | | :---------- | :------------ | :------------------ | :--------------------------------------------------------------------------------------------------------- | | (A) | 50 | 40 | Incorreta. p aponta para arr[3] (valor 40), não arr[4] (valor 50). | | (B) | 40 | 30 | Correta. p aponta para arr[3] (valor 40) e p - 1 aponta para arr[2] (valor 30). | | (C) | 30 | 20 | Incorreta. p aponta para arr[3] (valor 40), não arr[2] (valor 30). | | (D) | 40 | 20 | Incorreta. *(p - 1) aponta para arr[2] (valor 30), não para arr[1] (valor 20). | | (E) | 40 | 10 | Incorreta. *(p - 1) aponta para arr[2] (valor 30), não para arr[0] (valor 10). |

Conclusão

A aritmética de ponteiros em C permite uma navegação eficiente através de estruturas de dados contíguas, como arrays. Ao inicializar o ponteiro p com o endereço base do array arr e então executar p = p + 3;, p é movido para apontar para o quarto elemento do array (índice 3), que armazena o valor 40. Consequentemente, *p é 40. Para determinar o valor de *(p - 1), o ponteiro p é "virtualmente" movido uma posição para trás, apontando para o terceiro elemento do array (índice 2), cujo valor é 30.

Alternativa (B).