Pointers Questions and Answers

Q: What is the output of this C code? void main() { int k = 5; int *p = &k; int **m = &p; printf("%d%d%d\n", k, *p, **m); }

Correct answer: 5 5 5Each dereference removes one level. k is 5; p holds the address of k, so *p is 5; and m holds the address of p, so *m is p and **m is 5. All three names reach the same object by paths of different length, which is the whole point of the double pointer.

Q: What would be the equivalent pointer expression for referring the array element a[i][j][k][l]

Correct answer: *(*(*(*(a+i)+j)+k)+l)Each subscript is defined as a dereference of a sum: x[y] means *(x+y). Applying that rule four times, from the outside in, gives one dereference for every subscript.\[ a[i][j][k][l] \equiv *(*(*(*(a+i)+j)+k)+l) \]The options without the asterisks compute addresses but never read through them. Note that the pointer arithmetic is scaled by the size of the sub-array at each level, which is why the array's dimensions must be known to the compiler.

Q: What will be the output of the program If the integer is 4bytes long? #include <stdio.h> int main() { int ***r, **q, *p, i=8; p = &i; q = &p; r = &q; printf("%d, %d, %d\n", *p, **q, ***r); return 0; }

Correct answer: 8, 8, 8Each level of indirection is undone by one dereference. p points to i, q points to p, and r points to q.So *p reaches i directly; **q goes through p to i; and ***r goes through q and p to i. All three arrive at the same object and print 8. The distractors offer addresses, which would appear only if fewer dereferences were applied than there are levels of indirection.

Q: What is the output of this C code? int main() { int i = 10; int *p = &i; foo(&p); printf("%d ", *p); printf("%d ", *p); } void foo(int **const p) { int j = 11; *p = &j; printf("%d ", **p); }

Correct answer: 11 11 Undefined-valueint **const p makes the parameter itself constant, but *p is not, so *p = &j is legal and the caller’s pointer is redirected to j. The first two prints give 11, one inside foo and one immediately after it returns. By the third, j’s lifetime has ended and the value is indeterminate - compare with the previous question, where the const sits in the other position and the code will not compile at all.

Q: What is the output of this C code? void main() { int x = 0; int *ptr = &5; printf("%p\n", ptr); }

Correct answer: Compile time errorThe address-of operator requires an lvalue - something with a memory location - and the literal 5 has none. It is a value, not an object, so &5 is rejected outright. The same rule is why you cannot take the address of an arithmetic expression or of the result of a function call returning a value.

Q: What will be the output of the following C code? #include <stdio.h> void foo(int*); int main() { int i = 10, *p = &i; foo(p++); } void foo(int *p) { printf("%d\n", *p); }

Correct answer: 10Here the address is held in a pointer variable, so p++ is legal. It is a post-increment, so the value passed to foo is the original value of p - the address of i - and p is incremented afterwards.foo therefore dereferences a pointer to i and prints 10. The increment of p has no effect on the output, and since p is never used again the value it now holds - one past i - is harmless.

Q: Are the expression *ptr++ and ++*ptr are same?

Correct answer: FalseThey differ in what is incremented. *ptr++ parses as *(ptr++), because the postfix ++ binds more tightly than the unary *: it yields the value currently pointed to and advances the pointer.++*ptr parses as ++(*ptr): it dereferences first and increments the pointed-to value, leaving the pointer where it was. The first walks along an array reading it; the second modifies one element in place.

What is the output of the following 'C' language statements?

#include\(\lt\)stdio.h\(\gt\)
int main(){
int a=10,b=20,*p1=&a,*p2=&b;
printf("Before : **p1=%d **p2=%d",*p1,*p2);
*p1=*p1+*p2;
*p2=*p1-*p2;
*p1=*p1-*p2;
printf("\nAfter : **p1=%d **p2=%d",*p1,*p2);
return 0;
}

A.Before : **p1=10 **p2=20 / After : **p1=20 **p2=10
B.Before : **p1=20 **p2=10 / After : **p1=10 **p2=20
C.Before : p1=10 p2=20 / After : p1=20 p2=10
D.Before : *p1=10 *p2=20 / After : *p1=20 *p2=20

Exam Year(s)

DSSSB TGT - 2023,

Answer: A

The output is Before : **p1=10 **p2=20 and then After : **p1=20 **p2=10. The pointers p1 and p2 point to a and b, so the three statements swap the values without a temporary variable. \[ *p1 = 10 + 20 = 30 \] \[ *p2 = 30 - 20 = 10 \] \[ *p1 = 30 - 10 = 20 \] The strings '**p1=' and '**p2=' are printed as plain text. The second option reverses the values, the third drops the asterisks that the format string prints, and the fourth gives the wrong second value.

Discuss in Forum

What is the output of this C code?

void main()
{
int k = 5;
int *p = &k;
int **m = &p;
printf("%d%d%d\n", k, *p, **m);
}

A.5 5 5
B.5 5 junk value
C.5 junk value
D.Run time error

Answer: A

Correct answer: 5 5 5

Each dereference removes one level. k is 5; p holds the address of k, so *p is 5; and m holds the address of p, so *m is p and **m is 5. All three names reach the same object by paths of different length, which is the whole point of the double pointer.

Discuss in Forum

What would be the equivalent pointer expression for referring the array element a[i][j][k][l]

A.((((a+i)+j)+k)+l)
B.*(*(*(*(a+i)+j)+k)+l)
C.(((a+i)+j)+k+l)
D.((a+i)+j+k+l)

Answer: B

Correct answer: *(*(*(*(a+i)+j)+k)+l)

Each subscript is defined as a dereference of a sum: x[y] means *(x+y). Applying that rule four times, from the outside in, gives one dereference for every subscript.

\[ a[i][j][k][l] \equiv *(*(*(*(a+i)+j)+k)+l) \]

The options without the asterisks compute addresses but never read through them. Note that the pointer arithmetic is scaled by the size of the sub-array at each level, which is why the array's dimensions must be known to the compiler.

Discuss in Forum

What will be the output of the program If the integer is 4bytes long?

#include <stdio.h>

int main()
{
    int ***r, **q, *p, i=8;
    p = &i;
    q = &p;
    r = &q;
    printf("%d, %d, %d\n", *p, **q, ***r);
    return 0;
}

A.8, 8, 8
B.4000, 4002, 4004
C.4000, 4004, 4008
D.4000, 4008, 4016

Answer: A

Correct answer: 8, 8, 8

Each level of indirection is undone by one dereference. p points to i, q points to p, and r points to q.

So *p reaches i directly; **q goes through p to i; and ***r goes through q and p to i. All three arrive at the same object and print 8. The distractors offer addresses, which would appear only if fewer dereferences were applied than there are levels of indirection.

Discuss in Forum

What is the output of this C code?

int main()
{
int i = 10;
int *p = &i;
foo(&p);
printf("%d ", *p);
printf("%d ", *p);
}
void foo(int **const p)
{
int j = 11;
*p = &j;
printf("%d ", **p);
}

A.11 11 11
B.11 11 Undefined-value
C.Compile time error
D.Segmentation fault/code-crash

Answer: B

Correct answer: 11 11 Undefined-value

int **const p makes the parameter itself constant, but *p is not, so *p = &j is legal and the caller’s pointer is redirected to j. The first two prints give 11, one inside foo and one immediately after it returns. By the third, j’s lifetime has ended and the value is indeterminate - compare with the previous question, where the const sits in the other position and the code will not compile at all.

Discuss in Forum

Which of the statements is correct about the program?

#include <stdio.h>

int main()
{
    int i=10;
    int *j=&i;
    return 0;
}

A.j and i are pointers to an int
B.i is a pointer to an int and stores address of j
C.j is a pointer to an int and stores address of i
D.j is a pointer to a pointer to an int and stores address of i

Answer: C

Correct answer: j is a pointer to an int and stores address of i

The declaration int *j = &i; declares j as a pointer to int and initialises it with the address of i.

The asterisk belongs to the declarator, not to the type specifier - the declaration reads "*j is an int", hence j is a pointer to int. i is an ordinary int and no pointer at all, and j has one level of indirection, not two, which the number of asterisks makes plain.

Discuss in Forum

What is the output of this C code?

void main()
{
int x = 0;
int *ptr = &5;
printf("%p\n", ptr);
}

A.5
B.Address of 5
C.Nothing
D.Compile time error

Answer: D

Correct answer: Compile time error

The address-of operator requires an lvalue - something with a memory location - and the literal 5 has none. It is a value, not an object, so &5 is rejected outright. The same rule is why you cannot take the address of an arithmetic expression or of the result of a function call returning a value.

Discuss in Forum

What will be the output of the following C code?

#include <stdio.h>
    void foo(int*);
    int main()
    {
        int i = 10, *p = &i;
        foo(p++);
    }
    void foo(int *p)
    {
        printf("%d\n", *p);
    }

A.10
B.Some garbage value
C.Compile time error
D.Segmentation fault

Answer: A

Correct answer: 10

Here the address is held in a pointer variable, so p++ is legal. It is a post-increment, so the value passed to foo is the original value of p - the address of i - and p is incremented afterwards.

foo therefore dereferences a pointer to i and prints 10. The increment of p has no effect on the output, and since p is never used again the value it now holds - one past i - is harmless.

Discuss in Forum

Which of the statements is correct about the program?

#include <stdio.h>

int main()
{
    float a=3.14;
    char *j;
    j = (char*)&a;
    printf("%d\n", *j);
    return 0;
}

A.It prints ASCII value of the binary number present in the first byte of a float variable a.
B.It prints character equivalent of the binary number present in the first byte of a float variable a.
C.It will print 3
D.It will print a garbage value

Answer: A

Correct answer: It prints ASCII value of the binary number present in the first byte of a float variable a.

Casting &a to char * reinterprets the float's storage as bytes. Dereferencing reads the first byte of the IEEE representation of 3.14 - a piece of the mantissa, not the number 3 - and %d prints that byte's numeric value.

The output is therefore a small integer determined by the bit pattern and by the machine's endianness, with no arithmetic relationship to 3.14. The other options misdescribe it: %d prints a number rather than a character, and the value is deterministic rather than garbage.

Discuss in Forum

10.

Are the expression *ptr++ and ++*ptr are same?

A.True
B.False

Answer: B

Correct answer: False

They differ in what is incremented. *ptr++ parses as *(ptr++), because the postfix ++ binds more tightly than the unary *: it yields the value currently pointed to and advances the pointer.

++*ptr parses as ++(*ptr): it dereferences first and increments the pointed-to value, leaving the pointer where it was. The first walks along an array reading it; the second modifies one element in place.

Discuss in Forum

Loading…

Topics

Subject Categories

Tags: Pointers Questions and Answers || Pointers MCQ Questions and Answers || Pointers GK Questions and Answers || Pointers GK MCQ Questions || Pointers Multiple Choice Questions and Answers || Pointers GK || GK on Pointers || C Programming Questions and Answers || C Programming MCQ Questions and Answers || C Programming GK Questions and Answers || GK on C Programming

Pointers Questions and Answers

Topics

Subject Categories

About Us

Stay informed about all important Dates & Notifications