Question 1

Identify the construct that is not a user-defined data type in C/C++ among the following: (1) struct book { char name[10]; float price; int pages; }; (2) long int l = 2.35; (3) enum day { Sun, Mon, Tue, Wed };

Accepted Answer

Introduction / Context: C and C++ provide several ways to define new types that aggregate or classify data. Distinguishing user-defined types from built-in types helps developers reason about declarations and understand how the type system maps to memory and semantics. This question asks you to identify which among three constructs is not a user-defined type. Given Data / Assumptions: (1) A structure declaration named book that introduces a composite record type. (2) A variable declaration using the built-in type long int with an initializer. (3) An enumeration declaration named day that creates a distinct type with named constants. Concept / Approach: User-defined types are created via language constructs such as struct, class, union, enum, and typedef/using aliases. Both struct and enum introduce new, distinct types. In contrast, long int is a fundamental arithmetic type provided by the language; declaring a variable of type long int does not define a new type. Therefore item (2) is not a user-defined type; it is simply a variable of a built-in type, even if the numeric literal shown would be converted or truncated during initialization. Step-by-Step Solution: Evaluate item (1): struct book { ... }; defines a new structure type named book, so it is user-defined.Evaluate item (2): long int l = 2.35; uses a built-in type; no new type is introduced.Evaluate item (3): enum day { Sun, Mon, Tue, Wed }; defines a new enumeration type day; it is user-defined.Therefore, the only item that is not user-defined is (2). Verification / Alternative check: Compilers allow declarations of variables with long int without any prior type definition. However, attempting to use book or day without the corresponding struct or enum declarations would produce errors, confirming that (1) and (3) are truly user-defined types. Why Other Options Are Wrong: Option 1: Incorrect because struct book is a user-defined type. Option 3: Incorrect because enum day is a user-defined type. Option Both 1 and 2: Incorrect because only (2) is not user-defined. None of the above: Incorrect because a correct choice exists, namely (2). Common Pitfalls: Confusing a variable declaration with a type definition. The presence of an initializer or a literal does not make a new type; only constructs like struct, class, enum, union, typedef, or using introduce types. Final Answer: 2.

Question 2

C/C++ declarations: Is there any difference between the following function declarations—(1) extern int fun(); and (2) int fun();—when no function body is provided?

Accepted Answer

Introduction / Context: Developers frequently separate function declarations from definitions across header and source files. In that workflow, you often see forms like 'extern int fun();' or simply 'int fun();'. This problem tests your understanding of linkage and what these two declarations actually mean in C/C++ when no function body is provided. Given Data / Assumptions: Two lines appear without a function body: 'extern int fun();' and 'int fun();'. No parameter list details are given (just empty parentheses). We are reasoning about declarations, not definitions. Concept / Approach: For functions, the storage class 'extern' is the default; a function declaration without 'static' or 'inline' already has external linkage. Therefore, writing 'extern int fun();' versus 'int fun();' communicates the same linkage and does not allocate storage or provide a body. A definition would be 'int fun() { /* body */ }' and it appears exactly once per program (per the One Definition Rule in C++). Step-by-Step Solution: Identify both statements as declarations (no body present).Recall: function declarations have external linkage by default unless otherwise specified (e.g., 'static').Conclude that adding 'extern' to a function declaration is redundant; the two lines are semantically identical. Verification / Alternative check: Place each line in a header and compile with a definition in a .c/.cpp file. The program links and runs the same in both cases. Why Other Options Are Wrong: No difference, except in another file: Location does not change the meaning; both are still declarations. 'int fun();' is overridden by 'extern int fun();': There is no overriding in declarations; they are equivalent. None of these / different linkage: Incorrect because both declare the same external linkage. Common Pitfalls: Confusing function declarations with variable declarations ('extern int x;' behaves differently from 'int x;'). Assuming empty parentheses mean 'no parameters' in C; strictly, 'void' should be used in C to indicate no parameters (C++ treats it as no parameters). Final Answer: Both are identical

Question 3

C/C++ fundamentals: At what stage do we 'mention' (provide) the prototype of a function—defining, declaring, prototyping, or calling?

Accepted Answer

Introduction / Context: A function prototype communicates a function's name, return type, and parameter types to the compiler before the function is used. This is critical for type checking, overload resolution (C++), and correct code generation. The question asks at which stage we provide that prototype in normal C/C++ development flow. Given Data / Assumptions: A function's signature must be known to the compiler before it is called. Prototypes are typically placed in header files that are included where needed. We distinguish between declaration (prototype) and definition (body). Concept / Approach: A declaration introduces an identifier and its type; for functions, that is the prototype. A definition provides the actual function body. Calling is the act of invoking a function; it requires that a declaration is already visible. Step-by-Step Solution: Identify what a prototype contains: return type + name + parameter types.Recognize that providing this information is exactly a function declaration, not a definition.Therefore, the stage is Declaring. Verification / Alternative check: Example: 'int sum(int a, int b);' (declaration/prototype) can appear in a header; the body appears in a source file. Why Other Options Are Wrong: Defining: Includes the body; the prototype exists even without the body. Prototyping: Not a standard stage name; the correct term is 'declaring'. Calling: Requires that the prototype (declaration) already be known. Common Pitfalls: Confusing the term 'prototype' with the implementation; only the signature is needed to call. Omitting prototypes leads to implicit declarations (illegal in modern C) or compiler errors. Final Answer: Declaring

Question 4

C linkage example: In the program shown, where is variable 'a' declared and where is it defined? (extern int a; ... int a = 20;)

Accepted Answer

Introduction / Context: The C language distinguishes between declaration (introducing a name and type) and definition (allocating storage or providing a body). This is especially important for global variables, which are often declared in headers and defined in exactly one source file. The snippet uses 'extern int a;' and later 'int a = 20;'. We must identify which line declares and which line defines the object 'a'. Given Data / Assumptions: Global context contains 'extern int a;' inside main's scope (visible as a declaration) and later a global definition 'int a = 20;'. We are discussing a non-const, non-static integer with external linkage. Standard C rules for declarations/definitions apply. Concept / Approach: 'extern int a;' is a declaration only: it promises that a definition exists elsewhere and does not allocate storage. 'int a = 20;' is a definition: it allocates storage and initializes the variable with 20. One program must have exactly one definition for 'a' with external linkage; multiple declarations are allowed. Step-by-Step Solution: Classify the 'extern' line → declaration without storage.Classify the 'int a = 20;' line → definition (creates the object and initializes it).Therefore, declaration is 'extern int a;' and definition is 'int a = 20;'. Verification / Alternative check: If you remove 'int a = 20;' and link, you will get an unresolved external symbol for 'a'; adding the definition resolves the reference. Why Other Options Are Wrong: Swapping declaration/definition reverses roles and is incorrect. Claiming 'a is not defined' contradicts the explicit definition present. Stating both are declarations ignores that initialization with storage constitutes a definition. Common Pitfalls: Placing a definition in a header and including it in multiple files causes multiple-definition linker errors. Confusing 'extern' on variables (suppresses definition) with 'extern' on functions (redundant for linkage). Final Answer: extern int a is declaration, int a = 20 is the definition

Question 5

C math library: Which statement correctly obtains the remainder of dividing 3.14 by 2.1 in floating-point arithmetic?

Accepted Answer

Introduction / Context: Unlike integer division, floating-point division in C/C++ uses library functions to compute the remainder. The operator '%' is defined only for integers, so you must select the proper function when working with doubles or floats. This question checks whether you know the standard library tool for floating-point remainders. Given Data / Assumptions: Operands are non-integers: 3.14 and 2.1 (double by default). We want the remainder r such that 3.14 = q * 2.1 + r with r having the same sign as the dividend for fmod. Standard C headers: / . Concept / Approach: Operator '%' applies to integers only; using it with floating types is a compile-time error. 'fmod(x, y)' returns the floating remainder of x / y following the definition r = x - trunc(x / y) * y. 'modf(x, &intpart)' splits a floating-point number into fractional and integral parts; it is not a remainder function. Step-by-Step Solution: Select the correct API: 'fmod(3.14, 2.1)'.Compute conceptually: r = 3.14 - trunc(3.14/2.1) * 2.1.Identify that '%' with doubles is illegal; 'modf' does something different entirely. Verification / Alternative check: C also offers 'remainder(x, y)' which returns r = x - rint(x/y) * y with possibly different sign/ magnitude conventions; the prompt specifically expects 'fmod'. Why Other Options Are Wrong: 3.14 % 2.1: Illegal for floating types. modf(3.14, 2.1): Wrong signature and purpose; 'modf' requires a pointer for the integer part. Remainder cannot be obtained: False; use 'fmod'. remainder(3.14, 2.1): Different function and behavior; not the canonical answer here. Common Pitfalls: Confusing 'modf' with modulo operations. Assuming '%' works for floats in C/C++ as in some languages; it does not. Final Answer: rem = fmod(3.14, 2.1);

Question 6

C/C++ language basics: Is the statement 'extern int i;' a declaration or a definition?

Accepted Answer

Introduction / Context: In multi-file C/C++ projects, header files commonly contain 'extern' declarations of globals. Understanding how 'extern' changes the meaning of a statement prevents multiple-definition linker errors while allowing many translation units to reference the same variable defined elsewhere. Given Data / Assumptions: The line in question is 'extern int i;' with no initializer. We are discussing a global-scope variable, not a function. Standard C/C++ linkage rules apply. Concept / Approach: A declaration introduces a name and its type. Using 'extern' for an object declares it without defining (allocating storage for) it. A definition for a global object allocates storage. Example: 'int i;' or 'int i = 0;'. Exactly one definition with external linkage must appear across the program, while declarations can appear in multiple files. Step-by-Step Solution: Classify 'extern int i;' → declaration only (no storage allocated).Recognize that definition would be 'int i;' (or with initialization) in exactly one source file.Thus, the statement is a declaration. Verification / Alternative check: Placing 'extern int i;' in a header included in many files compiles; the program links only if one file defines 'int i;' once. Why Other Options Are Wrong: Definition: Would allocate storage; our line does not. Function: We are not declaring a function here. Error: The statement is valid; it simply declares an external symbol. Common Pitfalls: Putting a definition (without extern) in a header causes multiple definitions during linking. Confusing 'extern' on variables with function declarations where 'extern' is redundant. Final Answer: Declaration

Question 7

C math rounding: Which function call rounds 1.66 upward to 2.0 according to standard C/C++ library rules?

Accepted Answer

Introduction / Context: Rounding functions in the C/C++ standard math library have distinct behaviors: some always round up, some always round down, and others round to the nearest integer with ties following specific rules. This question focuses on rounding 1.66 upward to 2.0 using the correct function. Given Data / Assumptions: The value is 1.66 (double by default). We want the result 2.0, i.e., the smallest integer not less than the argument. Standard functions are declared in / . Concept / Approach: 'ceil(x)' returns the least integer value not less than x (rounds toward +infinity). 'floor(x)' returns the greatest integer value not greater than x (rounds toward -infinity). 'rint/nearbyint/round' round to the nearest integer under specified tie-breaking; 1.66 still rounds to 2 in common modes but the explicit 'round up' operation is 'ceil'. Names like 'roundup' and 'roundto' are not standard C functions. Step-by-Step Solution: Identify desired behavior → always round upward.Choose 'ceil(1.66)' → returns 2.0.Confirm alternatives: 'floor(1.66)' gives 1.0; 'round' gives nearest (2); but the canonical 'always up' function is 'ceil'. Verification / Alternative check: Test values: ceil(2.0) = 2.0, ceil(-1.2) = -1.0; behavior matches 'toward +infinity' definition. Why Other Options Are Wrong: floor(1.66): Moves downward to 1.0. roundup/roundto: Not standard C library functions. rint: Rounds to nearest according to current rounding mode; not explicitly 'always up'. Common Pitfalls: Assuming 'round' and 'ceil' are interchangeable; only 'ceil' guarantees upward rounding regardless of fractional part. Forgetting to include / and link the math library where required. Final Answer: ceil(1.66)

Question 8

C language linkage: Which types of linkages are recognized for identifiers in C—considering scope and visibility across translation units?

Accepted Answer

Introduction / Context: In C, linkage describes whether multiple declarations refer to the same entity across scopes and translation units. Understanding linkage is key to organizing headers and source files, avoiding multiple-definition errors, and intentionally restricting visibility of symbols. Given Data / Assumptions: We are discussing identifiers with potential external visibility (functions, global objects) and those restricted to a translation unit or block. Storage-class specifiers like 'static' and 'extern' affect linkage. Block-scope variables generally have no linkage. Concept / Approach: External linkage: The identifier refers to the same entity across translation units (e.g., non-static functions/globals). Internal linkage: The identifier is limited to a single translation unit (e.g., 'static' global objects or functions). No linkage: Each appearance refers to a distinct entity (e.g., block-scope variables, function parameters, typedef names). Step-by-Step Solution: Map examples to linkage: 'int g;' (external), 'static int g;' (internal), 'int x' inside a block (no linkage).Recognize that all three categories exist in the language standard.Therefore, the correct choice is 'External, Internal and None'. Verification / Alternative check: Link two files that declare the same non-static function → they refer to one function (external). Make a function 'static' → calls from another file fail (internal). Local variables of the same name in different functions are independent (no linkage). Why Other Options Are Wrong: Pairs or singletons omit one or two categories defined by the standard. Only External/Internal: ignores block-scope identifiers with no linkage. Common Pitfalls: Confusing storage duration (automatic/static) with linkage (external/internal/none). Assuming 'extern' always defines; it usually only declares for objects. Final Answer: External, Internal and None

Question 9

C/C++ declarations: Which among the following lines are declarations (not definitions) — 1) extern int x; 2) float square(float x) { /* ... / } 3) double pow(double, double);

Accepted Answer

Introduction / Context: Correctly distinguishing between declarations and definitions shapes how you structure headers and source files. Declarations introduce names and types; definitions allocate storage or provide function bodies. This question asks you to classify three common patterns you will encounter in real projects. Given Data / Assumptions: 1) 'extern int x;' 2) 'float square(float x) { / body */ }' 3) 'double pow(double, double);' Standard C/C++ rules apply. Concept / Approach: For objects: 'extern' declares without defining (no storage). For functions: a prototype with a semicolon is a declaration; a body enclosed in braces is a definition. Therefore, 1 and 3 are declarations; 2 is a definition. Step-by-Step Solution: Line 1 → declaration only (no storage allocated).Line 2 → function body present → definition.Line 3 → prototype only → declaration. Verification / Alternative check: If you place 1 and 3 in a header and compile multiple translation units, linking succeeds provided there is exactly one definition of 'x' and of the function elsewhere. Why Other Options Are Wrong: 2: Contains a body; it is a definition, not a mere declaration. Single-choice options miss that two items are declarations. Common Pitfalls: Putting definitions in headers can cause multiple-definition errors. Forgetting that functions always have external linkage by default unless qualified (e.g., 'static'). Final Answer: 1 and 3

Question 10

C/C++ literals: By default, a real (floating) numeric literal such as 3.5 is treated as which type?

Accepted Answer

Introduction / Context: Literal types influence overload resolution, precision, and performance. In both C and C++, an unsuffixed real literal like 3.5 is assigned a default floating type unless a suffix changes it. Recognizing this default helps you pick correct function overloads and avoid unintentional narrowing conversions. Given Data / Assumptions: No suffix is present (e.g., 'f' or 'L'). We refer to standard language rules, not compiler extensions. The literal is written in decimal floating notation. Concept / Approach: Unsuffixed floating literals are of type double. Adding 'f' or 'F' yields type float; adding 'l' or 'L' yields long double (subject to implementation specifics). There is no 'far double' in standard C/C++. Step-by-Step Solution: Identify the absence of a suffix → default applies.Default floating literal type → double.Therefore, answer: 'double'. Verification / Alternative check: Use sizeof(3.5) versus sizeof(3.5f) in C++: commonly 8 bytes vs 4 bytes on typical platforms, confirming different default types. Why Other Options Are Wrong: float/long double require explicit suffixes or contexts. far double: Not a standard type. Common Pitfalls: Accidentally calling 'float' overloads with double arguments, causing extra casts or ambiguity. Assuming 'long double' is always higher precision; implementation details vary. Final Answer: double

Question 11

C identifier rules: Which special symbol is allowed within a variable name according to standard C/C++ naming conventions?

Accepted Answer

Introduction / Context: Valid identifiers are essential for readable, portable code. C and C++ restrict variable names to a specific character set so compilers can parse tokens unambiguously. This question checks your knowledge of which special symbol is permitted within a variable name without invoking operator parsing or undefined behavior. Given Data / Assumptions: Identifiers typically consist of letters (A–Z, a–z), digits (0–9), and possibly one special character. The first character of an identifier cannot be a digit. We are concerned with ASCII-like basic source character set; extended identifiers exist but are not the focus. Concept / Approach: The only commonly allowed special character in standard C/C++ identifiers is the underscore ''. Other symbols like '', '|', and '-' are operators or punctuation and cannot appear in identifiers. Although identifiers beginning with underscores may be reserved in certain contexts, underscore itself is permitted. Step-by-Step Solution: Eliminate operator characters: '' (multiplication), '|' (bitwise OR/pipe), '-' (minus/negation).Confirm the remaining candidate '' as valid within identifiers.Hence, the allowed special symbol is the underscore. Verification / Alternative check: Try compiling variables named data_value, value2, and a-b; only the hyphenated name fails because '-' is parsed as an operator. Why Other Options Are Wrong: *, |, -: These are operators with fixed meanings in expressions and cannot appear in identifiers. None of the above: Incorrect because underscore is valid. Common Pitfalls: Using identifiers beginning with an underscore plus a capital letter or double underscore; these are reserved for the implementation. Starting identifiers with digits; that is invalid syntax. Final Answer: _ (underscore)

Question 12

What will be the output of the program in 16 bit platform (Turbo C under DOS)? #include<stdio.h> int main() {     extern int i;     i = 20;     printf("%d ", sizeof(i));     return 0; }

Accepted Answer

Linker Error : Undefined symbol 'i' The statement extern int i specifies to the compiler that the memory for 'i' is allocated in some other program and that address will be given to the current program at the time of linking. But linker finds that no other variable of name 'i' is available in any other program with memory space allocated for it. Hence a linker error has occurred.

Question 13

What is the output of the program given below? #include<stdio.h> int main() {     enum status { pass, fail, atkt};     enum status stud1, stud2, stud3;     stud1 = pass;     stud2 = atkt;     stud3 = fail;     printf("%d, %d, %d ", stud1, stud2, stu…

Accepted Answer

enum takes the format like {0,1,2..) so pass=0, fail=1, atkt=2 stud1 = pass (value is 0) stud2 = atkt (value is 2) stud3 = fail (value is 1) Hence it prints 0, 2, 1

Question 14

What is the output of the program? #include<stdio.h> int main() {     extern int a;     printf("%d ", a);     return 0; } int a=20;

Accepted Answer

extern int a; indicates that the variable a is defined elsewhere, usually in a separate source code module. printf("%d
", a); it prints the value of local variable int a = 20. Because, whenever there is a conflict between local variable and global variable, local variable gets the highest priority. So it prints 20.

Question 15

What will be the output of the program? #include<stdio.h> int X=40; int main() {     int X=20;     printf("%d ", X);     return 0; }

Accepted Answer

Whenever there is conflict between a local variable and global variable, the local variable gets priority.

Question 16

What is the output of the program #include<stdio.h> int main() {     extern int fun(float);     int a;     a = fun(3.14);     printf("%d ", a);     return 0; } int fun(int aa) { 	return (int)++aa; }

Accepted Answer

2 Errors 1. Type mismatch in redeclaration of fun 2. Type mismatch in parameter aa

Question 17

In the following program how long will the for loop get executed? #include<stdio.h> int main() {     int i=5;     for(;scanf("%s", &i); printf("%d ", i));     return 0; }

Accepted Answer

During the for loop execution scanf() ask input and then printf() prints that given input. This process will be continued repeatedly because, scanf() returns the number of input given, the condition is always true(user gives a input means it reurns '1'). Hence this for loop would get executed infinite times.

Question 18

What is the output of the program #include<stdio.h> int main() {     int a[5] = {2, 3};     printf("%d, %d, %d ", a[2], a[3], a[4]);     return 0; }

Accepted Answer

When an automatic array is partially initialized, the remaining elements are initialized to 0.

Question 19

What is the output of the program in Turbo C (in DOS 16-bit OS)? #include<stdio.h> int main() {     char *s1;     char far *s2;     char huge *s3;     printf("%d, %d, %d ", sizeof(s1), sizeof(s2), sizeof(s3));     return 0; }

Accepted Answer

Any pointer size is 2 bytes. (only 16-bit offset) So, char *s1 = 2 bytes. So, char far *s2; = 4 bytes. So, char huge *s3; = 4 bytes. A far, huge pointer has two parts: a 16-bit segment value and a 16-bit offset value. Since C is a compiler dependent language, it may give different output in other platforms. The above program works fine in Windows (TurboC), but error in Linux (GCC Compiler).

Question 20

What is the output of the program #include<stdio.h> int main() {     int x = 10, y = 20, z = 5, i;     i = x < y < z;     printf("%d ", i);     return 0; }

Accepted Answer

Since x < y turns to be TRUE it is replaced by 1. Then 1 < z is compared and to be TRUE. The 1 is assigned to i.

Declarations and Initializations Questions