Assume int is 4 bytes, char is 1 byte, and 4-byte alignment is enforced. What is sizeof(struct S) for:
struct S {
char c1;
int i;
char c2;
};c1 takes 1 byte + 3 padding bytes (4). 'i' takes 4 bytes (8). c2 takes 1 byte + 3 trailing padding bytes to round up to multiple of 4, yielding 12 bytes.
What is the output of the following C code?
#include <stdio.h>
struct S {
int a;
int b;
};
int main(void) {
struct S arr[3] = {{1, 2}, {3, 4}, {5, 6}};
printf("%d", arr[1].b + arr[2].a);
return 0;
}arr[1].b evaluates to 4. arr[2].a evaluates to 5. 4 + 5 = 9.
Consider a union declared on a 32-bit architecture:
union Test {
char arr[15];
int i;
};Assuming int alignment is 4 bytes, what is sizeof(union Test) in bytes?
Largest member is arr[15] (15 bytes). To satisfy 4-byte alignment requirement for 'int i', the union size is rounded up to the nearest multiple of 4, which is 16 bytes.
What is printed by the C code?
#include <stdio.h>
struct Point {
int x;
int y;
};
int main(void) {
struct Point p[2] = {{10, 20}, {30, 40}};
struct Point *ptr = p;
ptr++;
printf("%d", ptr->y);
return 0;
}ptr initially points to p[0]. 'ptr++' advances ptr to p[1]. 'ptr->y' evaluates to p[1].y, which is 40.
What is the output value printed?
#include <stdio.h>
struct S {
int x;
};
int main(void) {
struct S s = {100};
struct S *p1 = &s;
struct S **p2 = &p1;
printf("%d", (**p2).x);
return 0;
}**p2 dereferences double pointer p2 to retrieve structure instance 's'. (**p2).x accesses field 'x', evaluating to 100.