PUERTA | PUERTA 2006 | Pregunta 49

¿Cuál de las opciones dadas a continuación se imprimirá cuando se ejecute el siguiente programa?

#include <stdio.h>
struct test {
               int i;
               char *c;
}st[] = {5, "become", 4, "better", 6, "jungle", 8, "ancestor", 7, "brother"};
main ()
{ 
    struct test *p = st;
    p += 1;
    ++p -> c;
    printf("%s,", p++ -> c);
    printf("%c,", *++p -> c);
    printf("%d,", p[0].i);
    printf("%s \n", p -> c);
} 

(A) jungle, n, 8, nclastor
(B) etter, u, 6, ungle
(C) cetter, k, 6, jungle
(D) etter, u, 8, ncestor

Respuesta: (B)
Explicación:  

Requisito Básico – Conocimiento de Estructuras

struct test *p = st;

st es una array de estructuras en la que el número entero es la variable «i» de la estructura y la array de caracteres es la variable «c» de la estructura.

p es un puntero de tipo de prueba de estructura que apunta a la array de estructuras (primer elemento). p contiene la dirección base de la primera estructura en la primera array, es decir, {5, se convierte}.

p += 1;

Esta declaración incrementa p en uno, lo que significa que p ahora apunta a la siguiente estructura (porque p es un puntero de tipo prueba de estructura, por lo que al incrementarlo en uno saltará una estructura). p ahora apunta a {4, mejor}.

Antes de pasar a otras declaraciones, primero discutimos sobre los operadores y su precedencia .

“->” es un operador de estructura que obtiene el miembro de la estructura a la que se hace referencia. Tiene mayor prioridad que la operación de incremento/decremento (++, –) y desreferenciación (*).

Ahora una breve discusión sobre el operador post-incremento y pre-incremento.

El operador de incremento previo se usa para incrementar el valor de la variable antes de usarla en la expresión. En el Pre-Incremento, el valor primero se incrementa y luego se usa dentro de la expresión.

El operador de incremento posterior se usa para incrementar el valor de la variable tan pronto como después de ejecutar completamente la expresión en la que se usa el incremento posterior. En Post-Increment, el valor se usa primero en una expresión y luego se incrementa.

 ++p -> c; 

En esta declaración, el operador de estructura (mayor prioridad) primero hará que p apunte a la variable c dentro de la estructura. Ahora el puntero está dentro de la array de caracteres, ahora al incrementar el puntero en la array de caracteres ‘c’ saltará un carácter en la array de caracteres. Por lo tanto, la array de caracteres ahora comienza desde «e».

p->c mueve el puntero dentro de la estructura a la variable “c”.

printf("%s,", p++ -> c);

En esta declaración se utiliza un operador de incremento posterior. Primero se ejecutará la declaración y luego funcionará el operador. Actualmente, p apunta a la segunda estructura {4, mejor} y dentro de la estructura, la array de caracteres comienza desde e debido a la declaración anterior, por lo que p->c imprimirá la string «mejor» y luego el operador de incremento posterior incrementará la estructura y p ahora apuntará a la siguiente estructura.

printf("%c,", *++p -> c);

En esta declaración, p->c apunta a «jungla» (p apuntaba actualmente a la tercera estructura {6, jungla}) y luego el operador de preincremento, al igual que en la declaración de preincremento anterior, mueve un carácter y ahora el puntero apunta a «u ”, el operador de desreferenciación aquí imprime el valor en la dirección a la que apunta el puntero y, dado que el puntero apunta a «u», se imprime u.

printf("%d,", p[0].i);

En esta declaración, p[0] dará la dirección a la que apunta actualmente p, es decir, {6, jungle} y el operador de estructura (.) apuntará a la variable «i» de la estructura que imprime 6 como resultado.

printf("%s \n", p -> c);

Esta declaración imprime la string de caracteres de la estructura a la que apunta actualmente p y, dado que debido al incremento anterior de la array de caracteres, la array de caracteres comienza desde «u», por lo tanto, se imprime «ungle».

Esta explicación ha sido aportada por Parul Sharma.
Cuestionario de esta pregunta