Question 1

What does the declaration char *arr[10]; signify in C? Explain the type and structure represented by arr in this declaration.

Accepted Answer

Introduction: C declarations can be read using precedence rules. This question probes your ability to parse a declaration that combines pointer and array syntax. Given Data / Assumptions: Declaration: char arr[10]; Standard C declarator binding rules apply. Concept / Approach: In declarators, [] binds tighter than . Therefore, arr is first an array of 10 elements, and each element has type pointer to char. Thus arr is an array (size 10) of char pointers. It is not a pointer to a single array, nor an array of chars, nor a function pointer. Step-by-Step Solution: 1) Parse inside-out: arr[10] → 'arr is an array of 10'.2) Then apply * to the element type: each element is 'pointer to char'.3) Result: arr is an array of 10 pointers to char. Verification / Alternative check: Consider typical usage: arr[i] = "hello"; Each arr[i] is of type char, pointing to the first character of a string literal or dynamically allocated buffer. Why Other Options Are Wrong: Array of function pointer: the element type would include '()()' for functions, which is not present.Array of characters: that would be char arr[10]; without a star.Pointer to array of characters: that would be char (*arr)[N]; with parentheses around *arr. Common Pitfalls: Misreading precedence or forgetting that [] binds more tightly than *. Parentheses are required to change binding if a pointer-to-array is intended. Final Answer: arr is a array of 10 character pointers.

Question 2

C declarations and pointers: interpret the following declaration int (*pf)(); What does it signify?

Accepted Answer

Introduction / Context: This question tests mastery of C declarator syntax for function pointers. Reading complex declarations correctly is essential when using callbacks, library hooks, signal handlers, and tables of operations. The declaration style can look cryptic at first, but a small set of rules lets you decode it reliably. Given Data / Assumptions: Declaration under analysis: int (*pf)(); No parameters are specified inside the parentheses, which in classic C implies an unspecified parameter list. Goal: determine exactly what pf represents. Concept / Approach: Use the clockwise spiral rule or a simple precedence rule: identifiers bind first to the closest parentheses, postfix operators like () and [] have higher precedence than unary *. In int (*pf)(); the inner parentheses force *pf to bind before (), producing a pointer-to-function rather than a function returning a pointer. The base type to the left is int, meaning the function's return type is int. Step-by-Step Solution: 1) Start at the identifier pf. 2) The nearest binding is (*pf), so pf is being dereferenced: pf is a pointer to something. 3) Next, () applies to (*pf), so that “something” is a function. 4) The type at the far left, int, is the function's return type. 5) Therefore, pf is a pointer to a function returning int. Verification / Alternative check: Compare with int *pf(); which declares a function named pf that returns int* (function returning pointer). The absence or presence of parentheses around *pf is decisive. You can also create a typedef: typedef int func_t(); then func_t *pf; makes the same meaning obvious. Why Other Options Are Wrong: pf is a pointer to function. This is incomplete because it omits the return type, which is int; the precise statement includes “return int”. pf is a function pointer. Too generic. While true in spirit, the best answer must state the return type. pf is a function of pointer variable. Nonsensical phrasing; the syntax does not declare a function of a pointer. Common Pitfalls: Confusing int (*pf)() with int *pf(). The former is a pointer to function returning int; the latter is a function returning pointer to int. Assuming empty parameter lists mean “no parameters”. In modern C, prefer using (void) to indicate no parameters explicitly. Final Answer: pf is a pointer to a function which return int

Question 3

C declarations: write a declaration for "An array of three pointers to chars" Choose the correct C syntax that matches the English statement.

Accepted Answer

Introduction / Context: Translating English descriptions into precise C declarations is a core skill for systems programming. The target phrase “an array of three pointers to chars” involves both array and pointer declarators, and it is easy to overcomplicate the syntax by adding function parentheses or extra indirection. Given Data / Assumptions: We want exactly 3 elements. Each element must be a pointer to char, that is, type char*. No functions are involved, no extra levels of pointers beyond one. Concept / Approach: Build from the inside out. The element type is “pointer to char”, written as char*. An array of 3 such elements is written by attaching [3] to the identifier: char *ptr[3]; Parentheses are not needed around the * for this simple case. Adding () would convert it into “array of pointers to functions”, which is not requested. Step-by-Step Solution: 1) Decide the element type: pointer to char ⇒ char*. 2) Make an array of 3 such elements ⇒ char *ptr[3]; 3) Confirm that ptr[i] has type char* for i in {0,1,2}. 4) No function declarators are present, so no call syntax appears. Verification / Alternative check: Use sizeof to confirm: sizeof(ptr) equals 3 * sizeof(char*). The expression *ptr[i] then has type char, confirming that each element is a pointer to char, not a function or a pointer to pointer. Why Other Options Are Wrong: char *ptr[3](); Declares an array of 3 functions returning char*, which is illegal because arrays of functions are not allowed; with some compilers it is read as array of 3 pointers to functions returning char* due to decay, which still does not match. char (*ptr[3])(); Explicitly an array of 3 pointers to functions, not pointers to char. char **ptr[3]; An array of 3 pointers to pointer to char (char**), which is one extra level of indirection. Common Pitfalls: Adding function parentheses by habit, creating function pointer declarations unintentionally. Confusing char* (pointer to char) with char** (pointer to pointer to char). Final Answer: char *ptr[3];

Question 4

C declarations: interpret the following declaration int *f(); What exactly does it mean?

Accepted Answer

Introduction / Context: Distinguishing “function returning pointer” from “pointer to function” is a frequent stumbling block in C. The position of parentheses relative to * and the identifier determines whether you declare a function or a pointer to a function. This question focuses on the declaration int *f(); Given Data / Assumptions: Declaration: int *f(); Empty parameter list means an unspecified list in old-style C. In modern code, prefer int *f(void) for no parameters. We must decide whether f itself is a pointer or a function. Concept / Approach: Operator precedence puts () on the identifier first. Because there are no parentheses around *f, the () applies to f, making f a function. The return type is int*, derived from the leading int *. Therefore, f is a function that, when called, returns a pointer to int. By contrast, a pointer to function returning int would look like int (*pf)(); Step-by-Step Solution: 1) Identify the identifier: f. 2) Postfix () binds to f, so f is a function. 3) The type to the left is int *, therefore the function's return type is pointer to int. 4) Conclude: f is a function returning pointer to int. Verification / Alternative check: Introduce a typedef for clarity: typedef int* pint; then pint f(); reads more naturally as “f returns pint”, confirming the interpretation. Another check is to compare with int (*f)(); which would be a pointer to a function returning int, clearly different. Why Other Options Are Wrong: Pointer variable of function type: Functions are not objects; you cannot have “pointer variable of function type” as phrased. The declaration does not make f a pointer variable at all. Function pointer: That would require parentheses around *f: int (*f)(); Simple declaration of pointer variable: A simple pointer variable would be int *p; with no (). Common Pitfalls: Forgetting that () binds tighter than *, making f a function here. Assuming empty parameter lists mean “no parameters” in all C dialects; use (void) in modern C when you mean no parameters. Final Answer: f is a function returning pointer to an int.

Question 5

C declarations: write a declaration for "A pointer to a function which receives an int pointer and returns a float pointer"

Accepted Answer

Introduction / Context: This problem assesses your ability to translate precise English descriptions into correct C declarations. Function pointer syntax in C can be tricky because parentheses affect binding order between the pointer declarator * and the function-call operator (). The goal is to declare a pointer to a function that accepts an int pointer as its sole parameter and returns a float pointer (that is, float). Given Data / Assumptions: We need a pointer to a function. That function's parameter type is int* (pointer to int). That function's return type is float* (pointer to float). No other qualifiers or calling conventions are involved. Concept / Approach: The pattern for a pointer to function is: return_type (*identifier)(parameter_types). Because we want a pointer to function, the * must be parenthesized with the identifier to ensure it binds before the function-call operator (). Then we place the function's parameter list inside the parentheses and put the intended return type to the left of the entire construct. Finally, we specify that the single parameter is a pointer to int (int*), and the function returns float*. Step-by-Step Solution: 1) Start with the function's return type: float*. 2) Make a pointer to a function identifier: (*ptr). 3) Add the parameter list receiving an int pointer: (int*). 4) Combine: float *(*ptr)(int*). 5) Read aloud: ptr is a pointer to a function taking int* and returning float*. Verification / Alternative check: Introduce typedefs to simplify reading: typedef float* f_ret_t; typedef f_ret_t func_t(int*); then func_t *ptr; matches float *(*ptr)(int*). Compilers accept both forms equivalently, and typeof or IDE hover info typically confirms the signature. Why Other Options Are Wrong: float *(ptr)*int; — Invalid syntax and not a function pointer declaration. float *(*ptr)(int) — Parameter is int, not int*, so the parameter type is wrong. float (*ptr)(int) — Returns float, not float*; return type is wrong. Common Pitfalls: Forgetting parentheses around *ptr, which changes the meaning to “function returning pointer” instead of “pointer to function”. Confusing int with int* in the parameter list, which subtly changes the signature. Misreading operator precedence between * and (). Final Answer: float *(*ptr)(int*)

Question 6

C declarations: interpret the following declaration char **argv;

Accepted Answer

Introduction / Context: Understanding multi-level pointers is essential in C, especially for command-line arguments and arrays of strings. The identifier argv is widely used in main's formal parameter list as char *argv, representing an array of C strings where each element is a char and the array itself is addressed via a pointer to pointer to char. Given Data / Assumptions: Declaration under analysis: char **argv; We are interpreting only the type, not storage duration or qualifiers. A typical use case is main(int argc, char **argv). Concept / Approach: char* means “pointer to char”. Adding another * yields char** which means “pointer to pointer to char”. This is commonly used for an array-of-pointers representation of strings, where argv points to the first element of an array of char* values, each of which points to the first character of a NUL-terminated string. Step-by-Step Solution: 1) Recognize ** as two levels of indirection. 2) The outer pointer refers to an element of type char*. 3) Each char* then points to a sequence of char ending with '\0'. 4) Therefore argv is “pointer to a char pointer”. Verification / Alternative check: Indexing argv like argv[i] produces type char*, and dereferencing once *argv[i] yields char, consistent with a list of strings. This aligns with the standard practice of treating argv as an array of pointers to C strings. Why Other Options Are Wrong: Pointer to pointer — Too vague; it does not specify the base type char. Function pointer — No function declarator () is present. Member of function pointer — Nonsensical in C terminology. Common Pitfalls: Assuming char** is interchangeable with char*[]. They are related through array-to-pointer decay but not identical types in all contexts. Forgetting to allocate and terminate the array of pointers when constructing argv-like structures. Final Answer: argv is a pointer to a char pointer.

Question 7

C declarations: write a declaration for "A pointer to a function which receives nothing and returns nothing"

Accepted Answer

Introduction / Context: This item checks whether you can construct a function pointer type for a procedure that takes no arguments and returns no value. In modern C, an explicit (void) parameter list indicates no parameters; older code sometimes uses empty parentheses, which historically meant an unspecified parameter list. Both styles appear in real code and documentation. Given Data / Assumptions: Pointer to a function is required. The function returns nothing (void). The function takes no parameters. No qualifiers or calling conventions are specified. Concept / Approach: The scheme for function pointers is return_type (*identifier)(parameters). We therefore place the pointer declarator around the identifier with parentheses, and supply the parameter list. Using an empty list () is commonly seen; the most explicit modern form is (void) to declare no parameters. Thus, void (*ptr)() is acceptable, and void (*ptr)(void) is even clearer where supported by your coding standard. Step-by-Step Solution: 1) Choose return type: void. 2) Make a pointer to a function: (*ptr). 3) Provide parameter list: () or (void). 4) Final form: void (*ptr)(). Verification / Alternative check: With typedefs: typedef void proc_t(void); then proc_t *ptr; has the same meaning as void (*ptr)(void). Practical tests, like assigning ptr = &some_function; and invoking (*ptr)(); confirm correct behavior. Why Other Options Are Wrong: void *(ptr)*int; — Invalid grammar; mixes pointer declarators and parameters incorrectly. void *(*ptr)() — Declares a function pointer returning void*, not void. void *(*ptr)(*) — Not valid C syntax; parameter list cannot be a bare *. Common Pitfalls: Omitting parentheses around *ptr, which changes the declaration's meaning. Confusing returning void with returning void*; these are completely different types. Final Answer: void (*ptr)()

Question 8

C declarations: interpret the following declaration char *scr;

Accepted Answer

Introduction / Context: This item tests basic pointer declarations in C. The expression char *name; is one of the most common idioms and denotes a pointer that can reference a character or the first element of a character array representing a C string. Given Data / Assumptions: Declaration under analysis: char *scr; No qualifiers (const, volatile) or storage specifiers are present. We are only classifying the type, not its initialization or lifetime. Concept / Approach: In C, the * binds to the identifier as part of the declarator, so char *scr; defines scr as “pointer to char”. This pointer can hold the address of a single char object or the first element of a char buffer that is terminated with '\0' to represent a string. The declaration does not allocate storage for characters; it only allocates space for the pointer itself. Step-by-Step Solution: 1) Identify base type: char. 2) Apply pointer declarator * to the identifier: *scr. 3) Conclude scr has type char* (pointer to char). 4) Usage typically involves assignment from &ch or from a string literal to a const-qualified pointer when appropriate. Verification / Alternative check: sizeof(scr) equals the size of a pointer on the platform, not the size of a character buffer. Dereferencing *scr yields type char, which confirms the one-level indirection. Why Other Options Are Wrong: Pointer to pointer — Would require char **scr. Function pointer — No function declarator () exists. Member of function pointer — Not meaningful terminology in C type system. Common Pitfalls: Assuming char *scr allocates storage for a full string; it does not allocate the characters themselves. Forgetting const when pointing to string literals to avoid modifying read-only storage. Final Answer: scr is a pointer to char.

Question 9

C declarations: interpret the following declaration void *cmp();

Accepted Answer

Introduction / Context: Distinguishing between “function returning pointer” and “pointer to function” is central to reading C declarations. Here, void *cmp(); uses the function declarator directly on the identifier, with a pointer type as the function's return type. This pattern is common for factory functions that return untyped memory or opaque handles. Given Data / Assumptions: Declaration: void *cmp(); Return type: void* (pointer to void). Parameter list is unspecified in the old-style form; modern code would prefer void *cmp(void). Concept / Approach: Because () applies to the identifier cmp (no parentheses around *cmp), cmp is a function, not a pointer variable. The leading void* indicates that the function returns a pointer to void. Therefore the accurate English reading is “cmp is a function that returns a void pointer”. Step-by-Step Solution: 1) Identify postfix operator: () binds to cmp, so cmp is a function. 2) Inspect the type on the left: void*. 3) Conclude the function's return type is pointer to void. 4) Optionally specify parameters as (void) in modern declarations to mean no parameters. Verification / Alternative check: Compare against a pointer-to-function form: void (*cmp)(); would be a pointer to a function returning void, which is different. Typedefs can help: typedef void* anyptr; anyptr cmp(void); reads clearly and confirms the meaning. Why Other Options Are Wrong: Pointer to a void type — Incorrect; that would be void *p; and not a function declaration. Void type pointer variable — Misstates the form; cmp is declared as a function, not a variable. Returns nothing — That would be return type void, not void*. Common Pitfalls: Confusing void (no value returned) with void* (pointer return). Assuming empty parameter lists always mean no parameters; in modern C use (void) to be explicit. Final Answer: cmp is a function that return a void pointer.

Question 10

C declarations: write a declaration for "A pointer to an array of three chars"

Accepted Answer

Introduction / Context: This problem evaluates whether you can distinguish between “array of pointers” and “pointer to array” in C declarations. Arrays and pointers interact through decay in expressions, but their types are not interchangeable in declarations, and parentheses are essential to convey the correct binding. Given Data / Assumptions: We need a pointer to an array. The array has exactly 3 elements. Each element is of type char. Concept / Approach: The array type is “array of 3 char”, written char[3]. A pointer to that array type is written by putting parentheses around the identifier with the pointer declarator, yielding char (*ptr)[3]. The parentheses ensure that *ptr is evaluated before applying [3], so ptr is a pointer to a single array object of length 3, rather than an array of pointers or anything involving functions. Step-by-Step Solution: 1) Start from the target object: an array of 3 char ⇒ char[3]. 2) Take a pointer to that array type ⇒ (*ptr) and then apply [3] to the type, not the variable. 3) Final form: char (*ptr)[3]. 4) Reading: ptr is a pointer to an array of three char. Verification / Alternative check: sizeof(*ptr) equals 3 * sizeof(char). Indexing (*ptr)[i] is valid for i in {0,1,2}. By contrast, char *ptr[3] declares an array of 3 pointers to char, which is a different type and storage layout entirely. Why Other Options Are Wrong: char *ptr[3]() — Introduces function declarators and describes an array of functions or function pointers, which is not required. char (*ptr)*[3] — Invalid placement of declarators; not legal syntax. char (*ptr[3])() — Declares an array of 3 pointers to functions, not a pointer to an array. Common Pitfalls: Omitting parentheses around *ptr and accidentally declaring an array of pointers. Assuming pointer-to-array and array-of-pointers are interchangeable; they are not, and pointer arithmetic differs. Final Answer: char (*ptr)[3];

Question 11

C declarations: interpret the following declaration void (*cmp)();

Accepted Answer

Introduction / Context: This item checks your ability to recognize a function pointer type in C. The parentheses around *cmp are the telltale sign that cmp is not a function itself but a pointer to a function. Such pointers are used for callbacks, signal handlers, and dispatch tables. Given Data / Assumptions: Declaration: void (*cmp)(); Return type of the function: void. Parameter list: unspecified in old-style C; modern code would prefer void (*cmp)(void). Concept / Approach: Reading with precedence: () applied to the declarator would make a function, but the parentheses force *cmp to bind before (), turning the whole into “pointer to function”. The type to the left, void, is the function's return type. There is no star on the return type, so it does not return a pointer; it returns nothing (void). Step-by-Step Solution: 1) Identify (*cmp): cmp is a pointer. 2) The trailing () indicates that the pointed-to target is a function. 3) The function's return type is void. 4) Therefore cmp is a pointer to a function returning void. Verification / Alternative check: Using a typedef: typedef void handler_t(void); handler_t *cmp; is equivalent and often clearer. Assign cmp = &some_handler; and invoke through (*cmp)(); to validate behavior in code. Why Other Options Are Wrong: Pointer to a void function type — Slightly awkward but closest in spirit; however, the best precise phrasing is “pointer to a function that returns void”. Void type pointer function — Not meaningful; functions are not “pointer functions”. Function that returns a void pointer — Would be void* f(); not this declaration. Common Pitfalls: Forgetting parentheses around *cmp and accidentally declaring a function returning a pointer instead of a pointer to function. Assuming empty parameter lists always mean no parameters; prefer (void) for clarity in modern C. Final Answer: cmp is a pointer to a function which returns void .

Question 12

In C/C++, how should we interpret the declaration: int ptr[30]; Explain precisely what ptr represents in terms of arrays and pointers.

Accepted Answer

Introduction: Parsing mixed pointer–array declarations in C/C++ requires understanding declarator precedence. This question tests whether you can correctly interpret what the identifier represents when both * and [] appear in the declaration. Given Data / Assumptions: Declaration under analysis: int ptr[30]; Language rules: standard C/C++ declarator binding (array brackets bind tighter than the asterisk). No typedefs or parentheses altering precedence. Concept / Approach: In declarations, [] has higher binding precedence than . Therefore ptr[30] is considered first (an array of 30 elements). Each element has the remaining type * to int, i.e., pointer to int. So ptr is an array with 30 elements, and each element is an int. Step-by-Step Solution: 1) Start from the identifier: ptr.2) Apply closest binding operator: [] → ptr[30] means “ptr is an array of 30”.3) Apply the remaining * to the element type: each element is a pointer to int (int).4) Final interpretation: ptr is an array (size 30) of pointers to int. Verification / Alternative check: Typical usage like ptr[i] = &someInt; compiles because ptr[i] has type int and can store the address of an int. Declaring a pointer to an array would require parentheses: int (*p)[30]; Why Other Options Are Wrong: Pointer to an array of 30 integer pointers: that would be int **(*p)[30]; with different grouping.Array of 30 integer pointers: this is semantically the same as the correct option, but wording should clearly state “pointers to integers.”Array 30 pointers: grammatically incomplete and type-unspecified. Common Pitfalls: Forgetting that [] binds tighter than * leads many to read it as “pointer to array” rather than “array of pointers.” Always add parentheses if you intend pointer-to-array semantics. Final Answer: ptr is an array of 30 pointers to integers.

Question 13

What will be the output of the program in Turbo C? #include<stdio.h>  int main() {     char near *near *ptr1;     char near *far *ptr2;     char near *huge *ptr3;     printf("%d, %d, %d ", sizeof(ptr1), sizeof(ptr2), sizeof(ptr3));     return 0; }

Accepted Answer

2, 4, 4

Question 14

What will be the output of the program? #include<stdio.h>  int main() {     char huge *near *ptr1;     char huge *far *ptr2;     char huge *huge *ptr3;     printf("%d, %d, %d ", sizeof(ptr1), sizeof(ptr2), sizeof(ptr3));     return 0; }

Accepted Answer

2, 4, 4

Question 15

What will be the output of the program (in Turbo C under DOS)? #include<stdio.h>  int main() {     char huge *near *far *ptr1;     char near *far *huge *ptr2;     char far *huge *near *ptr3;     printf("%d, %d, %d ", sizeof(ptr1), sizeof(ptr2), size…

Accepted Answer

4, 4, 2

Question 16

What will be the output of the program under DOS? #include<stdio.h>  int main() {     char huge *near *far *ptr1;     char near *far *huge *ptr2;     char far *huge *near *ptr3;     printf("%d, %d, %d ", sizeof(ptr1), sizeof(**ptr2), sizeof(ptr3)); …

Accepted Answer

4, 2, 2

Question 17

What will be the output of the program? #include<stdio.h>  int main() {     char far *near *ptr1;     char far *far *ptr2;     char far *huge *ptr3;     printf("%d, %d, %d ", sizeof(ptr1), sizeof(ptr2), sizeof(ptr3));     return 0; }

Accepted Answer

2, 4, 4

Question 18

What will be the output of the program? #include<stdio.h>  int main() {     char huge *near *far *ptr1;     char near *far *huge *ptr2;     char far *huge *near *ptr3;     printf("%d, %d, %d ", sizeof(ptr1), sizeof(*ptr2), sizeof(**ptr3));  …

Accepted Answer

4, 4, 4

Question 19

What will be the output of the program? #include<stdio.h> typedef void v; typedef int i;  int main() {     v fun(i, i);     fun(2, 3);     return 0; } v fun(i a, i b) {     i s=2;     float i;     printf("%d,", sizeof(i));     printf(…

Accepted Answer

4, 12

Question 20

What will be the output of the program? #include<stdio.h> typedef unsigned long int uli; typedef uli u;  int main() {     uli a;     u b = -1;     a = -1;     printf("%lu, %lu", a, b);     return 0; }

Accepted Answer

The system will treat the negative numbers with 2's complement method. For 'long int' system will occupy 4 bytes (32 bits). Therefore, Binary 1 : 00000000 00000000 00000000 00000001 To represent -1, system uses the 2's complement value of 1. Add 1 to the 1's complement result to obtain 2's complement of 1. So, First take 1's complement of binary 1 (change all 0s to 1s and all 1s to 0s) 1's complement of Binary 1: 11111111 11111111 11111111 11111110 2's complement of Binary 1: (Add 1 with the above result) 11111111 11111111 11111111 11111111 In HexaDecimal 11111111 11111111 11111111 11111111 = FFFF FFFF FFFF FFFF In Unsigned Integer 11111111 11111111 11111111 11111111 = 4294967295.

Complicated Declarations Questions