GATE IT 2006 | Question: 49

Question

Which one of the choices given below would be printed when the following program is executed ?

#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. $\text{jungle, n, 8, nclastor}$
• B. $\text{etter, u, 6, ungle}$
• C. $\text{cetter, k, 6, jungle}$
• D. $\text{etter, u, 8, ncestor}$

Comments

Legendary explanation ...thanks a lot

---

many people are confusing why increment by 1000 to 1008 why not 1004 ? 

because of   

struct test {
int i;
char *c;
}

 

 

---

Table for precedence of operators:

https://gateoverflow.in/?qa=blob&qa_blobid=14995026566324324186

Answer 1

code :

#include <stdio.h>

struct test {
    int i;
    char *c;
}st[] = {5, "become", 4, "better", 6, "jungle", 8, "ancestor", 7, "brother"};

int main () { 
    //printf("size = %d\n",sizeof(struct test) );
    struct test *p = st;
    p += 1;
    ++p->c; // ++(p->c)
    printf("%s,", p++->c); // (p++)->c 
    printf("%c,", *++p->c); // *(++(p->c))
    printf("%d,", p[0].i);
    printf("%s \n", p->c);
}

We will assume few things:

• Size of integer $4$ Bytes.
• Size of a pointer $4$ Bytes.

Neglecting any alignment issues with the storage of this structure we will have $8$ Bytes per structure. 

And one precedence rule we need to use:

---

Initial situation :

---

struct test *p = st;

---

p += 1;

We know that if ptr is a pointer then,  ptr + x = ptr + x*sizeof(*ptr);

---

++p->c;

---

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

---

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

---

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

---

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

Correct Answer: $B$

Comments

such a beautiful "art work" truly appreciated :) you have drawn all "array & pointer" questions with the diagram i a very beautiful way.....will helpful for the beginner in the understanding  pointer concept

---

best answer

---

This is till date, the best answer I've come across on GO.

---

superb .......

---

best answer on GO so far amazing work

---

best explanation for practicing at home ...hope no one will try this whole step wise step  at exam hall

---

there is another question of Same type please do the same explanation again....

---

In 2004 paper

---

in case of pre increment on p , ---> operator is given more priority  by applying brackets

in case of post increment on p , ----.> operator is given less priority  by applying brackets on p++       

 

please explain why ???/

---

He has given brackets jst fr understanding purpose....

---

Wat a presentation ... GO should start Best answer award ... U will be the 1st winner i guess ... (y)

---

grand salute ..#grt no one can explain btr than this

---

its just wooooow

---

awesome explanation

---

@Debashish Deka

guys like you , makes this community such a great place for preparation.

Thankyou sir.

---

brilliance...!!

---

Salute sir excellent explanation

---

@Debashish Deka sir 

How to differentiate ++p -> c  &  p++ -> c

If I take precedence concept then first dereferencing will be done as for p -> c  & then the pointer p should increase for either p++ or ++p. But why for pre-increment line the character pointer is increasing instead of p??

---

have you seen the precedence rule I have mentioned? Out of the two cases, you presented, which expression need precedence resolution?

---

I think both the expression need precedence resolution.without precednce resolution how can I proceed ???   -> having higher precedence than ++

---

@Debashish Deka 

ok sir let me clear my doubt.

At the line of ++p -> c  first -> operator will be evaluated i.e p->c = 200. upto this it's okay but after that when p++ is executed then why p->c is increasing instead of p. I mean now p should be p = 1016(pointing to next structure).

This is happening exactly like in the next line p++ -> c , where after p->c , p is incrementing rather than (p -> c)++.

From this solution it's look like

++p -> c = p->c ; (p->c)++ ;

p++ -> c = p->c ; p++;

How is this happening???

---

$++p\rightarrow c$ means $p=p+1$ then $p\rightarrow c$

$p++\rightarrow c$ means $p\rightarrow c$ then $p=p+1$ 

$++(*p)$ means value at that position gets increased

means this

#include <stdio.h>
 
int main(void) {
	 char ptr[ ]="C programming";
    printf(" %c \n",++*ptr); 
	return 0;
}
 

o/p="D"

---

@srestha mam, can we evaluate lower precedence operator before higher precedence operator.as ++ having lower precedence than [ ].

If ++p -> c means p=p+ 1 then p->c. Then in that case p would be 1016 & p->c would be from j and in the next line p->c would print jungle.

Isn't it ????

 

​​

 

---

yes, I was wrong

$++p\rightarrow c=++(p\rightarrow c)$

As $\rightarrow$ has greater precedence than $++$ So, that will be evaluated first.

In this question , when $p$ is incrementing, it increments as size of pointer. but when $p\rightarrow c$ incrementing, it incrementing as size of a character, i.e. $1$ B

---

@srestha man, I can understand the pointer increment.

You please tell me one thing, if ++p->c is treated as ++(p->c) then p++ -> c  should be treated as (p->c)++

Isn't it?????

but here these both are treated as differently in this solution.

See ++p->c is ++(p->c) and p++ -> c is p->c then p++

This is my confusion.

---

@MRINMOY_HALDER ,

p++->c

 see the operand from the left, (it is p first), how many operators are attached with p? Only 1, and that is, ++.

Apply it to p and continue.

Now please see the difference between (operator) operand (operator) case, p++->c does not fall into this category. 

---

@Debashish Deka

Sir, I can't understand,could u please explain me a little bit more??

---

$p++\rightarrow c$ is equal to $(p++)\rightarrow c$

here we are not comparing precedence between $\rightarrow$ and $++$

Because $p$ is not linked with $\rightarrow$

We calculate precedence same variable attached with atleast 2 operator

but here that is not the case

---

Thanks srestha mam 😊

---

@MRINMOY_HALDER     p++->c is equal to ((p++)->c) //since p is post increment p->c will be evaluated first but p will be incremented later.

in case of ++p->c it will be equal to (++(p->c))// inner bracket will be evaluated first and then the outer bracker.

it all about precedence and associativity.

hope it helps

---

Yeah

---

The most amazing thing about this explanation is that he made students understood the concept without even speaking a word.Explaining what you think is very tough using just writing and visual pictures.

---

Everything is perfect But I think,

P[0].i is same as (*(P+0)).i and  it's same as P->i here

---

Please someone clear my doubt here,

in the line ++p-> c;  just before print, here it will evaluated as ++(p->c) and P will point to first e of better, after evaluating this, Is this new address being store in P, and the value of P been changed to first e of better ? Or P still point to p[1]?

---

Awarded for the best answer :) 🏆

---

such a clear and detailed explanation, hats off to the dedication!

Answer 2

#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);
    

Prints value and  increments the pointer. Pointing ti the next structure

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

printf("%d,", p[0].i); //Prints the integer value associated with struct pointed by p

printf("%s \n", p -> c); //Prints the character string pointed by p

PS : Thank you @monanshi for the explanation

Comments

@ Puja Mishra 

It is incrementing the position of a character string. NO

++p->c does not increment p at all.

---

great explanation.......

---

thor It is incrementing to the next structure in the array as p is the pointer to struct test

Answer 3

Answer is B )

Run The code.

http://codepad.org/WmSREd4G

For extra inofrmation =>

++p -> c will become ++(p -> c)

p++ -> c will become (p++) -> c

 *++p -> c will become => *++(p->c)

Reference-> C Puzzle Book

Comments

in case of pre increment on p , ---> operator is given more priority  by applying brackets

in case of post increment on p , ----.> operator is given less priority  by applying brackets on p++       

 

please explain why ???/

---

-> is not given priority in post inc, () is there to show ++ is associated with p not with p->c

Answer 4

I am getting B.

 

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

Line 8 => Initially p is pointing to st, i.e, first element of st which is {5, "become"}
Line 9 => Now p is pointing to {4, "better"}
Line 10=> ++(p->c) since -> has higher precedence. So, p->c points to 'e' of 'better'
Line 11=> prints 'etter' and p now points to {6, "jungle"}
Line 12=> *++(p->c) since -> has higher precedence. prints 'u'
Line 13=> p->i, which is 6 so prints '6'
Line 14=> prints 'ungle' since p is pointing to 'u'.

So, output is "etter, u, 6, ungle" that is B.

Comments

@monanshi your explanation has errors. p is a pointer to structure test and it can only point to structures of the same type, so p will never point to 'e', rather p->c points to 'e' after ++p->c, same thing for line 14, when p->c points to u, not p.

---

++p points to one letter of word 'e' so how can p++ point directly to next element of structure?

---

p is a pointer to structure. So, why ++(p ->c) increments p by 11B. Why it doesn't increment the value of character.

---

Nice Explanation Monashi. But I have added few steps

Initially st => [{5, c0},{4,c1},{6,c2},{8,c3},{7,c4}]

Suppose address of variable c is where ci are:

c0 => "become"
c1 => "better"
c2 => "jungle"
c3 => "ancestor"
c4 => "brother"

Line 8 => Initially p is pointing to st, i.e, first element of st which is {5, c0} 
Line 9 => Now p is pointing to {4, c1} 
Line 10=> ++(p->c) since -> has higher precedence. [ Means: p->c= (p->c)+1 Therefore address of c1 is incremented by 1 and thus c1 => "etter"] 
Line 11=> prints 'etter' [because c1 => "etter" now ] and p now points to {6, "jungle"} 
Line 12=> *++(p->c) since -> has higher precedence. [ Means: ++(p->c) => (p->c= (p->c)+1) Therefore address of c2 is incremented by 1 and thus c2 => "ungle"  and * (++(p->c)) prints the character pointing to, i.e 'u' ] 
Line 13=> p->i, which is 6 so prints '6' 
Line 14=> prints 'ungle' [Because of modification in the string c2 at Line 12]

Post Execution st => [{5, "become"},{4,"etter"},{6,"ungle"},{8,"ancestor"},{7,"brother"}]