Carregando...
Carregando...
Carregando...
Em um programa de C, um desenvolvedor precisa manipular um array de inteiros utilizando ponteiros para realizar operações específicas. O código a seguir é um exemplo simplificado onde são realizadas algumas dessas operações. Compreender como ponteiros interagem com arrays é crucial para operações eficientes de manipulação de dados.
Considere o seguinte trecho de código em C:
| | | --- | | #include <stdio.h> void manipulaArray(int *arr, int tamanho) { int *p = arr; for(int i = 0; i < tamanho; i++) { *p = *p + 1; p++; } } int main() { int array[] = {1, 2, 3, 4, 5}; int tamanho = 5; manipulaArray(array, tamanho); for(int i = 0; i < tamanho; i++) { printf("%d ", array[i]); } return 0; } |
Quais serão os valores impressos pelo programa após a execução do código?
Está correto o que se afirma em:
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 (D) - II, apenas.
A questão aborda um conceito fundamental em programação C: a manipulação de arrays utilizando ponteiros. A compreensão de como ponteiros interagem com arrays é essencial para um desenvolvedor C, pois permite operações eficientes de acesso e modificação de dados em memória, além de ser a base para muitas estruturas de dados e algoritmos. Este exemplo ilustra a alteração dos valores de um array através de um ponteiro que itera sobre seus elementos.
Em C, um array é uma coleção de elementos do mesmo tipo armazenados em posições de memória contíguas. O nome de um array, na maioria dos contextos, pode ser tratado como um ponteiro para o seu primeiro elemento. Um ponteiro é uma variável que armazena um endereço de memória.
No código fornecido:
int array[] = {1, 2, 3, 4, 5};: Declara e inicializa um array de inteiros. Na memória, esses valores estão lado a lado.void manipulaArray(int *arr, int tamanho): Esta função recebe um ponteiro para inteiro (int *arr) e o tamanho do array. Quando manipulaArray(array, tamanho); é chamada, o nome array "decai" para um ponteiro para o seu primeiro elemento (array[0]), e esse endereço é passado para arr. Isso significa que arr dentro da função aponta para o mesmo local de memória que o array em main.int *p = arr;: Dentro de manipulaArray, um novo ponteiro p é declarado e inicializado com o endereço que arr contém. Assim, p também aponta para o primeiro elemento do array original.for(int i = 0; i < tamanho; i++): Um loop itera tamanho vezes, ou seja, para cada elemento do array.*p = *p + 1;: Esta é a operação crucial. *p (o operador de desreferência) acessa o valor armazenado no endereço para o qual p aponta. A linha incrementa esse valor em 1. Como p aponta para o array original de main, essa operação altera diretamente os valores do array em main.p++;: O operador de incremento em um ponteiro (p++) move o ponteiro para o próximo local de memória do tipo de dados que ele aponta. Neste caso, p aponta para int, então p++ avança o ponteiro para o endereço do próximo inteiro no array. Isso permite que o loop processe sequencialmente cada elemento do array.printf em main: Após a função manipulaArray ser executada e retornar, o array original (array) em main terá sido modificado. O loop final em main simplesmente imprime os valores atuais do array.Vamos rastrear a execução do código passo a passo, focando nas modificações do array:
| Etapa | i | p aponta para array[índice] | Valor de *p antes | Operação *p = *p + 1; | array após modificação | p++ (próximo elemento) |
| :---- | :-- | :------------------------------- | :------------------ | :------------------------- | :-------------------------- | :------------------------- |
| Inicial | - | - | - | - | {1, 2, 3, 4, 5} | - |
| 1 | 0 | array[0] | 1 | *p = 1 + 1 = 2 | {2, 2, 3, 4, 5} | p aponta para array[1] |
| 2 | 1 | array[1] | 2 | *p = 2 + 1 = 3 | {2, 3, 3, 4, 5} | p aponta para array[2] |
| 3 | 2 | array[2] | 3 | *p = 3 + 1 = 4 | {2, 3, 4, 4, 5} | p aponta para array[3] |
| 4 | 3 | array[3] | 4 | *p = 4 + 1 = 5 | {2, 3, 4, 5, 5} | p aponta para array[4] |
| 5 | 4 | array[4] | 5 | *p = 5 + 1 = 6 | {2, 3, 4, 5, 6} | p aponta para fora do array |
Após a função manipulaArray ser concluída, o array em main terá os valores {2, 3, 4, 5, 6}. O loop for subsequente em main irá imprimir esses valores.
Analisando as alternativas:
1 2 3 4 5: Incorreto. Esta seria a saída se o array não fosse modificado.2 3 4 5 6: Correto. Corresponde exatamente ao resultado da nossa simulação.0 1 2 3 4: Incorreto. Estes são valores iniciais diferentes ou um tipo de indexação.1 1 1 1 1: Incorreto. Sugere uma modificação que não ocorre no código.2 2 2 2 2: Incorreto. Cada elemento é incrementado pelo seu próprio valor, não por um valor fixo.Portanto, a única afirmação correta é a de número 2.
A execução do programa em C demonstra a poderosa interação entre ponteiros e arrays. Ao passar um array para uma função como um ponteiro e manipular esse ponteiro através de desreferenciação (*p) e aritmética de ponteiros (p++), é possível alterar diretamente os elementos do array original. No exemplo dado, cada elemento do array array é incrementado em uma unidade, resultando na sequência de saída 2 3 4 5 6.
Alternativa (D).