Pointers Questions and Answers

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.

Q: Which of the following declaration throw run-time error?

Correct answer: None of the mentionedNone of the three reaches run time. Each is a type error caught at compilation: &c in the first has type int ***, the second is the same after the & and * cancel, and the third dereferences c twice in its own initialiser. A run-time error would require a program that compiles first.

Q: Is the NULL pointer same as an uninitialised pointer?

Correct answer: NoA null pointer holds a defined value that compares unequal to any valid address, so it can be tested with if (p) and used as a sentinel. An uninitialised pointer holds whatever happened to be in memory, so it cannot be tested meaningfully and dereferencing it is undefined. Confusing the two is why uninitialised pointers should always be set to NULL explicitly.

51.

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

52.

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

53.

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

54.

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

55.

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

56.

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

57.

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

58.

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

59.

Which of the following declaration throw run-time error?

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

Answer: D

Correct answer: None of the mentioned

None of the three reaches run time. Each is a type error caught at compilation: &c in the first has type int ***, the second is the same after the & and * cancel, and the third dereferences c twice in its own initialiser. A run-time error would require a program that compiles first.

Discuss in Forum

60.

Is the NULL pointer same as an uninitialised pointer?

A.Yes
B.No

Answer: B

Correct answer: No

A null pointer holds a defined value that compares unequal to any valid address, so it can be tested with if (p) and used as a sentinel. An uninitialised pointer holds whatever happened to be in memory, so it cannot be tested meaningfully and dereferencing it is undefined. Confusing the two is why uninitialised pointers should always be set to NULL explicitly.

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