Question 1

Partial structure initialization in C: unnamed members default to zero. What does this print?  #include<stdio.h> int main() { struct emp { char name[20]; int age; float sal; }; struct emp e = {"Tiger"}; // only name given; others default-initialized…

Accepted Answer

Introduction / Context:Structures in C can be partially initialized with aggregate initializers. Understanding what happens to unspecified members avoids undefined behavior and misinterpretation of output.Given Data / Assumptions:A struct has three members: char name[20]; int age; float sal;Initializer provides only the first member: {"Tiger"}.Printing the numeric members age and sal.Concept / Approach:In an aggregate initializer, any members not explicitly initialized are initialized as if by zero. This rule applies regardless of storage duration when an initializer is present. Therefore, age becomes 0 and sal becomes 0.0.Step-by-Step Solution:Assign name = "Tiger".Omitted members age and sal → set to 0 and 0.0 respectively.Print “0, 0.000000”.Verification / Alternative check:Explicitly writing struct emp e = {"Tiger", 0, 0.0f}; yields identical behavior; both are well-defined.Why Other Options Are Wrong:B: Not garbage—there is an initializer. C: No syntax error. D/E: The behavior is specified by the C standard and is not implementation dependent in this context.Common Pitfalls:Confusing uninitialized automatic structs (indeterminate) with partially initialized ones (rest zero). Forgetting the difference between designated and positional initializers.Final Answer:0, 0.000000

Question 2

In C programming, consider variable shadowing and block scope. What will be the output of the following program?  #include<stdio.h> int main() {  int X = 40;  {  int X = 20;  printf("%d ", X);  }  printf("%d ", X);  return 0; }  Choose the exact con…

Accepted Answer

Introduction / Context:This question tests your understanding of C block scope, variable shadowing, and how printf prints values from the innermost visible declaration. Many beginners confuse the two X variables and expect the same value printed twice. Recognizing scope boundaries is essential for writing maintainable, bug-free C code.Given Data / Assumptions:Two distinct variables both named X are declared: one in main and one in an inner block.Both variables are of type int and initialized (40 in outer scope, 20 in inner scope).The code compiles without errors; printf format strings are correct.Concept / Approach:In C, the innermost declaration of an identifier shadows any outer declarations of the same name within that inner block. Therefore, references to X inside the inner braces use the inner X. When the program exits the inner block, the inner X goes out of scope and any further references use the outer X.Step-by-Step Solution:Enter main: outer X = 40.Enter inner block: inner X = 20 shadows outer X.printf("%d ", X) inside inner block prints 20 followed by a space.Exit inner block: inner X is destroyed; outer X (40) becomes visible again.printf("%d", X) after the block prints 40 and a newline.Verification / Alternative check:Mental trace or debugger watch window will show two distinct storage locations for X. The first printf refers to the inner one (20), and the second refers to the outer one (40).Why Other Options Are Wrong:40 40: would imply no shadowing.20: misses the second print after the block.Compilation error: standard, valid C; no error.40 20: reverses the actual order of prints.Common Pitfalls:Forgetting that an inner declaration with the same name hides the outer variable; assuming updates to the inner X affect the outer X.Final Answer:20 40

Question 3

In C (assume a typical little-endian system), what is the output of this program using a union to overlay int and char[2]?  #include<stdio.h> int main() {  union a { int i; char ch[2]; };  union a u;  u.ch[0] = 3;  u.ch[1] = 2;  printf("%d, %d, %d "…

Accepted Answer

Introduction / Context:This problem evaluates understanding of C unions, memory overlay, and endianness. A union stores all members at the same location; writing one member and reading another reveals how bytes are arranged in memory. Most contemporary desktops use little-endian ordering, where the least significant byte is stored at the lowest address.Given Data / Assumptions:union a contains int i and char ch[2].Assignments: ch[0] = 3 and ch[1] = 2.Assume a little-endian machine and that sizeof(int) ≥ 2 bytes.Reading u.i after writing the char bytes reflects the combined two bytes.Concept / Approach:In little-endian layout, ch[0] holds the least significant byte and ch[1] the next byte. Thus the integer value becomes 2 * 256 + 3 = 512 + 3 = 515. The first two printed values are exactly the assigned chars: 3 and 2.Step-by-Step Solution:Write low byte: ch[0] = 3.Write next byte: ch[1] = 2.Construct int (little-endian): i = 2 * 256 + 3 = 515.printf prints: 3, 2, 515.Verification / Alternative check:Test on an actual little-endian compiler or compute by byte combination: i = (ch[1] Why Other Options Are Wrong:515, 2, 3: reorders outputs incorrectly.3, 2, 5: treats 2 and 3 as digits rather than bytes.None of these: incorrect because 3, 2, 515 is correct.2, 3, 515: swaps the first two printed values.Common Pitfalls:Confusing big-endian vs little-endian; assuming chars are signed and letting sign extension distort reasoning (irrelevant here as we read the full int built from bytes).Final Answer:3, 2, 515

Question 4

In C structures, which of the following declarations is incorrect (identify the invalid one and explain why)?  1) struct aa {  int a;  float b; };  2) struct aa {  int a;  float b;  struct aa var; // member is a complete object of the same type };  …

Accepted Answer

Introduction / Context:Self-referential structures enable linked lists and trees, but they must be written correctly. C permits pointers to an incomplete type within the same struct, but not a full instance of that same type as a member, because its size would be undefined (infinitely recursive).Given Data / Assumptions:Three candidate declarations of a struct named aa.Standard C rules for complete vs. incomplete types apply.We are checking syntactic and semantic validity, not usage.Concept / Approach:A struct type becomes complete at the closing brace of its definition. Inside the definition, the type is incomplete. C allows declaring pointers to an incomplete type (since pointer size is known) but not embedding a full object of that incomplete type (size unknown).Step-by-Step Solution:Case 1: Plain fields only (int, float) → valid.Case 2: Member is struct aa var; but struct aa is incomplete within its own definition → invalid due to infinite recursion of size.Case 3: Member is struct aa *var; pointer size is known → valid.Therefore, only declaration (2) is incorrect.Verification / Alternative check:Try compiling: (2) yields a diagnostic like “field has incomplete type,” whereas (3) compiles and is commonly used for linked structures.Why Other Options Are Wrong:1: Standard, correct struct.3: Correct self-referential pointer usage.1, 2, and 3 / 1 and 3: contradict the analysis.Common Pitfalls:Embedding the same struct type directly instead of a pointer; forgetting that mutual embedding of two structs also requires pointers or forward declarations.Final Answer:2

Question 5

C typedef and extern syntax: which line is correct?  1) typedef long a; extern int a c; 2) typedef long a; extern a int c; 3) typedef long a; extern a c;

Accepted Answer

Introduction / Context:This checks precision with C declarations. After introducing a typedef name, you must use it as a standalone type specifier. Mixing it with conflicting specifiers leads to invalid syntax or redeclaration errors.Given Data / Assumptions:The typedef name is a for long.Goal: declare an external variable named c using that typedef.We assume a single translation unit context; focus on syntax correctness.Concept / Approach:Once typedef long a; is processed, a is an alias for long and should be used by itself in place of long. A valid extern declaration using the alias is extern a c; which is equivalent to extern long c;. Combining a with another basic type keyword (like int) is invalid because a already denotes a complete type.Step-by-Step Solution:Line 1: extern int a c; → invalid: conflicts and malformed declarators.Line 2: extern a int c; → invalid: cannot combine typedef name a with int.Line 3: extern a c; → valid: equivalent to extern long c;.Therefore, only line 3 is correct.Verification / Alternative check:Compiling the three lines independently confirms that only the third form is accepted by a conforming compiler.Why Other Options Are Wrong:1 correct / 2 correct: both lines contain invalid combinations.All correct: contradicts compiler behavior.None are correct: false because line 3 is valid.Common Pitfalls:Forgetting that typedef names are type aliases, not modifiers; attempting to stack a with other base types; writing extern in a way that changes storage class rather than type.Final Answer:3 correct

Question 6

Standard C expressions: which of the following operations is incorrect (produces a compile-time error) in ISO C?

Accepted Answer

Introduction / Context:This question checks operator applicability across C types. The modulo operator % is defined only for integer operands. Using it with floating types is a common mistake that leads to compilation errors.Given Data / Assumptions:Plain ISO C (not using fmod from math.h).Each statement is independent and syntactically complete.Implicit conversions follow the usual arithmetic conversions.Concept / Approach:In C, % is the remainder operator for integer types only. For floating-point remainders, you must call the library function fmod or fmodf. Assignments to self (j = j; k = k;) are valid no-ops. Integer modulo and unsigned addition are also valid.Step-by-Step Solution:Check each operation's operand types.(a) int % int → valid.(b) self-assignment on short → valid though pointless.(c) self-assignment on long → valid.(d) float % int → invalid; % not defined for float. Use a = fmod(a, 3.0); instead.(e) unsigned arithmetic → valid.Verification / Alternative check:Try compiling (d): compilers report “invalid operands to binary %”. Replacing with fmod compiles and runs correctly.Why Other Options Are Wrong:(a), (b), (c), (e) are legal C statements; only (d) violates operator rules.Common Pitfalls:Assuming % behaves like mathematical modulo for real numbers; forgetting to include math.h and link with the math library when using fmod.Final Answer:float a = 3.14; a = a % 3;

Question 7

C structure syntax validation: which of the following structure definitions is correct as written?  1) struct book {  char name[10];  float price;  int pages; };  2) struct aa {  char name[10];  float price;  int pages; } // missing semicolon termin…

Accepted Answer

Introduction / Context:In C, every struct definition must end with a semicolon after the closing brace. This question tests attention to syntax details and the difference between a definition and a variable declaration that may follow it.Given Data / Assumptions:Three snippets claim to define a structure.No trailing variable declarations are present; only the definitions are considered.We evaluate exact syntax correctness.Concept / Approach:The grammar requires a semicolon after a struct or enum declaration list. Omitting it causes a compilation error. Only snippet (1) shows the required semicolon; snippets (2) and (3) omit it.Step-by-Step Solution:Inspect (1): has closing brace followed by semicolon → valid.Inspect (2) and (3): missing the terminating semicolon → invalid.Therefore, only option (1) is correct.Verification / Alternative check:Compiling (2) or (3) results in a diagnostic such as “expected ‘;’ after struct declaration.” Adding the semicolon fixes the error.Why Other Options Are Wrong:2, 3, and “All of the above” include definitions without the required semicolon.1 and 2: includes an invalid definition.Common Pitfalls:Forgetting the semicolon; confusing a struct definition with a variable declaration that might follow on the same line (e.g., struct T { ... } x;).Final Answer:1

Question 8

C declarations: which of the following declarations is syntactically correct and defines an object?

Accepted Answer

Introduction / Context:Correctly forming declarations is foundational in C. A declaration must present a valid type specifier sequence followed by one or more declarators (identifiers, possibly with pointers, arrays, or function forms).Given Data / Assumptions:We are judging syntax only, not storage duration or initialization.Each candidate is a standalone declaration.Concept / Approach:Valid type specifiers can be combined in restricted ways (e.g., long int is valid, but int long; without an identifier is incomplete). A declaration also requires an identifier unless it is a typedef or a function prototype. Here, only “int length;” supplies both a valid type and an identifier.Step-by-Step Solution:Option (a): type int and identifier length → valid object declaration.Option (b): “char int;” mixes two base types and lacks an identifier → invalid.Option (c): “int long;” reversed order without identifier; even “long int;” would still lack an identifier → invalid.Option (d): “float double;” two base types together, no identifier → invalid.Option (e): “long signed;” incompatible specifier sequence and no identifier → invalid.Verification / Alternative check:Compilers accept (a) but reject the others with messages about expected identifiers or invalid type specifiers.Why Other Options Are Wrong:They either combine incompatible base types or omit an identifier, violating declaration syntax.Common Pitfalls:Providing only a type without an identifier; mixing multiple base types that cannot appear together.Final Answer:int length;

Question 9

C literals: which option correctly represents a long double floating constant in standard C?

Accepted Answer

Introduction / Context:Floating constant suffixes control the type of a literal at compile time. Choosing the correct suffix helps avoid unintended promotions or loss of precision, especially when interfacing with math libraries and printf/scanf formats.Given Data / Assumptions:No unusual implementation-defined behavior; standard C suffix rules apply.Default unsuffixed floating constants are of type double.Concept / Approach:In C, the suffix f or F yields type float; the suffix l or L yields type long double. No valid combined suffix “LF” exists for literals. Therefore, a long double constant corresponding to 6.68 must be written as 6.68L.Step-by-Step Solution:Consider 6.68 → default type double.Consider 6.68f or 6.68F → type float.Consider 6.68L → type long double.6.68LF → invalid suffix combination.Verification / Alternative check:Compilers report an invalid suffix for “LF”. Printing with printf requires matching format specifiers; long double uses %Lf.Why Other Options Are Wrong:6.68: double, not long double.6.68f / 6.68F: float, not long double.6.68LF: not a valid literal form.Common Pitfalls:Assuming uppercase F implies long double; forgetting to use the corresponding format specifier when printing long double values.Final Answer:6.68L

Question 10

C linkage and scope: if a global (external) variable is defined earlier in the same source file, must a function still declare it with extern before using it?

Accepted Answer

Introduction / Context:This question probes understanding of C linkage and declaration requirements. Global variables have file scope and external linkage by default (unless declared static). If a definition appears before a use, the identifier is already known to subsequent code in that translation unit.Given Data / Assumptions:A single source file (translation unit) is considered.The global variable has been defined (not just declared) before the function that uses it.The variable is not declared static.Concept / Approach:In C, a definition of an external object at file scope also serves as a declaration that introduces the name and its type to the rest of the translation unit that follows. Therefore, no additional extern declaration inside a function is required to use it. The extern keyword is needed when referencing an object that is defined elsewhere (e.g., another file) or before its definition is visible.Step-by-Step Solution:Place the definition at file scope before functions: int g = 42;Later function uses g directly without redeclaring extern g; → valid.If g were defined in another file, then extern int g; would be needed in this file to declare it.Verification / Alternative check:Compilers accept use of a previously defined external variable without an additional extern. Moving the definition below the function and omitting a prior declaration will cause a diagnostic in modern C.Why Other Options Are Wrong:Does not apply: contradicts the rule that a prior definition suffices.Static: static changes linkage to internal; extern is irrelevant in that case.Order dependency: only matters if the definition comes after; our case has it before.Compiler-dependent: this is defined by the C standard, not implementation whim.Common Pitfalls:Confusing declarations with definitions; forgetting that extern inside a function does not define storage; assuming extern is always required.Final Answer:Applies (the statement is correct)

Question 11

C data model portability: does the size (number of bytes) of short int and long int vary across platforms and ABIs?

Accepted Answer

Introduction / Context:This question checks knowledge of the C data model and portability. Unlike types such as uint32_t from stdint.h, the fundamental integer types short and long have implementation-defined sizes subject to minimum ranges in the standard.Given Data / Assumptions:The C standard guarantees relative ordering: sizeof(char) ≤ sizeof(short) ≤ sizeof(int) ≤ sizeof(long) ≤ sizeof(long long).Minimum widths are specified, but exact byte sizes depend on the platform and ABI (e.g., ILP32, LP64, LLP64).Examples: many Unix-like 64-bit systems use LP64 (long = 8 bytes), while Windows 64-bit uses LLP64 (long = 4 bytes).Concept / Approach:The standard defines ranges, not fixed sizes. A short is at least 16 bits; a long is at least 32 bits and no smaller than an int. Therefore, both short and long can vary across compilers and architectures.Step-by-Step Solution:Identify data model: ILP32 (int, long, pointer are 32-bit), LP64 (long, pointer 64-bit), LLP64 (long long and pointer 64-bit; long 32-bit).Map consequences: short often 16 bits; long may be 32 or 64 bits.Conclude variability: neither short nor long has a universally fixed byte size.Verification / Alternative check:Printing sizeof(short) and sizeof(long) on different targets confirms differing values (e.g., 2/8 on LP64 vs 2/4 on LLP64).Why Other Options Are Wrong:Fixed by the standard: false; only minima and relations are fixed.Only long or only short varies: both can vary.Variation only on embedded: variation exists on desktops and servers too.Common Pitfalls:Coding with hard-coded sizes; failing to use stdint.h types when exact widths are required.Final Answer:Yes — sizes vary by platform and ABI

Question 12

C data types and ranges: evaluate the claim “Range of float is from -2.25e+308 to +2.25e+308.” Assume a typical C implementation targeting IEEE-754 formats unless explicitly stated otherwise.

Accepted Answer

Introduction / Context:In the C language, floating-point ranges depend on the underlying representation, which on most modern systems follows IEEE-754. Knowing the typical limits for float (single precision), double (double precision), and long double helps you choose the right type without overflow or underflow surprises. This question tests whether a quoted range matches the usual capacity of a float.Given Data / Assumptions:Typical C implementation using IEEE-754 formats.float is usually 32-bit single precision; double is usually 64-bit double precision.We evaluate the statement “float range is about ±2.25e+308”.Concept / Approach:IEEE-754 single precision (float) has approximately 7 decimal digits of precision and a maximum finite magnitude near 3.4e+38. IEEE-754 double precision (double) has roughly 15–16 digits and a maximum finite magnitude near 1.7e+308. Therefore, a bound as high as 2.25e+308 cannot describe float; it is closer to, but still not exactly, the double limit.Step-by-Step Solution:Identify target type in the claim: float.Recall typical float max magnitude: about 3.4e+38.Compare with claimed 2.25e+308: vastly larger, off by ~270 orders of magnitude.Conclude the statement does not match float; it resembles double's order of magnitude (about 1.7e+308), but even then the number 2.25e+308 is not the standard double limit.Verification / Alternative check:On a standard system, printing FLT_MAX and DBL_MAX from will show approximately 3.402823e+38 and 1.797693e+308, respectively, confirming the reasoning.Why Other Options Are Wrong:Correct: wrong because float cannot reach e+308.Depends only on the compiler optimizations: optimization has nothing to do with fundamental representation limits.True on 16-bit vs 32-bit: historical memory models do not turn float into e+308.Applies only to long double: some long double formats exceed double, but the claim explicitly names float.Common Pitfalls:Confusing float with double, or assuming all platforms use identical sizes while ignoring standard macros like FLT_MAX and DBL_MAX.Final Answer:Incorrect.

Question 13

C floating types: if the numeric range of double is insufficient for a real number, can long double be used to extend range or precision?

Accepted Answer

Introduction / Context:C offers multiple floating-point types: float, double, and long double. Developers often choose double for general numerical work. When extreme ranges or additional precision are required, long double may help. This question checks your practical understanding of when long double is appropriate.Given Data / Assumptions:A typical C implementation with float.h available.double is commonly IEEE-754 double precision.long double may equal double on some platforms, but may also be wider (80-bit extended, 128-bit quad, etc.).Concept / Approach:On many systems, long double uses a format with greater exponent range and/or precision (for example, 80-bit extended on x86 or 128-bit quadruple on some toolchains). Therefore, when a value exceeds the range of double or requires more precision, long double can be selected to mitigate overflow or reduce rounding error. However, portability requires checking the actual limits via LDBL_MAX and LDBL_DIG in .Step-by-Step Solution:Recognize the limitation: double cannot represent the desired magnitude/precision.Consult : compare DBL_MAX/DBL_DIG with LDBL_MAX/LDBL_DIG.If long double exceeds double on the target, choose long double to extend range/precision.If equal, consider arbitrary-precision libraries instead.Verification / Alternative check:Print DBL_MAX vs LDBL_MAX at runtime to confirm capacity; verify numerical results remain finite and precise under long double where double overflowed or lost precision.Why Other Options Are Wrong:Incorrect: dismisses legitimate platforms where long double is wider.Tying truth to -O3 or “only 16-bit DOS” is irrelevant; optimization levels do not change type ranges.“Never true”: demonstrably false on systems with 80-bit or 128-bit long double.Common Pitfalls:Assuming long double is always wider; on some ABIs it equals double. Always check float.h for portable code.Final Answer:Correct.

Question 14

Legacy C environment (16-bit Turbo C under DOS): the stated range “double is from -1.7e-38 to +1.7e+38” — evaluate this claim.

Accepted Answer

Introduction / Context:Historic 16-bit DOS compilers (such as Turbo C) used specific floating representations. Understanding which numeric limits belong to float, double, and long double avoids selecting the wrong type or misjudging overflow risk. The statement equates double with a range typical for float—this must be validated.Given Data / Assumptions:Turbo C style 16-bit environment.Common sizes: float = 4 bytes, double = 8 bytes, long double = 10 bytes (80-bit extended).Typical maxima: float ~3.4e+38, double ~1.7e+308, long double ~1.1e+4932 (implementation-dependent).Concept / Approach:The quoted range ±1.7e±38 is associated with 32-bit float, not 64-bit double. Double in both legacy and modern compilers typically reaches around 1.7e+308. Therefore, assigning float’s range to double is incorrect for the platform described.Step-by-Step Solution:Identify the claimed range: about 10^38.Map known ranges: float ≈ 10^38; double ≈ 10^308.Compare: the claim matches float, not double.Conclude: the statement is incorrect for double on the stated platform.Verification / Alternative check:Consult macros (DBL_MAX) or compiler manuals for Turbo C, which document double’s much larger maximum magnitude than float’s.Why Other Options Are Wrong:Correct: conflicts with standard documentation.“Correct only for float” is true as a remark but does not answer whether the statement about double is correct (it is not).Mentions of register or optimizer are unrelated to fundamental type ranges.Common Pitfalls:Assuming all floating types share the same exponent range; conflating precision with range.Final Answer:Incorrect.

Question 15

C type sizes (typical systems): “A float is 4 bytes wide, whereas a double is 8 bytes wide.” Assess this statement for common ABIs while acknowledging portability notes.

Accepted Answer

Introduction / Context:On mainstream desktop and server platforms, compilers typically implement float as 4 bytes (single precision) and double as 8 bytes (double precision). However, C allows implementations to choose representations, so exact sizes are technically implementation-defined. This question asks whether the common statement is correct in practice across typical environments.Given Data / Assumptions:Common ABIs like LP64 or LLP64.IEEE-754 formats widely used by compilers such as GCC, Clang, and MSVC.We assess the statement’s correctness for typical systems, not exotic targets.Concept / Approach:In most environments, sizeof(float) == 4 and sizeof(double) == 8. The standard headers document limits consistent with these sizes. While exceptions exist (special embedded targets or unusual ABIs), the statement holds for the majority of platforms students encounter.Step-by-Step Solution:Recall common representations: float (32-bit), double (64-bit).Check with sizeof in code to confirm on a specific system.Acknowledge portability: sizes are implementation-defined, but the claim is accurate on typical PCs.Verification / Alternative check:Write a small program printing sizeof(float) and sizeof(double). Expect 4 and 8 on mainstream systems. Compare with FLT_MANT_DIG and DBL_MANT_DIG in as further evidence.Why Other Options Are Wrong:Incorrect: contradicts common practice.Optimization level, 8-bit MCUs, or “only C++” have no bearing on fundamental type sizes mandated by a given implementation.Common Pitfalls:Forgetting that long double may vary (80-bit, 128-bit, or equal to double) and that exotic compilers can deviate; always verify with sizeof on target.Final Answer:Correct.

Question 16

C introspection: can you verify the sizes of short int and long int by using the sizeof operator in portable C code?

Accepted Answer

Introduction / Context:Type sizes in C are implementation-defined and can vary across platforms and ABIs. The language provides the sizeof operator to query object sizes at compile time (and also usable in constant expressions). This question checks whether sizeof is the correct portable way to discover sizes for short int and long int.Given Data / Assumptions:C code compiled with a conforming compiler.Types short int and long int exist with implementation-defined widths and alignment.Need a reliable method to check sizes.Concept / Approach:sizeof(type) yields the size in bytes of any complete object type. It is evaluated at compile time for known types and is the standard mechanism for determining the storage size without resorting to non-portable tricks. This works equally for short, int, long, pointers, structures, and arrays (with caveats for flexible array members).Step-by-Step Solution:Use sizeof(short) and sizeof(long) in code.Optionally print results to confirm on the target environment.Rely on these values for memory allocation or serialization logic.Verification / Alternative check:Compare the values with limits macros from such as SHRT_MAX and LONG_MAX to ensure expectations match the ABI (e.g., LP64 vs LLP64).Why Other Options Are Wrong:Incorrect: denies a standard feature expressly designed for this task.Compiler pragmas, link-time checks, or inline assembly are unnecessary for discovering type sizes.Common Pitfalls:Assuming fixed sizes (e.g., long always 8 bytes). Always use sizeof for portability.Final Answer:Correct.

Declarations and Initializations Questions

Questions

Practice smarter