What is the output of this C code?
void main()
{
int k = 5;
int *p = &k;
int **m = &p;
**m = 6;
printf("%d\n", k);
}
Answer: C
Correct answer: 6
**m reaches all the way through to k: m points at p, and p points at k. So the assignment writes 6 into k itself, and printing k confirms it. This is how a double pointer lets code several levels away modify the original object.
Please log in or register to report this question.
What is the output of this C code?
int main()
{
int a = 1, b = 2, c = 3;
int *ptr1 = &a, *ptr2 = &b, *ptr3 = &c;
int **sptr = &ptr1; //-Ref
*sptr = ptr2;
}
Answer: B
Correct answer: ptr1 points to b
sptr holds the address of ptr1, so *sptr is ptr1, and assigning ptr2 to it copies the address of b into ptr1. Afterwards ptr1 and ptr2 both point at b. Note that sptr itself is unchanged and still points at ptr1.
Please log in or register to report this question.
What will be the output of the program ?
#include <stdio.h>
int main()
{
char *str;
str = "%s";
printf(str, "K\n");
return 0;
}
Answer: C
Correct answer: K
printf takes its format as an ordinary const char * argument, so nothing requires it to be a literal written at the call site. Here str holds "%s", and printf(str, "K\n") uses it exactly as if the literal had been written there.
The output is K followed by a newline. The technique is legal but dangerous in practice: a format string taken from input rather than fixed in the source is the classic format string vulnerability, which is why compilers warn about non-literal formats.
Please log in or register to report this question.
What will be the output of the program assuming that the array begins at location 1002?
#include <stdio.h>
int main()
{
int a[2][3][4] = { {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 1, 2},
{2, 1, 4, 7, 6, 7, 8, 9, 0, 0, 0, 0} };
printf("%u, %u, %u, %d\n", a, *a, **a, ***a);
return 0;
}
Answer: C
Correct answer: 1002, 1002, 1002, 1
The first three arguments all denote the same address, differing only in type. a is a pointer to the first two-dimensional sub-array, *a a pointer to its first row, and **a a pointer to its first element - but the first element sits at the start of the first row, which sits at the start of the array, so all three are 1002.
Only ***a dereferences all the way through to a value, giving the first element, 1. This is the standard demonstration that an array's address and its first element's address coincide numerically while differing in type.
Please log in or register to report this question.
The operator used to get value at address stored in a pointer variable is
Answer: A
Correct answer: *
The unary * is the indirection, or dereference, operator: it yields the object a pointer points to. Its counterpart & is the address-of operator, going the other way.
The asterisk plays two distinct roles that are easy to conflate. In a declaration it forms a pointer type; in an expression it dereferences. The && and || operators are logical AND and OR and have nothing to do with pointers.
Please log in or register to report this question.
What is the output of this C code?
int main()
{
int i = 10;
void *p = &i;
printf("%d\n", (int)*p);
return 0;
}
Answer: A
Correct answer: Compile time error
A void * cannot be dereferenced. void is an incomplete type with no size and no representation, so the compiler cannot know how many bytes to read or how to interpret them, and *p is rejected before the cast is even considered. The correct form casts the pointer first: *(int *)p.
Please log in or register to report this question.
Comment on the output of this C code?
int main()
{
int a = 10;
int **c -= &&a;
}
Answer: B
Correct answer: We don't have address of an address operator
There is no && address operator in C. The token exists only as logical AND, so &&a is parsed as that operator with a missing left operand and the line will not compile. To obtain a pointer to a pointer you must have a pointer object to take the address of, as the earlier questions do with &p.
Please log in or register to report this question.
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;
}
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.
Please log in or register to report this question.
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);
}
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.
Please log in or register to report this question.
Can you combine the following two statements into one?
char *p;
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.
Please log in or register to report this question.