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