Question 1

Pointers and dereferencing in C: which operator retrieves the value stored at the memory address contained in a pointer variable?

Accepted Answer

Introduction / Context: Pointers store memory addresses, and dereferencing a pointer accesses the object at that address. This is central to dynamic memory, arrays, and function parameters. Knowing the distinct roles of the unary * and & operators avoids confusion when reading and writing pointer code. Given Data / Assumptions: We have a pointer variable p that holds the address of some object. Standard C operator meanings are assumed. Concept / Approach: The unary * operator is the dereference operator. Applied to a pointer p, the expression *p yields the lvalue of the object pointed to. Conversely, & is the address-of operator that produces a pointer from an object. The tokens && and || are logical operators for boolean conditions and have nothing to do with pointer access. Step-by-Step Solution: Given int x = 10; int *p = &x; the expression *p evaluates to 10.Assignments through pointers use dereference: *p = 42; changes x to 42.Therefore, the operator that “gets the value at the address” in a pointer is *. Verification / Alternative check: Print *p and x after assignments to confirm they remain in sync because they refer to the same object via direct and indirect access. Why Other Options Are Wrong: & obtains an address; it does not access the value through a pointer. && and || are logical operators for conditions, unrelated to memory access. Common Pitfalls: Confusing * in declarations (type name) with * in expressions (dereference); both are related but occur in different grammatical contexts. Final Answer: .

Question 2

C standard macros: in which standard header(s) is the macro NULL guaranteed to be defined?

Accepted Answer

Introduction / Context: NULL is the canonical macro used to denote a null pointer constant in C. Many standard headers include its definition so that programmers can use NULL without memorizing which specific header introduced it in a particular translation unit. Given Data / Assumptions: We are targeting conforming hosted C implementations. We want to know which headers are required by the C standard to provide NULL. Concept / Approach: The C standard specifies that several headers define NULL, including , , , , and . Therefore, both stddef.h and stdio.h provide it. Choosing either header (or many others) makes NULL available. Step-by-Step Solution: Identify headers guaranteed to define NULL.Confirm that both stddef.h and stdio.h are among them.Select the option that lists both together. Verification / Alternative check: Compile small files that include only stddef.h or only stdio.h and use NULL in a declaration; both compile successfully on conforming implementations. Why Other Options Are Wrong: stdio.h alone or stddef.h alone omit one valid header from the paired choice. math.h is not required to define NULL. Common Pitfalls: Confusing NULL (a null pointer constant) with 0 or with the C++ nullptr keyword; assuming only one header provides NULL. Final Answer: stdio.h and stddef.h.

Question 3

In C pointer terminology, what does the expression (void*)0 represent?

Accepted Answer

Introduction / Context: Null pointers are used to indicate that a pointer intentionally does not point to any valid object or function. C defines specific ways to write a null pointer constant so that it can be converted to any pointer type safely. Given Data / Assumptions: We are evaluating the literal (void*)0. Standard C semantics for pointer constants apply. Concept / Approach: (void*)0 is a canonical spelling of a null pointer constant: the integer constant 0 explicitly cast to pointer-to-void. When assigned to or compared with any object pointer type, it becomes that type’s null pointer. It does not represent a generic “void pointer value” in use; it specifically denotes the absence of a valid address. Step-by-Step Solution: Start with the integer constant 0, which is a null pointer constant in C.Cast to (void*) to make the null-ness explicit and type-safe for function overloading or diagnostics.Use in code: int p = (void)0; /* p becomes a null pointer / Verification / Alternative check: Comparisons like if (p == NULL) or if (p == (void)0) are equivalent when p is a pointer to object. Why Other Options Are Wrong: “Representation of void pointer” is vague; (void*)0 is not a generic pointer value, it is the null pointer value of type void*. “Error” and “None of above” are incorrect because the expression is well-defined and standard. Common Pitfalls: Confusing (void*)0 with 0 or NULL in C++ where nullptr is preferred; assuming null pointers are all-bits-zero at the machine level (the standard does not require that). Final Answer: Representation of NULL pointer.

Question 4

Accessing structure members through a pointer in C: which operator should be used to reach a field of a struct via a pointer variable?

Accepted Answer

Introduction / Context: C offers two syntaxes for accessing structure members: the dot operator for a direct struct object and the arrow operator for a pointer to a struct. Choosing the correct operator improves clarity and avoids common compiler errors. Given Data / Assumptions: We have a pointer variable p of type struct S that points to a valid struct S object. We want to access one of its members, say field. Concept / Approach: When working with a pointer to a struct, the expression p->field is syntactic sugar for (*p).field. The arrow operator both dereferences the pointer and selects the member in one step. By contrast, the dot operator expects an actual struct object (not a pointer). The unary * operator alone yields the struct object from the pointer but still requires . to access a specific member. Step-by-Step Solution: Given struct S s; struct S *p = &s; to access s.field through p, write p->field.Equivalent but longer form: (*p).field.Using p.field is a type error because p is not a struct object. Verification / Alternative check: Compile a snippet using both p->field and (p).field to see they produce the same code in practice. Why Other Options Are Wrong: . applies to non-pointer struct objects. & is the address-of operator, unrelated to member access. alone dereferences but does not select a member. Common Pitfalls: Forgetting parentheses in (*p).field; without them, *p.field binds incorrectly due to precedence. Final Answer: ->.

Question 5

In C/C++, can the two statements 'char p;' and 'p = (char) malloc(100);' be combined into a single declaration-and-initialization statement? Select the correctly formed combined statement.

Accepted Answer

Introduction / Context: Dynamic memory allocation is a core C/C++ skill. Often, a pointer is declared and immediately assigned memory from the heap using malloc. This question tests whether you can correctly combine the declaration and the allocation into a single, syntactically valid statement while respecting type conversions and pointer syntax. Given Data / Assumptions: You need 100 bytes allocated from the heap. Pointer type should be char because the memory will be treated as an array of bytes. The code may be compiled as C or C++ (casting rules differ slightly). Concept / Approach: malloc returns void. In C, an explicit cast is not required; in C++ it is required (or you should prefer new). A correct single statement must both declare p as a char and assign it the result of malloc converted to char*. Step-by-Step Solution: Start with the pointer declaration: char p;Allocate: p = (char)malloc(100);Combine: char p = (char)malloc(100);Ensure parentheses are around the cast, not around malloc's name. Verification / Alternative check: You can print p or test p != NULL (or p != nullptr in C++) to verify allocation. In C-only code, char *p = malloc(100); without a cast is also valid and idiomatic. Why Other Options Are Wrong: char p = malloc(100); dereferences void and stores a single char—wrong type/semantics. char *p = (char) malloc(100); casts to char, losing pointer value. char p = (char )(malloc)(100); invents a non-existent type (malloc), invalid syntax. Common Pitfalls: Forgetting to include stdlib.h (or cstdlib) for malloc, or failing to check allocation success. In C++, prefer new[] or smart pointers over malloc/free. Final Answer: char p = (char)malloc(100);.

Question 6

In C programming, what is a pointer most accurately described as (choose the best definition in the context of variables and memory addresses)?

Accepted Answer

Introduction / Context: Pointers are fundamental in C for indirect access, dynamic memory management, and interfacing with arrays and functions. Understanding the precise definition of a pointer prevents misuse and clarifies how memory addresses are manipulated in code. Given Data / Assumptions: The discussion is about C variables and how pointers behave. We consider typical pointers to objects; function pointers are an advanced topic. We focus on the best general definition among the given choices. Concept / Approach: A pointer is a variable whose value is the address of another object (variable). Declared as type *name, it stores the location of an object of that type. While there are function pointers that hold code addresses, the most accurate, general-purpose definition is that a pointer stores the address of another variable (object). It is not a keyword; it is a kind of variable with a special value (an address). Step-by-Step Solution: Identify that a pointer value is an address (e.g., &x).Understand that dereferencing *p accesses the object at that address.Select the option stating it stores the address of another variable.Exclude options that mischaracterize keywords or overgeneralize. Verification / Alternative check: Given int x = 10; int *p = &x; *p == 10 evaluates true, confirming that p stores x's address and can access x indirectly. Why Other Options Are Wrong: Keyword: The pointer is not a keyword; * is an operator in declarations. Address of an instruction: That describes function pointers, not the general case. All of the above: Bundles incorrect statements, so it is false. Common Pitfalls: Confusing the pointer's own address (&p) with the address it stores (p). Also, forgetting to initialize pointers leads to undefined behavior. Final Answer: A variable that stores address of other variable.

Question 7

In 16-bit DOS memory models, how many bytes are used by near, far, and huge pointers respectively?

Accepted Answer

Introduction / Context: Legacy 16-bit DOS compilers (e.g., Turbo C) used segmented memory. Pointer size depended on the model: near, far, and huge pointers referenced memory differently across segments and offsets. Recognizing these sizes is vital for understanding historical code and interview questions about memory models. Given Data / Assumptions: Platform is 16-bit DOS with segment:offset addressing. near pointers reference within a single segment. far and huge pointers include both segment and offset. Concept / Approach: A near pointer holds only a 16-bit offset (2 bytes). Far and huge pointers store a 16-bit segment and a 16-bit offset, totaling 32 bits (4 bytes). The difference between far and huge is semantic: huge pointers are normalized for arithmetic across segment boundaries, whereas far pointers are not necessarily normalized, but both are 4 bytes. Step-by-Step Solution: Identify near pointer size: offset only → 2 bytes.Identify far/huge pointer sizes: segment (2 bytes) + offset (2 bytes) → 4 bytes.Conclude: near=2, far=4, huge=4.Recognize behavioral difference (normalization) without affecting size. Verification / Alternative check: Consulting old compiler docs (e.g., Borland/Turbo C memory models) confirms 2-byte near and 4-byte far/huge pointers in 16-bit modes. Why Other Options Are Wrong: near=2 far=4 huge=8: Huge is not 8 bytes in 16-bit DOS. near=4 far=8 huge=8 or near=4 far=4 huge=8: These sizes correspond to neither 16-bit DOS nor standard models. Common Pitfalls: Confusing 32/64-bit flat models (where pointers are 4/8 bytes) with 16-bit segmented models. Always tie pointer size to architecture and memory model. Final Answer: near=2 far=4 huge=4.

Question 8

For a four-dimensional array a[i][j][k][l] in C, which equivalent pointer expression correctly refers to that element using pointer arithmetic and dereferencing?

Accepted Answer

Introduction / Context: In C, multi-dimensional arrays are arrays of arrays laid out contiguously in row-major order. Subscript notation a[i][j][k][l] can be expressed using pointer arithmetic and dereferencing. This question checks your understanding of how nested dereferences correspond to each subscript level. Given Data / Assumptions: a is declared as a true 4D array, not as a flattened pointer. Each subscript selects the next inner array level. Pointer arithmetic is scaled by the size of the pointed-to type at each level. Concept / Approach: For an array T a[A][B][C][D], the expression a+i advances i elements of type T[B][C][D]. Dereferencing once with * yields a[i], which is of type T[B][C][D]. Repeating this logic, each subsequent + index and * dereference steps into the next dimension until reaching the scalar element T at [i][j][k][l]. Step-by-Step Solution: Start: a+i → pointer to a[i] (type: array of [B][C][D]).Dereference: (a+i) → a[i].Add j: (a+i)+j → &a[i][j] (pointer to array [C][D]).Dereference: ((a+i)+j) → a[i][j].Add k: ((a+i)+j)+k → &a[i][j][k] (pointer to array [D]).Dereference: (((a+i)+j)+k) → a[i][j][k].Add l: (((a+i)+j)+k)+l → &a[i][j][k][l].Final dereference: ((((a+i)+j)+k)+l) → a[i][j][k][l]. Verification / Alternative check: For a 2D case a[i][j], the equivalent (a[i] + j) generalizes to higher dimensions by nesting the pattern consistently, confirming the chosen expression. Why Other Options Are Wrong: Parentheses-only sums like (((a+i)+j)+k+l) never dereference; they also add integers to incompatible pointer types. ((((a+i)+j)+k)+l) similarly omits dereferencing at each dimension. Common Pitfalls: Forgetting that each dimension requires a dereference before adding the next index; otherwise, types do not line up and the expression becomes ill-formed. Final Answer: (((*(a+i)+j)+k)+l).

Question 9

C format strings, pointer arithmetic, and printf: what does this program print?  #include<stdio.h>  int main() {  char *str;  str = "%d ";  str++;  str++;  printf(str-2, 300);  return 0; }

Accepted Answer

Introduction / Context: This problem tests understanding of string literals, pointer arithmetic, and how printf uses a format string. The code manipulates a pointer into the literal "%d" and then passes an adjusted pointer back to printf. Given Data / Assumptions: String literal: "%d" has bytes: '%' (index 0), 'd' (1), '' (2), '\0' (3). str initially points to index 0. str is incremented twice, so str points at index 2 (the newline). printf receives str - 2, which points back to index 0. Concept / Approach: After two increments, str points at ''. Subtracting 2 moves the pointer back to '%'. Therefore, the format string passed to printf is effectively "%d". With the integer argument 300 supplied, printf prints the decimal representation followed by a newline. Step-by-Step Solution: Initialize str → "%d".Increment twice → str now points at ''.Compute str - 2 → pointer to '%' (start of format).printf("%d", 300) → prints 300. Verification / Alternative check: Replace the subtraction with a direct literal in printf and confirm identical output. Why Other Options Are Wrong: No output / Runtime error: The pointer ends up valid; it points to the beginning of the same literal.30 or 3: printf with "%d" prints the full integer value, not partial digits. Common Pitfalls: Forgetting the actual byte layout of the format string and miscounting pointer steps; assuming pointer math corrupts the pointer when it actually returns to a valid position within the same literal. Final Answer: 300.

Question 10

C printf with a string format specifier: what is printed?  #include<stdio.h>  int main() {  char str;  str = "%s";  printf(str, "K ");  return 0; }

Accepted Answer

Introduction / Context: printf uses a format string to control how subsequent arguments are printed. With the "%s" format, printf expects a pointer to a null-terminated string. This question checks whether you can trace a simple printf call passing a one-character string with a newline. Given Data / Assumptions: Format string: "%s". Argument: the string literal "K" (letter K then newline then null terminator). Concept / Approach: The "%s" format prints characters from the provided char until the terminating '\0'. Therefore, the two characters 'K' and '' are emitted. Many MCQs capture the visible part (“K”) and ignore that a newline follows; here the important visual output is the letter K followed by a line break. Step-by-Step Solution: printf("%s", "K")Output sequence → 'K' then newline.On a terminal, you see K and the cursor moves to the next line. Verification / Alternative check: Change the literal to "K" (no newline) to see the cursor remain on the same line. Why Other Options Are Wrong: Error/No output: printf is called correctly with a matching argument type.%s: That would print the percent-escaped letters literally, which does not happen here.K%s: Not produced by printf for this call. Common Pitfalls: Forgetting the newline is part of the literal; misreading the format string as a literal to be printed rather than a directive. Final Answer: K.

Question 11

Pointer-based string copy with printing at each step (assume enough destination space): what final string does str1 hold after the loop?  #include<stdio.h>  int main() {  char str1[20] = "India"; // assume sufficient space to avoid overflow  char st…

Accepted Answer

Introduction / Context: This classic pointer-copy loop uses the assignment expression inside the while condition to copy bytes from a source string to a destination and stops when the terminating null is copied. The example also prints the destination after each successful character copy. To avoid undefined behavior, we explicitly assume str1 has enough storage for the entire copy (for example, char str1[20] = "India"). Given Data / Assumptions: str2 = "CURIOUSTAB\0" (length 10). str1 has sufficient capacity (at least 11 bytes including the terminator). Loop condition: while (*s1++ = *s2++) copies a byte, then tests the assignment value; it stops when the null byte (0) is copied. Concept / Approach: At each iteration, one character from str2 overwrites the next position in str1. Initially str1 contains "India"; after 10 character copies and the final null byte, str1 holds an exact copy of str2. The prints inside the loop show intermediate states, but the question asks for the final content of str1, which equals the source string. Step-by-Step Solution: Start: str1 = "India", str2 = "CURIOUSTAB".Copy C → str1 begins “Cndia…”.Copy progresses: after all characters, the former terminator in str1 is moved forward as the new characters extend the string.When the null from str2 is copied, the loop terminates; str1 is now “CURIOUSTAB”. Verification / Alternative check: Print str1 after the loop (outside the while). It shows “CURIOUSTAB”. The in-loop prints show transitional states but do not alter the final result. Why Other Options Are Wrong: India: This would be true only if no copying occurred.(null): printf of a null pointer, which we are not using here.Cndia: An intermediate state after copying only the first character, not the final state.The long mixed string: reflects misconceived concatenation of prints and is not the final stored value. Common Pitfalls: Forgetting to size the destination buffer to avoid overflow; misreading the assignment-in-condition idiom; confusing “console output during the loop” with the final string state in memory. Final Answer: CURIOUSTAB.

Question 12

Pointer arithmetic and 2D arrays in C (row-major layout): assuming the base address of a begins at 1002 and sizeof(int) = 4 bytes, what does the following print?  #include<stdio.h>  int main() {  int a[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12…

Accepted Answer

Introduction / Context: Understanding how C lays out multidimensional arrays (row-major order) and how pointers relate to array elements is essential for correct indexing and pointer arithmetic. This example asks you to compute both an address and two dereferenced values when given a base address and sizeof(int). Given Data / Assumptions: Array a is 3 rows by 4 columns: a[0][0]=1, a[0][1]=2, a[0][2]=3, a[0][3]=4, … Base address of a is 1002 (bytes). sizeof(int) = 4 bytes. Row-major layout: consecutive elements in a row are adjacent in memory. Concept / Approach: a[0] has type int and points to a[0][0]. Adding 1 to a[0] advances the pointer by one int, i.e., +4 bytes. Dereferencing (a[0]+1) reads a[0][1]. The expression ((a+0)+1) is the same as a[0][1]. Step-by-Step Solution: Address: a[0] → 1002; a[0] + 1 → 1002 + 1sizeof(int) = 1002 + 4 = 1006.Value: *(a[0] + 1) → element a[0][1] → 2.Value: ((a + 0) + 1) → a[0][1] again → 2. Verification / Alternative check: Index equivalence: a[i][j] equals ((a+i)+j). With i=0, j=1 we get the same element both ways. Why Other Options Are Wrong: 448, 4, 4 or 520, 2, 2: Addresses do not match the given base and sizeof(int).Error: The expressions are valid and well-typed.1002, 1, 1: That would correspond to a[0] not a[0]+1, and to element [0][0], not [0][1]. Common Pitfalls: Adding 1 to a pointer moves it by sizeof(element), not 1 byte; confusing addresses with values; forgetting row-major ordering. Final Answer: 1006, 2, 2.

Question 13

In C (pointer decay with multidimensional arrays), what will this print if the array 'a' begins at address 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} };  pri…

Accepted Answer

Introduction / Context: This question checks your understanding of how multidimensional arrays decay to pointers in C, what a, *a, and **a mean for a 3-D array, and how dereferencing down to **a yields the first stored integer. The addresses are based on a provided base location (1002). Given Data / Assumptions: The array has type int a[2][3][4] and begins at address 1002. printf uses %u for printing pointer values (strictly, standard requires %p, but we follow the problem’s convention). Array-to-pointer decay applies when array expressions appear in function calls. Concept / Approach: For int a[2][3][4], the identifiers behave as follows: a → pointer to first element, type int ()[3][4], value &a[0]a → the first element, type int [3][4]; when passed to printf, it decays to &a[0][0] (type int ()[4])*a → the first row inside that, type int [4]; it decays to &a[0][0][0] (type int)***a → the first scalar int value stored, which is 1 from the initializerAll three pointers point to the same starting address of the entire object’s first scalar element. Step-by-Step Solution: a → &a[0] → address 1002*a → a[0] → decays to &a[0][0] → address 1002**a → a[0][0] → decays to &a[0][0][0] → address 1002***a → a[0][0][0] → integer value 1 Verification / Alternative check: Manually expand indices: a == &a[0]*a == a[0] and &a[0][0] is where the first 4-int row begins**a == a[0][0] and &a[0][0][0] is the first scalar Why Other Options Are Wrong: (a) and (b) assume incorrect scaling to different addresses; all three decayed pointers start at the same base. (d) No compile-time error for this code. (e) The problem pins the base address; under those assumptions, the triplet is not variable. Common Pitfalls: Confusing types of a, *a, and **a; assuming each must advance to a different address; or thinking ***a is a pointer rather than a scalar. Final Answer: 1002, 1002, 1002, 1

Question 14

In C strings and pointers, what does this print (note: writing to a string literal is undefined; assume it succeeds for this exercise)? #include #include int main() { int i, n; char *x = "Alice"; n = strlen(x); *x = x[n]; f…

Accepted Answer

Introduction / Context: This problem explores pointer arithmetic on C strings and how %s prints from the first \0 encountered onward. It also contains a deliberate twist: writing to a string literal via *x = .... That write is undefined behavior in standard C and can crash; however, many textbook problems assume it “works” for demonstration purposes. We follow that intent here. Given Data / Assumptions: x initially points to the literal "Alice" (bytes: A l i c e \0). n = strlen(x) = 5; x[n] is the null terminator. The loop prints the current string and then increments the pointer. We assume the write succeeds and memory afterward remains readable. Concept / Approach: *x = x[n] sets the first byte to \0. Thus, at the original location, the string becomes empty. The remainder of the bytes still contain l i c e \0. Advancing the pointer by one then points to "lice", which prints fully; further increments produce suffixes. Step-by-Step Solution: Before assignment: [A][l][i][c][e][\0]After *x = x[n]: [\0][l][i][c][e][\0]i = 0 → prints "" (empty), pointer moves to li = 1 → prints "lice"i = 2 → prints "ice"i = 3 → prints "ce"i = 4 → prints "e"i = 5 → prints ""Ignoring the empty prints, the visible output is: lice ice ce e Verification / Alternative check: If char x[] = "Alice"; (array, not literal), the write is valid and the same visible output results. Why Other Options Are Wrong: (a) and (c) would require the first byte to remain 'A'. (b) is reversal, which this code does not do. (e) can happen in real systems but the exercise assumes otherwise. Common Pitfalls: Forgetting that %s prints until \0 and that pointer increments shift the starting point; overlooking undefined behavior of modifying string literals. Final Answer: lice ice ce e

Question 15

In C (pointers to pointers), given 4-byte int, what does this print?  #include<stdio.h>  int main() {  int ***r, **q, *p, i = 8;  p = &i;  q = &p;  r = &q;  printf("%d, %d, %d ", *p, **q, ***r);  return 0; }

Accepted Answer

Introduction / Context: The exercise ensures you can trace multiple levels of indirection. The pointers p, q, and r successively point to the location of i, the location of p, and the location of q. Dereferencing the correct number of times should always yield the integer value stored in i. Given Data / Assumptions: i = 8 p = &i → *p reads i q = &p → **q reads *(&i) → i r = &q → ***r reads **(&p) → i Concept / Approach: At each level, dereference once to move toward the underlying object. The star count must match the pointer depth: one star for p, two for q, three for r. All evaluate to the same stored scalar. Step-by-Step Solution: *p = i = 8**q = ((&i)) = *(&i) = i = 8**r = **((&p)) = **(&p) = *p = i = 8 Verification / Alternative check: Temporarily print addresses to confirm the chain: &i == p&p == q&q == r and match the dereference counts. Why Other Options Are Wrong: (b)–(d) list pretend addresses instead of values. The code prints integers obtained by dereferencing, not addresses. Common Pitfalls: Confusing the number of dereferences; printing pointers rather than values; assuming pointer size affects the printed values here. Final Answer: 8, 8, 8

Question 16

In C pointer arithmetic with post-increment on pointers, assume &x = 500 and sizeof(int) = 4 bytes. What prints?  #include<stdio.h>  int main() {  int x = 30, *y, z;  y = &x; / &x is 500 */  z = y;  *y++ = *z++;  x++;  printf("x=%d, y=%d, z=%d ", x,…

Accepted Answer

Introduction / Context: This evaluates post-increment on pointers combined with dereferencing and assignment. It also highlights that printing pointers with %d is nonportable, but within this exercise we treat them as integer addresses to show arithmetic on int *. Given Data / Assumptions: &x is 500 (artificial base for demonstration). sizeof(int) = 4 bytes. Both pointers y and z are initially &x. Expression *y++ = z++; means (y++) = *(z++). Concept / Approach: Post-increment returns the original pointer for the dereference, then increments the pointer by one element. Thus the assignment copies the current value at &x to itself and then both pointers advance to point past x by 4 bytes (since they are int *). Step-by-Step Solution: Initial: x = 30; y = z = 500.*y++ = *z++ → reads *(500) = 30 and stores to *(500) = 30 (no change to x); then y = z = 504.x++ → x becomes 31.printf prints x and the new pointer values: x=31, y=504, z=504. Verification / Alternative check: Rewrite with temporaries: *y = *z; y = y + 1; z = z + 1; where pointer increments add sizeof(int). Why Other Options Are Wrong: (a) uses +2 which is not correct for 4-byte ints. (b) keeps pointers at 500 despite post-increment. (c) subtracts; not applicable. (e) adds +8 as if two increments or larger element size had occurred. Common Pitfalls: Parsing *y++ as (*y)++ (it is not); forgetting that pointer arithmetic scales by element size. Final Answer: x=31, y=504, z=504

Question 17

In C, casting addresses through void* inside a function: what is printed?  #include<stdio.h>  void fun(void *p); int i;  int main() {  void vptr;  vptr = &i; / global i zero-initialized /  fun(vptr);  return 0; } void fun(void p) {  int q;  q = (int…

Accepted Answer

Introduction / Context: This question illustrates how a function parameter of type void * can be reinterpreted by taking its own address and recasting that to int *. It is a contrived but educational example of pointer aliasing and object representation. A global int i is zero-initialized by default. Given Data / Assumptions: i is a global int → default-initialized to 0. main passes vptr = &i into fun as a void . Inside fun, p is a local copy of that pointer value. q = (int)&p; means “treat the address of local p as if it were an int **”, so *q sees the bit pattern of p as an int *. Concept / Approach: *q reads the stored pointer value (which is &i), and q dereferences it to the integer i, which is 0. Although this style is unsafe and nonportable regarding strict aliasing and alignment, the intent is to show that the pointer value can be recovered. Step-by-Step Solution: main: vptr = &ifun: p holds &iq = (int)&pq interprets bytes of p as int → value &i**q → *(&i) → i → 0 Verification / Alternative check: If you instead write printf("%d", (int)p); you also get 0 and avoid the contortion. Why Other Options Are Wrong: (a) Compiles in C with an explicit cast. (b) and (e) suggest randomness; the flow deterministically reads i. (d) The program prints one line with 0. Common Pitfalls: Assuming parameters are passed by reference; misunderstanding that p is a local copy of a pointer value; confusing type-punning with undefined behavior across incompatible representations. Final Answer: 0

Question 18

In C, mixing char* and int* and unaligned reads: what prints?  #include<stdio.h>  int main() {  int arr[3] = {2, 3, 4};  char p;  p = (char)arr;  p = (char*)((int*)(p));  printf("%d, ", p);  p = (int)(p + 1);  printf("%d", p);  return 0; }

Accepted Answer

Introduction / Context: This question tests your understanding of pointer casts between char and int*, byte-level access, alignment, and the consequences of reading an int from a non–int-aligned address. Many platforms allow the code to compile but may yield implementation-defined or undefined results at runtime when misaligned. Given Data / Assumptions: arr = {2, 3, 4} p is a char* pointing to the first byte of arr. Ordinary little-endian assumptions explain why the first byte of the first int is 2. The code later forms an int* from p + 1, which is typically misaligned. Concept / Approach: p reads the very first byte of the array’s memory, which for the integer 2 on little-endian is 0x02 → prints 2. Then p = (int)(p + 1) creates an int* at the following byte boundary. Dereferencing *p reads four bytes starting at a nonaligned address, yielding a “garbage” integer (and possibly a bus error on strict-alignment systems). Step-by-Step Solution: Initial: p points to arr as bytes.Print p → 2.Advance by 1 byte and cast to int → potential misalignment.Print *p → implementation-defined “garbage” value. Verification / Alternative check: On a platform that traps misaligned access, the program may fault. On tolerant CPUs, the value varies by endianness and representation. Why Other Options Are Wrong: (a) assumes a clean aligned int read. (b) suggests a forced zero which is unlikely. (d) prints zeros without basis. Common Pitfalls: Forgetting alignment rules; assuming bytes map to integers uniformly across architectures. Final Answer: 2, Garbage value

Question 19

In C, using sizeof with arrays and elements (int is 4 bytes): what is printed?  #include<stdio.h>  int main() {  int arr[] = {12, 13, 14, 15, 16};  printf("%d, %d, %d ", sizeof(arr), sizeof(*arr), sizeof(arr[0]));  return 0; }

Accepted Answer

Introduction / Context: This measures your knowledge of sizeof behavior with arrays versus elements in C. Unlike a pointer to the first element, an array expression used directly with sizeof does not decay; it yields the full storage size of the entire array object. Given Data / Assumptions: int is 4 bytes. arr contains 5 integers: {12, 13, 14, 15, 16}. We compute three sizeof values: the whole array, the first dereferenced element, and arr[0]. Concept / Approach: sizeof(arr) = number_of_elements * sizeof(int) = 5 * 4 = 20sizeof(*arr) = sizeof(int) = 4sizeof(arr[0]) = sizeof(int) = 4Because sizeof is an operator evaluated at compile time (no decay for arr here), it returns the full byte size of the array object. Step-by-Step Solution: Compute each term using int = 4 bytes.Format and print: 20, 4, 4. Verification / Alternative check: Replace arr with a pointer variable; then sizeof(ptr) would return the pointer size, not the array size. This highlights why sizeof on arrays is special. Why Other Options Are Wrong: (a), (c), (d) use 2-byte ints or wrong counts. (e) assumes 6 elements or different size. Common Pitfalls: Confusing arrays with pointers; assuming sizeof(arr) yields pointer size; forgetting that sizeof is compile-time for known objects. Final Answer: 20, 4, 4

Question 20

In C, address-of and dereference cancellation with a char pointer: what is printed?  #include<stdio.h>  int main() {  char p;  p = "hello";  printf("%s ", &&p);  return 0; }

Accepted Answer

Introduction / Context: This short puzzle shows that applying address-of (&) and dereference () operators in alternating fashion can cancel out, if they are applied in a type-consistent way. The format string %s expects a char* to a null-terminated string. Given Data / Assumptions: p points to the string literal "hello". The expression is &&p (equivalent to p). We print with printf("%s", ...). Concept / Approach: Reading right-to-left for unary operators: the innermost is &p (address of p), then (&p) which yields p, then &((&p)) which is &p again, and finally (&p) which returns p. So the entire expression is simply p, a char to the literal. Step-by-Step Solution: Evaluate &&p → pprintf receives p as a char*It prints the full null-terminated string: hello Verification / Alternative check: Replacing the expression with just p yields identical output. Why Other Options Are Wrong: (a), (c), and (d) suggest starting at later characters; nothing in the code increments the pointer. (e) There is no invalid access here; reading a string literal via %s is fine (modification would not be). Common Pitfalls: Assuming address-of and dereference operators always change the value; when paired correctly, they cancel out. Final Answer: hello

Pointers Questions