Obs: O espaço que dei entre os grupos de colchetes (“[ ] [ ]”) não deve existir. Fi-lo apenas porque o segundo grupo de colchetes sempre estava sendo exibido na linha de baixo aqui no post quando eu nao dava o espaço entre eles. Portanto, fiquem atentos a isso.
Eis a questão:
11. Considere a seguinte declaração em linguagem C:
int a[ ] [3] = {1,2,3,4,5,6,7,8,9,10,11,12};
A instrução printf ( “%d”, *(a[1]+2)) irá retornar o valor:
(A) 2
(B) 3
(C) 5
(D) 6
(E) 10
Esse é o tipo de questão que refina nossos conhecimentos ao extremo e é por isso que as provas antigas da EsFCEx, em minha humilde opinião, eram extremamente difíceis. Essa questão exige muito conhecimento sobre vetores e ponteiros em C. Se você não domina esses assuntos, de uma olhadinha no livro “Estrutura de Dados usando C”. Ele pode auxiliar muito.
Vou tentar explicar como resolvê-la.
Quando declaramos o vetor int a[ ] [3] = {1,2,3,4,5,6,7,8,9,10,11,12};
estamos dizendo que teremos um vetor bidimensional (linhas x colunas) de 3 colunas. Só temos definida a quantidade de colunas, pois a mesma é representada pelo segundo grupo de colchetes “[3]”.
Não sabemos quantas linhas esse vetor tem, pois os colchetes que representam as linhas está em branco “[ ]”. O compilador então vai determinar isso na inicialização do vetor.
Então entendo que ele vai dividir tudo isso entre as chaves “{1,2,3,4,5,6,7,8,9,10,11,12}” em grupos de 3 colunas, para determinar as linhas, assim teremos 4 linhas.
Em tese, essa inicialização seria a mesma coisa que declarar:
int a[4] [3] = {1,2,3,4,5,6,7,8,9,10,11,12};
ou
int a[4] [3] = {(1,2,3),(4,5,6),(7,8,9),(10,11,12)};
Beleza até aqui… bom, vamos ao comando print da questão:
printf (“%d”, *(a[1] + 2));
Esse “*” serve pra identificar o valor que há dentro de um campo sendo apontado.
Segundo os materiais que consultei, temos as seguintes deduções:
*(a) = a[ ] = a[0]
*(a + 1) = a[1]
*(a + 2) = a[2]
*(a + 3) = a[3]
darei um exemplo:
considere o vetor vet[4] = {200, 10, 5, 1500};
Assim:
vet[0] = 200
vet[1] = 10
vet[2] = 5
vet[3] = 1500
Até ai é beleza, o problema vem na interpretação abaixo.
De acordo com a notação de ponteiros temos que:
vet[0] = *(vet) = *(vet + 0) = 200
vet[1] = *(vet + 1) = 10
vet[2] = *(vet + 2) = 5
vet[3] = *(vet + 3) = 1500
Esse raciocínio é para um vetor unidimensional. Porém temos nessa questão um vetor bidimensional.
No caso do exercício da prova, cada linha tem 3 colunas certo?
Independente de o vetor ser uni, bi, tri ou multidimensional, ele sempre vai ser organizado sequencialmente na memória.
Se considerarmos uma organização sequencial desses números teríamos que na posição:
Explicação
0 temos o número 1, na 1 temos o número 2, na 2 temos o número 3 <fim da primeira linha>
3 temos o número 4, na 4 temos o número 5, na 5 temos o número 6 <fim da segunda linha>
e o raciocínio continua até o fim de quarta linha.
Então, se estamos tratando de um vetor bidimensional, quando dizemos a[1] estamos dizendo que na notação de ponteiros temos:
* ( * (a + 1) + 0 ) que quer dizer * ( * (a + <numero da linha>) + <numero da coluna> ) isso porque agora estamos lidando com 2 dimensões no vetor.
Se fossemos traduzir de um modo grosseiro isso tudo, já que todo o vetor, independente de uni ou multidimensional é organizado sequencialmente, poderíamos dizer que:
a[1] ou *(a + 1) é a posição 3 do vetor (ver explicação). Mas ainda não estamos considerando o número das colunas. Se quiséssemos acessar o segundo elemento da segunda linha teríamos que somar mais duas posições à posição 3. Assim teríamos a posição 5, que é igual a 6
Quando você diz para o compilador, num vetor bidimensional, vá para a[0], ele irá para a posição 0… vá para a[1], ele irá para a posição 3… quando disser vá para a[2], ele irá para a posição 6, vá para a[3], ele irá para a posição 9… colocando agora as colunas em jogo também, temos que quando dissermos vá para a[0] [0], ele irá para a posição 0… vá para a[0] [1], ele irá para a posição 1… a[0] [2], ele irá para a posição 2…
a[1] [0], ele irá para a posição 3… a[1] [1], ele irá para a posição 4… a[1] [2], ele irá para a posição 5… etc etc etc
tudo isso para te explicar aquilo que escrevi acima, que:
* ( * (a + <numero da linha>) + <numero da coluna> )
é o modo de se caminhar no vetor através de ponteiros, em vetores bidimensionais.
Ou seja:
a[0] [0] = * ( * (a + 0 ) + 0 )
a[2] [1] = * ( * (a + 2 ) + 1 )
a[1] [0] = * ( * (a + 1 ) + 0 )
etc…
é confuso pra caramba… pelo menos eu acho… mas espero que tenham entendido… porque eu demorei quase 1 dia pra entender, rs
Vamos à questão:
printf (“%d”, *(a[1] + 2));
a[1] = *(a + 1) então temos printf (“%d”, *(*(a + 1) + 2)); Exatamente o método de ir para linha e coluna em vetores bidimensionais através do valor dentro dos ponteiros.
*(a + 1) = linha 1 = 4,5,6 (se déssemos um printf nisso iríamos obter apenas o número 4)
*(*(a + 1) + 2) = linha 1 coluna 2
col 0 col 1 col2
linha 0 ——> 1 2 3
linha 1 ——> 4 5 6
linha 2 ——> 7 8 9
linha 3 ——> 10 11 12
Resposta D = 6
Abraços
