Carregando...
Carregando...
Carregando...
Ponteiros desempenham um papel crucial quando uma variável precisa ser acessada em diferentes partes de um programa. Nesse contexto, é comum encontrar diversos ponteiros distribuídos por várias seções do código, cada um apontando para a variável que contém os dados necessários. Uma vantagem significativa dessa abordagem é que, se esses dados forem alterados, não há preocupação, pois todos os ponteiros no programa estão direcionados para o endereço onde os dados atualizados residem. Essa flexibilidade oferecida pelos ponteiros é fundamental para garantir a eficiência e a consistência na manipulação de dados em diferentes partes do código.
Considerando o uso de ponteiros em estruturas de dados, analise o seguinte código em C:
#include <stdio.h>
int main() {
int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;
printf("%d\n", *ptr + 2);
printf("%d\n", *(ptr + 2));
printf("%d\n", ptr[2]);
printf("%d\n", *ptr++);
printf("%d\n", (*ptr)++);
return 0;
}
Diante da análise realizada, assinale a alternativa que apresenta a saída impressa ao executar este código.
Explique melhor esta questão
Abre o Tutor com o enunciado e as alternativas já no campo — você revisa e envia.
Esta questão foi verificada por um de nossos administradores.
Alternativa C - 3, 3, 3, 1, 2
A questão explora a aritmética de ponteiros e as regras de precedência de operadores na linguagem C, especificamente incrementos e desreferenciamento.
Dado int arr[5] = {1, 2, 3, 4, 5}; e int *ptr = arr; (onde ptr aponta para o valor 1):
printf("%d\n", *ptr + 2);: Pega o valor apontado (1) e soma 2. Resultado: 3.printf("%d\n", *(ptr + 2));: Move o ponteiro temporariamente duas posições à frente (arr[2]) e acessa o valor. Resultado: 3.printf("%d\n", ptr[2]);: Notação de array, equivalente a *(ptr + 2). Resultado: 3.printf("%d\n", *ptr++);: O operador ++ pós-fixado tem precedência, mas o valor é usado antes do incremento. Ele imprime *ptr (1) e depois move ptr para arr[1]. Resultado: 1.printf("%d\n", (*ptr)++);: Agora ptr aponta para arr[1] (valor 2). O parêntese força o acesso ao valor (2). O ++ pós-fixado usa o valor (2) para impressão e depois incrementa o valor na memória para 3. Resultado: 2.| Passo | Operação | Valor Impresso | Estado de ptr / Valor |
| :--- | :--- | :--- | :--- |
| 1 | *ptr + 2 | 3 | ptr aponta para arr[0] (1) |
| 2 | *(ptr + 2) | 3 | ptr aponta para arr[0] (1) |
| 3 | ptr[2] | 3 | ptr aponta para arr[0] (1) |
| 4 | *ptr++ | 1 | ptr passa a apontar para arr[1] (2) |
| 5 | (*ptr)++ | 2 | Valor em arr[1] vira 3 |
A sequência correta de saídas, seguindo as regras de pós-incremento e precedência, é 3, 3, 3, 1, 2.
Alternativa C.