Pointers Questions and Answers

Q: What will be the output of the program ? #include <stdio.h> int main() { printf("%c\n", 7["IndiaBIX"]); return 0; }

Correct answer: print "X" of IndiaBIXSubscripting is defined as x[y] meaning *(x+y), and addition is commutative, so 7["IndiaBIX"] means *(7 + "IndiaBIX") - exactly the same as "IndiaBIX"[7].Counting from zero, position 7 of IndiaBIX is X. The reversed form is legal but deliberately perverse, and it is worth knowing chiefly as evidence that array subscripting in C really is just pointer arithmetic with syntactic sugar.

Q: If a variable is a pointer to a structure, then which of the following operator is used to access data members of the structure through the pointer variable?

Correct answer: ->The arrow operator accesses a member through a pointer to a structure: p->member is by definition equivalent to (*p).member.The parentheses in that expansion are essential, which is why the shorthand exists - . binds more tightly than *, so *p.member would be parsed as *(p.member) and rejected. The dot operator is for a structure object itself, not for a pointer to one.

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

Correct answer: 0i is a global, so it has static storage duration and is zero-initialised before the program starts.Inside fun, &p is the address of the parameter, which itself holds &i. Casting that to int ** and applying ** therefore reads first the parameter, obtaining &i, and then i itself - giving 0. The double cast is a roundabout way of reaching a value that *(int*)p would have given directly.

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

Correct answer: 2 2Here the address of the pointer is passed, so *p = &j modifies the caller’s pointer itself and both prints give 2. That is how a function changes a pointer in its caller. Note that it is also a bug in the making: after foo returns, p in main points at j, whose lifetime has ended, so the second dereference is strictly undefined even though it prints 2 in practice.

Q: What will be the output of the program ? #include <stdio.h> int main() { char str1[] = "India"; char str2[] = "BIX"; char *s1 = str1, *s2=str2; while(*s1++ = *s2++) printf("%s", str1); printf("\n"); return 0; }

Correct answer: BndiaBIdiaBIXiaThe loop copies str2 into str1 one character at a time, printing the whole of str1 after each copy, and stops when the assigned value is the terminating null.After copying B, str1 reads Bndia; after I, BIdia; after X, BIXia. The three prints concatenate to BndiaBIdiaBIXia. Note that the assignment's value is what controls the loop, which is the standard C string-copy idiom.

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

Correct answer: Compile time errorint *const ptr declares a constant pointer to a modifiable int: the pointer itself may not be changed after initialisation. So ptr++ is an attempt to modify a const object and the compiler rejects it. Read the declaration from the name outward - const binds to what is on its left, so here it qualifies the pointer rather than the pointee.

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, **p); }

Correct answer: Compile time errorThe last argument is **p, but p is an int *, so *p is an int and applying * to an integer is not allowed. The number of dereferences must match the number of levels the pointer actually has. Writing **m instead, as in the previous question, is the correct form and gives 5.

Q: What will be the output of the program ? #include <stdio.h> int main() { char str[20] = "Hello"; char *const p=str; *p='M'; printf("%s\n", str); return 0; }

Correct answer: Mellochar *const p makes the pointer const, not what it points to. So p cannot be made to point elsewhere, but *p = 'M' is perfectly legal and writes through it.str is a modifiable array, so the write succeeds and the string becomes Mello. Compare const char *p, where the qualifier applies to the pointed-to characters and the assignment would be rejected - the position of const relative to the asterisk decides which is protected.

81.

What will be the output of the program ?

#include <stdio.h>

int main()
{
    printf("%c\n", 7["IndiaBIX"]);
    return 0;
}

A.Error: in printf
B.Nothing will print
C.print "X" of IndiaBIX
D.print "7"

Answer: C

Correct answer: print "X" of IndiaBIX

Subscripting is defined as x[y] meaning *(x+y), and addition is commutative, so 7["IndiaBIX"] means *(7 + "IndiaBIX") - exactly the same as "IndiaBIX"[7].

Counting from zero, position 7 of IndiaBIX is X. The reversed form is legal but deliberately perverse, and it is worth knowing chiefly as evidence that array subscripting in C really is just pointer arithmetic with syntactic sugar.

Discuss in Forum

82.

If a variable is a pointer to a structure, then which of the following operator is used to access data members of the structure through the pointer variable?

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

Answer: D

Correct answer: ->

The arrow operator accesses a member through a pointer to a structure: p->member is by definition equivalent to (*p).member.

The parentheses in that expansion are essential, which is why the shorthand exists - . binds more tightly than *, so *p.member would be parsed as *(p.member) and rejected. The dot operator is for a structure object itself, not for a pointer to one.

Discuss in Forum

83.

What will be the output of the program ?

#include <stdio.h>

void fun(void *p);
int i;

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

A.Error: cannot convert from void** to int**
B.Garbage value
C.No output
D.0

Answer: D

Correct answer: 0

i is a global, so it has static storage duration and is zero-initialised before the program starts.

Inside fun, &p is the address of the parameter, which itself holds &i. Casting that to int ** and applying ** therefore reads first the parameter, obtaining &i, and then i itself - giving 0. The double cast is a roundabout way of reaching a value that *(int*)p would have given directly.

Discuss in Forum

84.

What is the output of this C code?

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

A.2 2
B.2 97
C.Undefined behaviour
D.Segmentation fault/code crash

Answer: A

Correct answer: 2 2

Here the address of the pointer is passed, so *p = &j modifies the caller’s pointer itself and both prints give 2. That is how a function changes a pointer in its caller. Note that it is also a bug in the making: after foo returns, p in main points at j, whose lifetime has ended, so the second dereference is strictly undefined even though it prints 2 in practice.

Discuss in Forum

85.

A pointer is

A.A keyword used to create variables
B.A variable that stores address of an instruction
C.A variable that stores address of other variable
D.All of the above

Answer: C

Correct answer: A variable that stores address of other variable

A pointer is a variable whose value is the address of another object. It has a type - the type of what it points to - which determines both how the pointed-to bytes are interpreted and how pointer arithmetic is scaled.

It is not a keyword; there is no pointer keyword in C, the asterisk in a declaration doing the work. And while a function pointer holds the address of code, the general definition is in terms of objects, so the option naming instructions describes a special case rather than the concept.

Discuss in Forum

86.

What will be the output of the program ?

#include <stdio.h>

int main()
{
    char str1[] = "India";
    char str2[] = "BIX";
    char *s1 = str1, *s2=str2;
    while(*s1++ = *s2++)
        printf("%s", str1);

    printf("\n");
    return 0;
}

A.IndiaBIX
B.BndiaBIdiaBIXia
C.India
D.(null)

Answer: B

Correct answer: BndiaBIdiaBIXia

The loop copies str2 into str1 one character at a time, printing the whole of str1 after each copy, and stops when the assigned value is the terminating null.

After copying B, str1 reads Bndia; after I, BIdia; after X, BIXia. The three prints concatenate to BndiaBIdiaBIXia. Note that the assignment's value is what controls the loop, which is the standard C string-copy idiom.

Discuss in Forum

87.

Which of the following statements correct about k used in the below statement?
char ****k;

A.k is a pointer to a pointer to a pointer to a char
B.k is a pointer to a pointer to a pointer to a pointer to a char
C.k is a pointer to a char pointer
D.k is a pointer to a pointer to a char

Answer: B

Correct answer: k is a pointer to a pointer to a pointer to a pointer to a char

Each asterisk adds one level of indirection, so four asterisks give four levels: k is a pointer to a pointer to a pointer to a pointer to char.

Counting the asterisks is the whole technique for reading such declarations. In practice more than two or three levels are rare outside argument-vector manipulation and certain data structures, and where they arise a typedef for the intermediate levels usually makes the code readable.

Discuss in Forum

88.

What is the output of this C code?

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

A.0 1
B.Compile time error
C.0xbfd605e8 0xbfd605ec
D.0xbfd605e8 0xbfd605e8

Answer: B

Correct answer: Compile time error

int *const ptr declares a constant pointer to a modifiable int: the pointer itself may not be changed after initialisation. So ptr++ is an attempt to modify a const object and the compiler rejects it. Read the declaration from the name outward - const binds to what is on its left, so here it qualifies the pointer rather than the pointee.

Discuss in Forum

89.

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, **p);
}

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

Answer: D

Correct answer: Compile time error

The last argument is **p, but p is an int *, so *p is an int and applying * to an integer is not allowed. The number of dereferences must match the number of levels the pointer actually has. Writing **m instead, as in the previous question, is the correct form and gives 5.

Discuss in Forum

90.

What will be the output of the program ?

#include <stdio.h>

int main()
{
    char str[20] = "Hello";
    char *const p=str;
    *p='M';
    printf("%s\n", str);
    return 0;
}

A.Mello
B.Hello
C.HMello
D.MHello

Answer: A

Correct answer: Mello

char *const p makes the pointer const, not what it points to. So p cannot be made to point elsewhere, but *p = 'M' is perfectly legal and writes through it.

str is a modifiable array, so the write succeeds and the string becomes Mello. Compare const char *p, where the qualifier applies to the pointed-to characters and the assignment would be rejected - the position of const relative to the asterisk decides which is protected.

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