Pointers Questions and Answers

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

Correct answer: 10The storage was obtained from malloc, so it lives on the heap and survives the return of the function that allocated it. The pointer therefore remains valid in main and dereferencing it gives 10. Compare the next question, where the same structure with an automatic variable is undefined - the difference is the storage duration, not the pointer.

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

Correct answer: 11 11In main, int *const p makes the pointer itself const, so &p has type int *const *. Passing that to a parameter of type int ** discards the qualifier, which is a constraint violation - but compilers generally warn rather than refuse, so the program runs.foo then writes through the pointer, redirecting main's p to j, and both prints show 11. The exercise illustrates that const can be circumvented through a pointer conversion the compiler only warns about.

Q: Can you combine the following two statements into one? char *p; p = (char*) malloc(100);

Correct answer: char *p = (char*)malloc(100);A declaration may carry an initialiser, so the declaration and the assignment combine directly: char *p = (char*)malloc(100);.The other forms misplace the asterisks. (char)malloc(100) casts the returned pointer to a single character, and the last option is not valid syntax at all. It is worth adding that in C the cast is unnecessary - void * converts to any object pointer type implicitly, and omitting the cast can expose a missing stdlib.h that the cast would hide.

Q: Which of the following statements correctly declare a function that receives a pointer to pointer to a pointer to a float and returns a pointer to a pointer to a pointer to a pointer to a float?

Correct answer: float ****fun(float***);Read the declaration outward from the name. The parameter is a pointer to a pointer to a pointer to a float, so it is written float ***. The return type is one level deeper again, so it is float ****.Count the asterisks against the words: three for the parameter, four for the return. The other options mismatch one or both. Where such declarations become unreadable, a typedef for the intermediate types is the usual remedy.

Q: If p is a pointer, what does the expression *p give ?

Correct answer: The value stored at the address held by pThe asterisk is the dereference operator, which follows the pointer to the object it refers to. The address of p itself is obtained with &p, and p alone gives the address it holds.

Q: What is the output of this C code? int main() { int *ptr, a = 10; ptr = &a; *ptr += 1; printf("%d,%d/n", *ptr, a); }

Correct answer: 11,11ptr holds the address of a, so *ptr += 1 increments a itself - there is only one object, reached by two names. Both print as 11. Note also the /n in the format string, which is a forward slash and the letter n rather than an escape, so it appears literally instead of starting a new line.

Q: What will be the output of the program assuming that the array begins at the location 1002 and size of an integer is 4 bytes? #include <stdio.h> int main() { int a[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; printf("%u, %u, %u\n", a[0]+1, *(a[0]+1), *(*(a+0)+1)); return 0; }

Correct answer: 1006, 2, 2Take the three arguments in turn. a[0] is a pointer to the first row's first element, at 1002, and adding 1 advances it by sizeof(int), giving 1006.*(a[0]+1) dereferences that, yielding a[0][1], which is 2. And *(*(a+0)+1) is the same expression written with explicit pointer arithmetic - a+0 is a, *(a+0) is a[0] - so it too gives 2.

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

Correct answer: Compile time error&i yields the address of i, but it is a value, not an object - there is no storage holding it that could be incremented.++ requires a modifiable lvalue, so (&i)++ is a constraint violation and the compiler rejects it. The contrast with the next case is instructive: if the address is first stored in a pointer variable, that variable is an object and can be incremented.

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.

41.

What is the output of this C code?

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

A.10
B.Compile time error
C.Segmentation fault/runtime crash since pointer to local variable is returned
D.Undefined behaviour

Answer: A

Correct answer: 10

The storage was obtained from malloc, so it lives on the heap and survives the return of the function that allocated it. The pointer therefore remains valid in main and dereferencing it gives 10. Compare the next question, where the same structure with an automatic variable is undefined - the difference is the storage duration, not the pointer.

Discuss in Forum

42.

What will be the output of the following C code?

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

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

Answer: A

Correct answer: 11 11

In main, int *const p makes the pointer itself const, so &p has type int *const *. Passing that to a parameter of type int ** discards the qualifier, which is a constraint violation - but compilers generally warn rather than refuse, so the program runs.

foo then writes through the pointer, redirecting main's p to j, and both prints show 11. The exercise illustrates that const can be circumvented through a pointer conversion the compiler only warns about.

Discuss in Forum

43.

Can you combine the following two statements into one?

char *p;
p = (char*) malloc(100);

A.char p = *malloc(100);
B.char *p = (char) malloc(100);
C.char *p = (char*)malloc(100);
D.char *p = (char *)(malloc*)(100);

Answer: C

Correct answer: char *p = (char*)malloc(100);

A declaration may carry an initialiser, so the declaration and the assignment combine directly: char *p = (char*)malloc(100);.

The other forms misplace the asterisks. (char)malloc(100) casts the returned pointer to a single character, and the last option is not valid syntax at all. It is worth adding that in C the cast is unnecessary - void * converts to any object pointer type implicitly, and omitting the cast can expose a missing stdlib.h that the cast would hide.

Discuss in Forum

44.

What will be the output of the program if the size of pointer is 4-bytes?

#include <stdio.h>

int main()
{
    printf("%d, %d\n", sizeof(NULL), sizeof(""));
    return 0;
}

A.2, 1
B.2, 2
C.4, 1
D.4, 2

Answer: C

In TurboC, the output will be 2, 1 because the size of the pointer is 2 bytes in 16-bit platform.

But in Linux, the output will be 4, 1 because the size of the pointer is 4 bytes.

This difference is due to the platform dependency of C compiler.

Discuss in Forum

45.

Which of the following statements correctly declare a function that receives a pointer to pointer to a pointer to a float and returns a pointer to a pointer to a pointer to a pointer to a float?

A.float **fun(float***);
B.float *fun(float**);
C.float fun(float***);
D.float ****fun(float***);

Answer: D

Correct answer: float ****fun(float***);

Read the declaration outward from the name. The parameter is a pointer to a pointer to a pointer to a float, so it is written float ***. The return type is one level deeper again, so it is float ****.

Count the asterisks against the words: three for the parameter, four for the return. The other options mismatch one or both. Where such declarations become unreadable, a typedef for the intermediate types is the usual remedy.

Discuss in Forum

46.

If p is a pointer, what does the expression *p give ?

A.The address stored in p
B.The value stored at the address held by p
C.The address of p itself
D.The size of the type p points to

Answer: C

Correct answer: The value stored at the address held by p

The asterisk is the dereference operator, which follows the pointer to the object it refers to. The address of p itself is obtained with &p, and p alone gives the address it holds.

Discuss in Forum

47.

What is the output of this C code?

int main()
{
int *ptr, a = 10;
ptr = &a;
*ptr += 1;
printf("%d,%d/n", *ptr, a);
}

A.10,10
B.10,11
C.11,10
D.11,11

Answer: D

Correct answer: 11,11

ptr holds the address of a, so *ptr += 1 increments a itself - there is only one object, reached by two names. Both print as 11. Note also the /n in the format string, which is a forward slash and the letter n rather than an escape, so it appears literally instead of starting a new line.

Discuss in Forum

48.

What will be the output of the program assuming that the array begins at the location 1002 and size of an integer is 4 bytes?

#include <stdio.h>

int main()
{
    int a[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
    printf("%u, %u, %u\n", a[0]+1, *(a[0]+1), *(*(a+0)+1));
    return 0;
}

A.448, 4, 4
B.520, 2, 2
C.1006, 2, 2
D.Error

Answer: C

Correct answer: 1006, 2, 2

Take the three arguments in turn. a[0] is a pointer to the first row's first element, at 1002, and adding 1 advances it by sizeof(int), giving 1006.

*(a[0]+1) dereferences that, yielding a[0][1], which is 2. And *(*(a+0)+1) is the same expression written with explicit pointer arithmetic - a+0 is a, *(a+0) is a[0] - so it too gives 2.

Discuss in Forum

49.

What will be the output of the following C code?

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

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

Answer: C

Correct answer: Compile time error

&i yields the address of i, but it is a value, not an object - there is no storage holding it that could be incremented.

++ requires a modifiable lvalue, so (&i)++ is a constraint violation and the compiler rejects it. The contrast with the next case is instructive: if the address is first stored in a pointer variable, that variable is an object and can be incremented.

Discuss in Forum

50.

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

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