Pointers Questions and Answers

Q: What will be the output of the program ? #include <stdio.h> int main() { char *p; p="hello"; printf("%s\n", *&*&p); return 0; }

Correct answer: helloThe operators * and & are inverses, so each adjacent pair cancels. Reading *&*&p from the right: &p gives the address of p, * takes us back to p, & takes the address again, and the final * returns to p.The whole expression is therefore just p, and printf prints hello. Any even number of such pairs behaves the same way; the exercise exists to make the inverse relationship explicit.

Q: In which header file is the NULL macro defined?

Correct answer: stdio.h and stddef.hNULL is defined in several headers, among them stdio.h and stddef.h, and also stdlib.h, string.h, time.h and others.The duplication is deliberate. A programmer using any of those libraries is likely to need NULL, and the standard permits a macro to be defined identically in more than one header, so each defines it rather than forcing an extra include. stddef.h is the canonical home, holding it alongside size_t and ptrdiff_t.

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

Correct answer: 0.000000The four bytes holding the integer 10 are read as an IEEE single-precision float, and that bit pattern is a denormal of about \( 1.4 \times 10^{-44} \), which %f prints as 0.000000. The pointer types are incompatible, so a conforming compiler must issue a diagnostic; older compilers treat it as a warning and produce this output, which is what the question is asking for.

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

Correct answer: 0xbfd605e8 0xbfd605ecPointer arithmetic is in units of the pointed-to type, so incrementing an int * advances the address by sizeof(int), four bytes on a typical implementation. The second address is therefore four higher than the first, which the option with the last digit changing from 8 to c reflects. The particular addresses vary from run to run; the difference of four does not.

Q: What will be the output of the following C code? #include <stdio.h> 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 pointer is passed by value, so foo receives a copy. Assigning p = &j inside foo changes only that copy, and the print there shows 2.Back in main, the original p still points to i, so the second print shows 97. This is the fundamental point about pointer arguments: passing a pointer lets a function modify what it points to, but not the caller's pointer itself. Changing the caller's pointer requires a pointer to pointer.

Q: What will be the output of the program ? #include <stdio.h> power(int**); int main() { int a=5, *aa; /* Address of 'a' is 1000 */ aa = &a; a = power(&aa); printf("%d\n", a); return 0; } power(int **ptr) { int b; b = **ptr***ptr; return (b); }

Correct answer: 25The expression b = **ptr***ptr; tokenises as **ptr * **ptr - the lexer taking the longest valid token at each point, so the run of asterisks splits into two dereferences, a multiplication, and two more dereferences.ptr is a pointer to aa, which points to a, so **ptr is 5 and the product is 25. The code relies on the old implicit int return type, which was removed in C99, so it would not compile cleanly under a modern standard.

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

Correct answer: Compile time errorRead the declaration int *const *p from the inside out: p is a pointer to a const pointer to int. So *p is const-qualified.The statement *p = &j attempts to assign to that const-qualified object, which the compiler rejects. Compare int **const p, where the const applies to p itself and *p remains modifiable - the position of the qualifier relative to the asterisks decides which level is protected.

Q: Which is an indirection operator among the following?

Correct answer: *The unary * is the indirection or dereference operator: applied to a pointer it yields the object addressed.& is its inverse, the address-of operator, producing a pointer from an object. The other two select members - . from a structure and -> from a pointer to one - and -> is in fact indirection and selection combined, p->m being shorthand for (*p).m.

Q: What will be the output of the program ? #include <stdio.h> int main() { char *str; str = "%d\n"; str++; str++; printf(str-2, 300); return 0; }

Correct answer: 300str initially points at the format "%d\n". Two increments advance it two characters, and str-2 then brings it back to where it started.So printf receives the original format string and prints 300 followed by a newline. The exercise is about pointer arithmetic being exactly reversible: advancing and retreating by the same amount returns the identical address, and the intervening increments leave no trace.

Q: What substitution should be made to //-Ref such that ptr1 points to variable C? int main() { int a = 1, b = 2, c = 3; int *ptr1 = &a; int **sptr = &ptr1; //-Ref }

Correct answer: *sptr = &c;*sptr is another name for ptr1, so assigning the address of c to it makes ptr1 point at c. The alternative **sptr = &c; would assign a pointer to the int that ptr1 currently points at, and *ptr1 = &c; does the same thing - both are type errors and both write to a rather than redirecting the pointer.

51.

What will be the output of the program ?

#include <stdio.h>

int main()
{
    char *p;
    p="hello";
    printf("%s\n", *&*&p);
    return 0;
}

A.llo
B.hello
C.ello
D.h

Answer: B

Correct answer: hello

The operators * and & are inverses, so each adjacent pair cancels. Reading *&*&p from the right: &p gives the address of p, * takes us back to p, & takes the address again, and the final * returns to p.

The whole expression is therefore just p, and printf prints hello. Any even number of such pairs behaves the same way; the exercise exists to make the inverse relationship explicit.

Discuss in Forum

52.

In which header file is the NULL macro defined?

A.stdio.h
B.stddef.h
C.stdio.h and stddef.h
D.math.h

Answer: C

Correct answer: stdio.h and stddef.h

NULL is defined in several headers, among them stdio.h and stddef.h, and also stdlib.h, string.h, time.h and others.

The duplication is deliberate. A programmer using any of those libraries is likely to need NULL, and the standard permits a macro to be defined identically in more than one header, so each defines it rather than forcing an extra include. stddef.h is the canonical home, holding it alongside size_t and ptrdiff_t.

Discuss in Forum

53.

What is the output of this C code?

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

The four bytes holding the integer 10 are read as an IEEE single-precision float, and that bit pattern is a denormal of about \( 1.4 \times 10^{-44} \), which %f prints as 0.000000. The pointer types are incompatible, so a conforming compiler must issue a diagnostic; older compilers treat it as a warning and produce this output, which is what the question is asking for.

Discuss in Forum

54.

What is the output of this C code?

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

A.0xbfd605e8 0xbfd605ec
B.0xbfd605e8 0cbfd60520
C.0xbfd605e8 0xbfd605e9
D.Run time error

Answer: A

Correct answer: 0xbfd605e8 0xbfd605ec

Pointer arithmetic is in units of the pointed-to type, so incrementing an int * advances the address by sizeof(int), four bytes on a typical implementation. The second address is therefore four higher than the first, which the option with the last digit changing from 8 to c reflects. The particular addresses vary from run to run; the difference of four does not.

Discuss in Forum

55.

What will be the output of the following C code?

#include <stdio.h>
    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 pointer is passed by value, so foo receives a copy. Assigning p = &j inside foo changes only that copy, and the print there shows 2.

Back in main, the original p still points to i, so the second print shows 97. This is the fundamental point about pointer arguments: passing a pointer lets a function modify what it points to, but not the caller's pointer itself. Changing the caller's pointer requires a pointer to pointer.

Discuss in Forum

56.

What will be the output of the program ?

#include <stdio.h>
power(int**);
int main()
{
    int a=5, *aa; /* Address of 'a' is 1000 */
    aa = &a;
    a = power(&aa);
    printf("%d\n", a);
    return 0;
}
power(int **ptr)
{
    int b;
    b = **ptr***ptr;
    return (b);
}

A.5
B.25
C.125
D.Garbage value

Answer: B

Correct answer: 25

The expression b = **ptr***ptr; tokenises as **ptr * **ptr - the lexer taking the longest valid token at each point, so the run of asterisks splits into two dereferences, a multiplication, and two more dereferences.

ptr is a pointer to aa, which points to a, so **ptr is 5 and the product is 25. The code relies on the old implicit int return type, which was removed in C99, so it would not compile cleanly under a modern standard.

Discuss in Forum

57.

What will be the output of the following C code?

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

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

Answer: A

Correct answer: Compile time error

Read the declaration int *const *p from the inside out: p is a pointer to a const pointer to int. So *p is const-qualified.

The statement *p = &j attempts to assign to that const-qualified object, which the compiler rejects. Compare int **const p, where the const applies to p itself and *p remains modifiable - the position of the qualifier relative to the asterisks decides which level is protected.

Discuss in Forum

58.

Which is an indirection operator among the following?

A.&
B.*
C.->
D..

Answer: B

Correct answer: *

The unary * is the indirection or dereference operator: applied to a pointer it yields the object addressed.

& is its inverse, the address-of operator, producing a pointer from an object. The other two select members - . from a structure and -> from a pointer to one - and -> is in fact indirection and selection combined, p->m being shorthand for (*p).m.

Discuss in Forum

59.

What will be the output of the program ?

#include <stdio.h>

int main()
{
    char *str;
    str = "%d\n";
    str++;
    str++;
    printf(str-2, 300);
    return 0;
}

A.No output
B.30
C.3
D.300

Answer: D

Correct answer: 300

str initially points at the format "%d\n". Two increments advance it two characters, and str-2 then brings it back to where it started.

So printf receives the original format string and prints 300 followed by a newline. The exercise is about pointer arithmetic being exactly reversible: advancing and retreating by the same amount returns the identical address, and the intervening increments leave no trace.

Discuss in Forum

60.

What substitution should be made to //-Ref such that ptr1 points to variable C?

int main()
{
int a = 1, b = 2, c = 3;
int *ptr1 = &a;
int **sptr = &ptr1;
//-Ref
}

A.*sptr = &c;
B.**sptr = &c;
C.*ptr1 = &c;
D.None of the mentioned.

Answer: A

Correct answer: *sptr = &c;

*sptr is another name for ptr1, so assigning the address of c to it makes ptr1 point at c. The alternative **sptr = &c; would assign a pointer to the int that ptr1 currently points at, and *ptr1 = &c; does the same thing - both are type errors and both write to a rather than redirecting the pointer.

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