Pointers Questions and Answers

Q: What will be the output of the following C code? #include <stdio.h> 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 p itself const but leaves *p modifiable, so *p = &j is legal and main's pointer is redirected to j.The first two prints show 11. But j is local to foo, and its lifetime ends when foo returns, so the pointer left in main is dangling. The second print in main reads that dead stack slot, which may still hold 11 or may not - it is undefined behaviour, and the intervening call to printf is exactly the sort of thing that overwrites it.

Q: Comment on the following? const int *ptr;

Correct answer: You cannot change the value pointed by ptrThe const applies to what ptr points at, not to ptr itself, so *ptr = 5 is rejected while ptr = &other is allowed.Read such declarations from the identifier outwards, or apply the rule that const qualifies whatever lies to its left unless there is nothing there, in which case it qualifies what lies to its right. int * const ptr reverses the meaning - a constant pointer to a modifiable int - and const int * const ptr fixes both.

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

Correct answer: 2 97The parameter p inside foo is a local copy of the pointer, so p = &j redirects only that copy. It prints 2. Back in main the original pointer is untouched and still points at i, so the second print gives 97. C passes everything by value, pointers included - which is exactly why the next question passes the address of the pointer instead.

Q: What is the output of this C code? int main() { int i = 10; void *p = &i; printf("%f\n", *(float*)p); return 0; }

Correct answer: 0.000000The cast changes how the bytes are interpreted, not what they contain. The four bytes hold the integer 10, and read as an IEEE single-precision float that bit pattern is a denormal of about \( 1.4 \times 10^{-44} \) - which %f prints, to six places, as 0.000000. The program compiles because the cast is explicit; it is the meaning rather than the syntax that is wrong.

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

Correct answer: 0.000000foo expects a float * but is given an int *. The pointer types are incompatible, so a conforming compiler must diagnose this - but the code compiles with a warning on most implementations, and the resulting behaviour is what the question asks about.Inside foo, the four bytes holding the integer 10 are reinterpreted as a float. The bit pattern 0x0000000A read as an IEEE single is a denormal of the order of \( 10^{-44} \), which prints as 0.000000 at the default precision. The value is an accident of representation, not a conversion.

Q: What is the output of this C code? int *f(); int main() { int *p = f(); printf("%d\n", *p); } int *f() { int j = 10; return &j; }

Correct answer: Undefined behaviourj is an automatic variable whose lifetime ends when f returns, so the address returned is dangling and dereferencing it is undefined. It very often prints 10, because the stack frame has not yet been overwritten, but that is an accident rather than a guarantee - another call, a different optimisation level or a different compiler can produce anything at all. The preceding question shows the correct pattern, using malloc.

101.

What will be the output of the following C code?

#include <stdio.h>
    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 p itself const but leaves *p modifiable, so *p = &j is legal and main's pointer is redirected to j.

The first two prints show 11. But j is local to foo, and its lifetime ends when foo returns, so the pointer left in main is dangling. The second print in main reads that dead stack slot, which may still hold 11 or may not - it is undefined behaviour, and the intervening call to printf is exactly the sort of thing that overwrites it.

Discuss in Forum

102.

Comment on the following?
const int *ptr;

A.You cannot change the value pointed by ptr
B.You cannot change the pointer ptr itself
C.Both (a) and (b)
D.You can change the pointer as well as the value pointed by it

Answer: A

Correct answer: You cannot change the value pointed by ptr

The const applies to what ptr points at, not to ptr itself, so *ptr = 5 is rejected while ptr = &other is allowed.

Read such declarations from the identifier outwards, or apply the rule that const qualifies whatever lies to its left unless there is nothing there, in which case it qualifies what lies to its right. int * const ptr reverses the meaning - a constant pointer to a modifiable int - and const int * const ptr fixes both.

Discuss in Forum

103.

What is the output of this C code?

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

A.2 97
B.2 2
C.Compile time error
D.Segmentation fault/code crash

Answer: A

Correct answer: 2 97

The parameter p inside foo is a local copy of the pointer, so p = &j redirects only that copy. It prints 2. Back in main the original pointer is untouched and still points at i, so the second print gives 97. C passes everything by value, pointers included - which is exactly why the next question passes the address of the pointer instead.

Discuss in Forum

104.

What is the output of this C code?

int main()
{
int i = 10;
void *p = &i;
printf("%f\n", *(float*)p);
return 0;
}

A.Compile time error
B.Undefined behaviour
C.10
D.0.000000

Answer: D

Correct answer: 0.000000

The cast changes how the bytes are interpreted, not what they contain. The four bytes hold the integer 10, and read as an IEEE single-precision float that bit pattern is a denormal of about \( 1.4 \times 10^{-44} \) - which %f prints, to six places, as 0.000000. The program compiles because the cast is explicit; it is the meaning rather than the syntax that is wrong.

Discuss in Forum

105.

What will be the output of the following C code?

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

A.10.000000
B.0.000000
C.Compile time error
D.Undefined behaviour

Answer: B

Correct answer: 0.000000

foo expects a float * but is given an int *. The pointer types are incompatible, so a conforming compiler must diagnose this - but the code compiles with a warning on most implementations, and the resulting behaviour is what the question asks about.

Inside foo, the four bytes holding the integer 10 are reinterpreted as a float. The bit pattern 0x0000000A read as an IEEE single is a denormal of the order of \( 10^{-44} \), which prints as 0.000000 at the default precision. The value is an accident of representation, not a conversion.

Discuss in Forum

106.

Will the program compile?

#include <stdio.h>
int main()
{
    char str[5] = "IndiaBIX";
    return 0;
}

A.True
B.False

Answer: A

C doesn't do array bounds checking at compile time, hence this compiles.

But, the modern compilers like Turbo C++ detects this as 'Error: Too many initializers'.

GCC would give you a warning.

Discuss in Forum

107.

What is the output of this C code?

int *f();
int main()
{
int *p = f();
printf("%d\n", *p);
}
int *f()
{
int j = 10;
return &j;
}

A.10
B.Compile time error
C.Segmentation fault/runtime crash
D.Undefined behaviour

Answer: A

Correct answer: Undefined behaviour

j is an automatic variable whose lifetime ends when f returns, so the address returned is dangling and dereferencing it is undefined. It very often prints 10, because the stack frame has not yet been overwritten, but that is an accident rather than a guarantee - another call, a different optimisation level or a different compiler can produce anything at all. The preceding question shows the correct pattern, using malloc.

Discuss in Forum

Loading…

Topics

Other Subjects

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

Other Subjects

About Us

Stay informed about all important Dates & Notifications