Q: In C++ (2D array filled by column-major style indexing), what sequence does the program output? #include class CuriousTabArray { int Matrix[3][3]; public: CuriousTabArray() { for(int i = 0; i < 3; i++) for(int j = 0; j < 3; j++) Matrix[…

Introduction / Context: The code writes and then reads a 3x3 matrix using the same Matrix[j][i] indexing order inside nested loops. Although C++ stores arrays in row-major order, the explicit indices determine which element is updated. Because both the constructor and the display use the same indexing, values are read exactly as written. Given Data / Assumptions: Initialization: Matrix[j][i] = i + j for i, j = 0..2. Display: prints Matrix[j][i] in the same i-outer, j-inner order. Concept / Approach: Compute each entry: For i=0, the row of outputs is 0,1,2; for i=1, outputs are 1,2,3; for i=2, outputs are 2,3,4. Since display mirrors initialization order and indexing, no uninitialized values are printed. Step-by-Step Solution: i=0: j=0..2 → 0 1 2 i=1: j=0..2 → 1 2 3 i=2: j=0..2 → 2 3 4 Concatenated: 0 1 2 1 2 3 2 3 4 Verification / Alternative check: Swapping indices in Display to Matrix[i][j] would produce a different sequence because the matrix is not symmetric in general for arbitrary formulas. Why Other Options Are Wrong: 4 3 2 ...: Reversed order, not what the loops produce. Garbage / Compilation error: All elements are assigned; headers and syntax are fine. Common Pitfalls: Confusing row-major storage with the iteration order used for printing; storage order does not affect correctness of this deterministic computation. Final Answer: The program will display the output 0 1 2 1 2 3 2 3 4.

Q: In C++ (old-style iostream.h), a function with a default argument is called once and computes a factorial-like product. Predict the printed result. #include long FactFinder(long = 5); int main() { for (int i = 0; i <= 0; i++) cout …

Introduction / Context: This question checks your understanding of default function arguments, loop bounds, and how an off-by-one choice in the loop makes the routine compute a product up to x - 1 rather than x. It also reinforces that the loop in main executes exactly once and calls the function with its default parameter value. Given Data / Assumptions: Function prototype: long FactFinder(long = 5). Main calls FactFinder() once due to for (i = 0; i <= 0; i++). In FactFinder, if x < 2 return 1; otherwise multiply i from 1 to x - 1. Classic headers (iostream.h) are assumed to compile in the intended environment. Concept / Approach: Because the call uses the default, x is 5. The function multiplies numbers from 1 through 4 (not 5). That computes 1 * 2 * 3 * 4 = 24. It then returns this value, which is printed by cout from main, followed by a newline. Step-by-Step Solution: In main: the loop runs exactly once and calls FactFinder() → x = 5.Check x < 2 → false; proceed to compute.Initialize fact = 1.Multiply for i = 1..4: fact = 11 → 1; then 12 → 2; then 23 → 6; then 64 → 24.Return 24; cout prints 24. Verification / Alternative check: If the loop were i <= x instead of i <= x - 1, the result would be 120 for x = 5. The present code intentionally stops early. Why Other Options Are Wrong: The program will print the output 1.: This would require x < 2 or an empty product, which is not the case. The program will print the output 120.: That would need multiplication up to 5. The program will print the output garbage value.: All variables are initialized; no undefined reads occur. The program will report compile time error.: The code is valid in the assumed toolchain. Common Pitfalls: Confusing default-argument usage, assuming factorial(x) instead of factorial(x - 1), or thinking the for loop in main runs multiple times. Also, overlooking that the code prints once because the loop bound is i <= 0. Final Answer: The program will print the output 24.

Q: C++ recursive base-13 conversion using a class method: determine the output when the initial value is 130. #include class Number { int Num; public: Number(int x = 0) { Num = x; } void Display() { cout << Num; } void Modify(); }; …

Introduction / Context: This program prints a number in base 13 using digits 0–9 and letters A, B, C for 10, 11, 12 respectively. The method Modify transforms Num by repeatedly dividing by 13, recursing for higher places, and then printing the current remainder as a base-13 digit. Given Data / Assumptions: Initial Num = 130. Remainder mapping: 10 → A, 11 → B, 12 → C. Recursion prints higher-order digits first (after dividing), then the current remainder. Concept / Approach: Converting to base 13: at each step compute Dec = Num % 13 and Num = Num / 13. Recurse if Num > 0 to print the more significant digits first; then print the symbol for Dec. This is the standard recursive number-to-base printing pattern. Step-by-Step Solution: Start: Num = 130 → Dec = 130 % 13 = 0; Num = 130 / 13 = 10; recurse.Second frame: Num = 10 → Dec = 10 % 13 = 10; Num = 10 / 13 = 0; no recursion.Map Dec = 10 → print "A".Return to first frame → print Dec = 0 as "0".Concatenate outputs → "A0". Verification / Alternative check: 130 in base 13 equals 10*13 + 0, so the digits are 10 and 0 → A0. Printing order matches the recursion. Why Other Options Are Wrong: 130: That would be base 10, not base 13 representation. B0 or 90: Incorrect remainder mapping or arithmetic. None of the above: A0 is exactly produced. Common Pitfalls: Expecting 13 to produce a remainder of 13 (remainders are 0–12), or forgetting that the routine prints higher-order digits first by recursing before output. Final Answer: A0

Q: C++ function with multiple defaulted parameters used as a polynomial: compute two outputs for x = 2.3. #include double CuriousTabFunction(double, double, double = 0, double = 0, double = 0); int main() { double d = 2.3; cout << Cur…

Introduction / Context: The function evaluates a cubic-like expression using Horner-style nesting. Default arguments make most coefficients zero unless explicitly provided. You must track which parameters receive values and which default to zero. Given Data / Assumptions: x = 2.3. First call: p = 7, q = r = s = 0. Second call: p = 7, q = 6, r = s = 0. Concept / Approach: For the first call, every nested term beyond p cancels to zero, leaving p. For the second call, only q contributes beyond p, scaled by x once. Evaluating carefully yields numeric results. Step-by-Step Solution: Call 1: p + (q + (r + sx)x)x with q=r=s=0 → 7 + (0 + (0 + 0)x)x = 7.Call 2: p=7, q=6, r=s=0 → 7 + (6 + (0 + 0)x)x = 7 + 6x = 7 + 62.3 = 7 + 13.8 = 20.8. Verification / Alternative check: Writing the general form as p + qx + rx^2 + sx^3 confirms that only qx contributes in the second call. Why Other Options Are Wrong: 7 20: Misses the 0.8 contribution of 60.133..; numerically incorrect. 7 19.8: Off by 1.0; likely mistaken sign. 7 Garbage / None of the above: All arguments are defined and the math is straightforward. Common Pitfalls: Misplacing parentheses in nested expressions, or forgetting that only q survives when r and s are zero. Final Answer: 7 20.8

Q: C++ overloading with a competing overload that has a default argument: which function is called and what is printed? #include int CuriousTabTest(int x, int y); int CuriousTabTest(int x, int y, int z = 5); int main() { cout << Curiou…

Introduction / Context: This item examines overload resolution when one overload exactly matches the argument list and another is also viable by supplying a default argument. The C++ rules select the best viable function, favoring an exact arity match over one that relies on defaults. Given Data / Assumptions: Two overloads exist: f(int,int) and f(int,int,int=5). Call site: CuriousTabTest(2, 4). Both overloads are viable, but one requires using a default argument for the third parameter. Concept / Approach: Overload resolution prefers the function that requires no default arguments and exactly matches the number and types of the provided parameters. Therefore CuriousTabTest(int,int) is selected, computing 2 * 4 = 8. Step-by-Step Solution: Evaluate candidates: (int,int) and (int,int,int=5).Both match types; the three-parameter overload needs its default for z.Best viable function is the exact two-parameter overload.Return 2 * 4 → 8; cout prints 8. Verification / Alternative check: If the call were CuriousTabTest(2,4,5), the three-parameter version would be chosen and print 40. Removing the two-parameter overload would also yield 40 due to the default. Why Other Options Are Wrong: 5: Not computed by either overload. 40: Would require calling the three-parameter function explicitly (or removing the two-parameter overload). Compile time error / None of the above: The overload set is resolvable. Common Pitfalls: Thinking the presence of a defaulted parameter forces selection of that overload; in reality, defaults only make a function viable, not necessarily the best match. Final Answer: The program will print the output 8.

Question 1

In C++ (2D array filled by column-major style indexing), what sequence does the program output?  #include<iostream.h> class CuriousTabArray { int Matrix[3][3]; public: CuriousTabArray() { for(int i = 0; i < 3; i++) for(int j = 0; j < 3; j++) Matrix[…

Accepted Answer

Introduction / Context: The code writes and then reads a 3x3 matrix using the same Matrix[j][i] indexing order inside nested loops. Although C++ stores arrays in row-major order, the explicit indices determine which element is updated. Because both the constructor and the display use the same indexing, values are read exactly as written. Given Data / Assumptions: Initialization: Matrix[j][i] = i + j for i, j = 0..2. Display: prints Matrix[j][i] in the same i-outer, j-inner order. Concept / Approach: Compute each entry: For i=0, the row of outputs is 0,1,2; for i=1, outputs are 1,2,3; for i=2, outputs are 2,3,4. Since display mirrors initialization order and indexing, no uninitialized values are printed. Step-by-Step Solution: i=0: j=0..2 → 0 1 2 i=1: j=0..2 → 1 2 3 i=2: j=0..2 → 2 3 4 Concatenated: 0 1 2 1 2 3 2 3 4 Verification / Alternative check: Swapping indices in Display to Matrix[i][j] would produce a different sequence because the matrix is not symmetric in general for arbitrary formulas. Why Other Options Are Wrong: 4 3 2 ...: Reversed order, not what the loops produce. Garbage / Compilation error: All elements are assigned; headers and syntax are fine. Common Pitfalls: Confusing row-major storage with the iteration order used for printing; storage order does not affect correctness of this deterministic computation. Final Answer: The program will display the output 0 1 2 1 2 3 2 3 4.

Question 2

In C++ (old-style iostream.h), a function with a default argument is called once and computes a factorial-like product. Predict the printed result.  #include <iostream.h>  long FactFinder(long = 5);  int main() {  for (int i = 0; i <= 0; i++)  cout …

Accepted Answer

Introduction / Context: This question checks your understanding of default function arguments, loop bounds, and how an off-by-one choice in the loop makes the routine compute a product up to x - 1 rather than x. It also reinforces that the loop in main executes exactly once and calls the function with its default parameter value. Given Data / Assumptions: Function prototype: long FactFinder(long = 5). Main calls FactFinder() once due to for (i = 0; i <= 0; i++). In FactFinder, if x < 2 return 1; otherwise multiply i from 1 to x - 1. Classic headers (iostream.h) are assumed to compile in the intended environment. Concept / Approach: Because the call uses the default, x is 5. The function multiplies numbers from 1 through 4 (not 5). That computes 1 * 2 * 3 * 4 = 24. It then returns this value, which is printed by cout from main, followed by a newline. Step-by-Step Solution: In main: the loop runs exactly once and calls FactFinder() → x = 5.Check x < 2 → false; proceed to compute.Initialize fact = 1.Multiply for i = 1..4: fact = 11 → 1; then 12 → 2; then 23 → 6; then 64 → 24.Return 24; cout prints 24. Verification / Alternative check: If the loop were i <= x instead of i <= x - 1, the result would be 120 for x = 5. The present code intentionally stops early. Why Other Options Are Wrong: The program will print the output 1.: This would require x < 2 or an empty product, which is not the case. The program will print the output 120.: That would need multiplication up to 5. The program will print the output garbage value.: All variables are initialized; no undefined reads occur. The program will report compile time error.: The code is valid in the assumed toolchain. Common Pitfalls: Confusing default-argument usage, assuming factorial(x) instead of factorial(x - 1), or thinking the for loop in main runs multiple times. Also, overlooking that the code prints once because the loop bound is i <= 0. Final Answer: The program will print the output 24.

Question 3

In C++ (iostream.h), a class method with default parameters modifies members and prints an expression using pre-increment and pre-decrement. Determine the output.  #include <iostream.h>  void Tester(int xx, int yy = 5); // unrelated free function  c…

Accepted Answer

Introduction / Context: The problem focuses on default parameters and operator semantics in C++. It asks you to evaluate an expression that uses pre-increment and pre-decrement with integer operands and the modulo operator, all inside a class method invoked with explicit arguments. Given Data / Assumptions: Method Tester(int, int = 5) is called as Tester(5, 5). Computation: cout << ++x % --y; with integer x and y. Free function Tester declared above is unrelated to the member call. Concept / Approach: Pre-increment ++x yields 6. Pre-decrement --y yields 4. The modulo operation with integers computes 6 % 4, which equals 2. The method prints this result directly. Step-by-Step Solution: Initialize x = 5, y = 5 via parameters.Compute ++x → 6.Compute --y → 4.Compute 6 % 4 → 2; stream it to cout. Verification / Alternative check: Replacing pre- with post- (x++ % y--) would evaluate to 5 % 5 → 0 first, but the code explicitly uses pre-operators, so the printed result is 2. Why Other Options Are Wrong: The program will print the output 0./1.: Do not match 6 % 4. The program will print the output garbage value.: All variables are well-defined. The program will report compile time error.: There is no ambiguity; member call resolves correctly. Common Pitfalls: Confusing the free Tester declaration with the class method; mixing up pre- and post- increments which change the numeric result; overlooking that modulo is only valid for integral types (which we have here). Final Answer: The program will print the output 2.

Question 4

C++ recursive base-13 conversion using a class method: determine the output when the initial value is 130.  #include <iostream.h>  class Number {  int Num; public:  Number(int x = 0) { Num = x; }  void Display() { cout << Num; }  void Modify(); };  …

Accepted Answer

Introduction / Context: This program prints a number in base 13 using digits 0–9 and letters A, B, C for 10, 11, 12 respectively. The method Modify transforms Num by repeatedly dividing by 13, recursing for higher places, and then printing the current remainder as a base-13 digit. Given Data / Assumptions: Initial Num = 130. Remainder mapping: 10 → A, 11 → B, 12 → C. Recursion prints higher-order digits first (after dividing), then the current remainder. Concept / Approach: Converting to base 13: at each step compute Dec = Num % 13 and Num = Num / 13. Recurse if Num > 0 to print the more significant digits first; then print the symbol for Dec. This is the standard recursive number-to-base printing pattern. Step-by-Step Solution: Start: Num = 130 → Dec = 130 % 13 = 0; Num = 130 / 13 = 10; recurse.Second frame: Num = 10 → Dec = 10 % 13 = 10; Num = 10 / 13 = 0; no recursion.Map Dec = 10 → print "A".Return to first frame → print Dec = 0 as "0".Concatenate outputs → "A0". Verification / Alternative check: 130 in base 13 equals 10*13 + 0, so the digits are 10 and 0 → A0. Printing order matches the recursion. Why Other Options Are Wrong: 130: That would be base 10, not base 13 representation. B0 or 90: Incorrect remainder mapping or arithmetic. None of the above: A0 is exactly produced. Common Pitfalls: Expecting 13 to produce a remainder of 13 (remainders are 0–12), or forgetting that the routine prints higher-order digits first by recursing before output. Final Answer: A0

Question 5

C++ function with multiple defaulted parameters used as a polynomial: compute two outputs for x = 2.3.  #include <iostream.h>  double CuriousTabFunction(double, double, double = 0, double = 0, double = 0);  int main() {  double d = 2.3;  cout << Cur…

Accepted Answer

Introduction / Context: The function evaluates a cubic-like expression using Horner-style nesting. Default arguments make most coefficients zero unless explicitly provided. You must track which parameters receive values and which default to zero. Given Data / Assumptions: x = 2.3. First call: p = 7, q = r = s = 0. Second call: p = 7, q = 6, r = s = 0. Concept / Approach: For the first call, every nested term beyond p cancels to zero, leaving p. For the second call, only q contributes beyond p, scaled by x once. Evaluating carefully yields numeric results. Step-by-Step Solution: Call 1: p + (q + (r + sx)x)x with q=r=s=0 → 7 + (0 + (0 + 0)x)x = 7.Call 2: p=7, q=6, r=s=0 → 7 + (6 + (0 + 0)x)x = 7 + 6x = 7 + 62.3 = 7 + 13.8 = 20.8. Verification / Alternative check: Writing the general form as p + qx + rx^2 + sx^3 confirms that only qx contributes in the second call. Why Other Options Are Wrong: 7 20: Misses the 0.8 contribution of 60.133..; numerically incorrect. 7 19.8: Off by 1.0; likely mistaken sign. 7 Garbage / None of the above: All arguments are defined and the math is straightforward. Common Pitfalls: Misplacing parentheses in nested expressions, or forgetting that only q survives when r and s are zero. Final Answer: 7 20.8

Question 6

C++ defaults, compound assignments, and parameter passing by value: trace member updates and print x and y.  #include <iostream.h>  class CuriousTab {  int x, y, z; public:  void Apply(int xx = 12, int yy = 21, int zz = 9)  {  x = xx; // x = 12  y =…

Accepted Answer

Introduction / Context: This exercise tests understanding of default arguments, pass-by-value, and chained assignments with compound operators. It asks you to follow exact state changes inside Apply and then print two members using Display. Given Data / Assumptions: SetValue calls Apply(12, 0, 20). Parameters are passed by value; modifications to yy do not escape Apply except through explicit assignments to members. Operators used: yy += 10 and x -= 2, with their results assigned to y and z respectively. Concept / Approach: Carefully evaluate compound assignments which both change the left-hand operand and yield a value. Keep track of x and y after each statement to determine what Display prints. Step-by-Step Solution: Entry to Apply: xx = 12, yy = 0, zz = 20.x = xx → x = 12.y = yy += 10 → yy becomes 10 (locally) and y receives 10.z = x -= 2 → x becomes 10 and z receives 10.Display prints x and y → "10 10". Verification / Alternative check: Rewriting as yy = yy + 10; y = yy; x = x - 2; z = x; confirms the same final member values. Why Other Options Are Wrong: 12 10: Ignores the later x -= 2. 12 21 / 12 31: Misapply defaults or assume pass-by-reference, which is not used here. The program will report compilation error.: The code compiles as intended. Common Pitfalls: Thinking yy += 10 returns the old value, or assuming parameters are references; both lead to incorrect y values. Final Answer: 10 10

Question 7

C++ modulo is not defined for floating-point operands: identify the outcome when using % with float values in a method.  #include <iostream.h>  void Tester(float xx, float yy = 5.0); // unrelated free function  class CuriousTab {  float x;  float y;…

Accepted Answer

Introduction / Context: In C++, the % (remainder) operator is defined only for integral types. Attempting to apply it to floating-point operands is ill-formed. This snippet intentionally uses % with float values to provoke a compiler diagnostic. Given Data / Assumptions: Method Tester takes float parameters and assigns to float members. Expression: ++x % --y with x and y of type float. Classic headers (iostream.h) do not affect the core language rule about %. Concept / Approach: Both operands to % must be integral. Since ++x and --y are still floats, there is no valid operator% overload, and the code fails to compile with an error similar to “invalid operands to binary %”. Step-by-Step Solution: Set x = 5.0 and y = 5.0.Attempt to compute ++x % --y with float operands.Compiler rejects the expression at compile time; no program output is produced. Verification / Alternative check: Changing the members to int (and passing integer literals) would allow % and yield a value. Alternatively, use fmod from for floating-point remainders: fmod(++x, --y). Why Other Options Are Wrong: Any printed numeric output assumes successful compilation and execution, which does not occur. “Garbage value” implies runtime behavior; the failure is compile-time. Common Pitfalls: Assuming % behaves like mathematical modulus for floats, or forgetting to use fmod for double/float types. Final Answer: The program will report compile time error.

Question 8

C++ overloaded constructors and default arguments in a base class: predict what is printed when the derived object chooses the 1-arg base constructor.  #include <iostream.h>  class Base { public:  char S, A, M;  Base(char x, char y)  {  S = y - y;  …

Accepted Answer

Introduction / Context: This example probes constructor selection with default arguments and the order of initialization in inheritance. The derived class calls Base(x) with one argument, forcing selection of the Base overload that has defaults for the remaining parameters, and then chooses which Display to invoke at runtime. Given Data / Assumptions: Derived’s initializer list uses Base(x) with a single argument. Base has an overload Base(char, char y = 'A', char z = 'B') that can be called with one argument. Display(0 - 1) passes a non-zero integer, so Base::Display() runs. Concept / Approach: With Base(x) and defaults, y becomes 'A' and z becomes 'B'. The chosen Base constructor sets S = y, A = y + 1 - 1 (thus also 'A'), and M = z - 1 ('B' - 1 → 'A'). Therefore all three printed characters are 'A'. Step-by-Step Solution: Call Base(x) → selects Base(char, char y = 'A', char z = 'B').Assign S = 'A'.Compute A = 'A' + 1 - 1 → 'A'.Compute M = 'B' - 1 → 'A'.Base::Display prints: A A A. Verification / Alternative check: If Derived called Base(x, y) or Base(x, y, z), the printed values could differ. The code as written uses the 1-argument form with defaults. Why Other Options Are Wrong: Any option not equal to A A A contradicts the explicit arithmetic on characters in the selected constructor. “Garbage” would suggest uninitialized output, which is not the case for Base members. Compile-time error does not occur under the assumed environment. Common Pitfalls: Worrying about using member x before it is assigned; while x is indeterminate when passed, the selected Base constructor ignores its value for S, A, and M because they depend only on defaulted y and z, leading to deterministic output here. Final Answer: A A A

Question 9

C++ overloading with a competing overload that has a default argument: which function is called and what is printed?  #include <iostream.h>  int CuriousTabTest(int x, int y); int CuriousTabTest(int x, int y, int z = 5);  int main() {  cout << Curiou…

Accepted Answer

Introduction / Context: This item examines overload resolution when one overload exactly matches the argument list and another is also viable by supplying a default argument. The C++ rules select the best viable function, favoring an exact arity match over one that relies on defaults. Given Data / Assumptions: Two overloads exist: f(int,int) and f(int,int,int=5). Call site: CuriousTabTest(2, 4). Both overloads are viable, but one requires using a default argument for the third parameter. Concept / Approach: Overload resolution prefers the function that requires no default arguments and exactly matches the number and types of the provided parameters. Therefore CuriousTabTest(int,int) is selected, computing 2 * 4 = 8. Step-by-Step Solution: Evaluate candidates: (int,int) and (int,int,int=5).Both match types; the three-parameter overload needs its default for z.Best viable function is the exact two-parameter overload.Return 2 * 4 → 8; cout prints 8. Verification / Alternative check: If the call were CuriousTabTest(2,4,5), the three-parameter version would be chosen and print 40. Removing the two-parameter overload would also yield 40 due to the default. Why Other Options Are Wrong: 5: Not computed by either overload. 40: Would require calling the three-parameter function explicitly (or removing the two-parameter overload). Compile time error / None of the above: The overload set is resolvable. Common Pitfalls: Thinking the presence of a defaulted parameter forces selection of that overload; in reality, defaults only make a function viable, not necessarily the best match. Final Answer: The program will print the output 8.

Question 10

C++ operator overloading with a default argument on operator+ (member): compute the result of objA + 5 and print it.  #include <iostream.h>  class Addition {  int x; public:  Addition() { x = 0; }  Addition(int xx) { x = xx; }   Addition operator+(i…

Accepted Answer

Introduction / Context: This question validates understanding of member operator overloading and default arguments. A member operator+(int) computes a new Addition whose x is the receiver’s x plus the provided integer. Default arguments on operators are allowed in C++ and are not the cause of any compilation issue here. Given Data / Assumptions: objA is constructed with x = 15. Expression objA + 5 invokes Addition::operator+(int). The operator returns a new Addition with x = 15 + 5 = 20, then Display prints that value. Concept / Approach: Member operator+(int) is analogous to a method call objA.operator+(5). It builds a temporary result object with the sum and returns it by value. No undefined behavior occurs; the temporary is copied into objB. Step-by-Step Solution: Construct objA with x = 15; objB with default x = 0.Invoke objA + 5 → creates objTemp with x = 20.Assign objTemp to objB (copy elision may apply) → objB.x = 20.objB.Display() prints 20. Verification / Alternative check: If you omit the argument (objA + ), the default argument 0 would be used and the result would be 15. The code as written provides 5 explicitly. Why Other Options Are Wrong: Run time error / garbage: nothing invalid or uninitialized occurs. Compilation fails due to operator + cannot have default arguments.: False; operators may have default parameters like any function, subject to signature rules. Common Pitfalls: Confusing member versus non-member operator overload constraints, or assuming default arguments are disallowed for overloaded operators. Final Answer: The program will print the output 20.

Question 11

C++ overload resolution on (float, char, char): compute and print K from character arithmetic.  #include <iostream.h>  class CuriousTab {  int K; public:  void CuriousTabFunction(float, int, char);  void CuriousTabFunction(float, char, char); };  in…

Accepted Answer

Introduction / Context: The call selects the overload CuriousTabFunction(float, char, char) because both the second and third arguments are chars, which is a better match than promoting the second argument to int. The body then performs character arithmetic, relying on integer promotion rules, which can expose the signedness of char on the target platform. Given Data / Assumptions: Invocation: (15.09f, 'A', char('A' + 'A')). 'A' has code 65. char('A' + 'A') computes a char from 65 + 65 = 130. On implementations where plain char is signed (common on x86), char(130) becomes -126. K is assigned y + z after integer promotions. Concept / Approach: Overload selection chooses (float, char, char). Then y = 65 and z is the char resulting from 130, which on signed-char targets is -126. Adding with integer promotion gives 65 + (-126) = -61. The program prints this integer value. Step-by-Step Solution: Overload resolution: (float, char, char) is a better match than (float, int, char).Map y = 65.Compute z = char(130) → typically -126 when char is signed.Compute K = y + z = 65 + (-126) = -61.cout prints "K = -61". Verification / Alternative check: On systems where plain char is unsigned, char(130) stays 130 and K becomes 65 + 130 = 195. The provided options reflect both possibilities; the conventional assumption for such questions is signed char, yielding -61. Why Other Options Are Wrong: K = 130: Would be printed only if the function printed the intermediate assignment K = int(z) instead of the final sum. K = 195: Occurs on platforms with unsigned char; not the typical assumption here. K = -21: Does not match any consistent interpretation of char sums here. Compile time error: Both overloads are valid; one is selected unambiguously. Common Pitfalls: Forgetting that plain char may be signed or unsigned, expecting cout with char to print a glyph rather than an integer (here it prints an int), or assuming the (float, int, char) overload is chosen. Final Answer: The program will print the output K = -61.

Question 12

C++ (member access across objects) — predict the output printed by show() when it is invoked on an object whose fields were set just before the call.  #include<iostream.h> class Tab {  int x, y; public:  void show(void);  void main(void); }; void Ta…

Accepted Answer

Introduction / Context: This program tests understanding of member access across different instances of the same class in C++. The function show() constructs its own local object b but then prints the data members x and y of the current object (the one on which show() was called), not of the temporary b created inside show(). Given Data / Assumptions: Class Tab has two private ints: x and y. Tab::main creates a local object b, assigns b.x = 6 and b.y = 8, then calls b.show(). Tab::show creates its own local Tab b, sets b.x = 2 and b.y = 4, but prints x and y of the current object. Assume an older environment where is accepted (as used by many legacy MCQs). Concept / Approach: Within a non-static member function, an unqualified member name (x, y) refers to this->x and this->y. Creating another instance inside the member function does not change which object this points to. As a member, show() can assign to private members of any Tab instance it has a reference to, but the cout line is explicitly referencing the current object’s fields. Step-by-Step Solution: Construct local b in Tab::main and set b.x = 6, b.y = 8.Call b.show(). Inside show(), a new local Tab b is created and set to (2, 4).The cout statement prints this->x and this->y from the caller object, which are 6 and 8.Therefore the output is the two numbers: 6 8. Verification / Alternative check: Rename the inner object to b2 and print b2.x, b2.y to see 2 4; but the given code does not do that, it prints the caller’s fields. Why Other Options Are Wrong: 2 4: Would be printed only if the code printed the inner object’s members. Compilation/Link/Run-time errors: The code is valid in a legacy header setting and runs normally. Common Pitfalls: Assuming that the most recently declared variable b is what gets printed; forgetting that x and y refer to this->x and this->y. Final Answer: 6 8

Question 13

C++ (constructor overload selection and copy construction) — determine the output printed after constructing Derived via two different constructors.  #include<iostream.h> class Base {  int x, y; public:  Base() { x = y = 0; }  Base(int xx) { x = xx;…

Accepted Answer

Introduction / Context: This exercise probes C++ constructor resolution and object slicing versus copy construction. The class Derived has two user-declared constructors: one forwarding arguments to the Base subobject, and a second that takes a Base by value with a default argument. When we pass a Derived to new Derived(objD), which constructor is invoked and what state does the Base subobject hold when Display() is called? Given Data / Assumptions: Derived(int,int) builds a Base subobject via Base(xx, xx + 1). Derived(Base) is a converting constructor taking Base by value and doing nothing in its body. An implicit copy constructor Derived(const Derived&) is still generated by the compiler. Display() prints the Base subobject of the object it is called on. Concept / Approach: Overload resolution chooses the best match. Passing a Derived to construct another Derived makes the implicit copy constructor an exact match, which is better than converting to Base and calling Derived(Base). Therefore, new Derived(objD) uses the copy constructor, not the Derived(Base) overload. Step-by-Step Solution: Construct objD(5,3): Base subobject uses Base(5,6) so x = 5 + 6 = 11, y = 6.Copy-construct *ptrD from objD: the Base subobject is copied, so it also has x = 11, y = 6.Call ptrD->Display(): prints 11 6. Verification / Alternative check: If you forcibly call the converting constructor (e.g., new Derived(static_cast(objD))) then the Base subobject in the new object would default-construct to 0 0 because the body does nothing and no base initializer is provided. Why Other Options Are Wrong: 3 2, 8 3, 11 10: Do not match the actual Base state produced by the constructors shown. “Will not compile”: All declarations are valid in classic header context. Common Pitfalls: Assuming the presence of Derived(Base) suppresses the implicit copy constructor (it does not), or assuming the converting constructor will be chosen over the exact-match copy constructor. Final Answer: 11 6

Question 14

C++ (overload resolution with defaults) — which overload is selected and what value of x is printed?  #include<iostream.h> class CuriousTab {  int x; float y; public:  void CuriousTabFunction(int = 0, float = 0.00f, char = 'A');  void CuriousTabFunc…

Accepted Answer

Introduction / Context: This question examines overload resolution when two viable overloads accept parameters that can be formed from the same call via standard conversions, and where defaults supply missing arguments. It highlights that exact matches and promotions out-rank other standard conversions. Given Data / Assumptions: Call site: CuriousTabFunction(10 * 1.0, int(56.0)) i.e., arguments are double and int. Two likely candidates: (int, float, char = 'A') and (float, int, char = 'Z'). Third overload (char, char, char) is not viable for the given types without narrowing conversions to char. Concept / Approach: For the first parameter, both candidates require converting a double (to int or to float). For the second parameter, the (float, int, char) overload has an exact match for the provided int, while the (int, float, char) overload requires converting int to float. Therefore, the chosen overload is CuriousTabFunction(float, int, char) with zz defaulting to 'Z' (ASCII 90). Step-by-Step Solution: Select overload: (float, int, char).Compute x = zz + zz = 90 + 90 = 180.The function prints " x = 180". Verification / Alternative check: Force the other overload with an explicit cast: obj.CuriousTabFunction(int(10.0), float(56.0)) and the output will reflect x = 10 + 56. Why Other Options Are Wrong: 65, 66, 130 correspond to other letter sums or different overloads; not chosen here. Compilation failure does not occur; all overloads are valid. Common Pitfalls: Overlooking that the second parameter is an exact match for int in the float-int-char overload, which tips the ranking. Final Answer: The program will print the output x = 180.

Question 15

C++ (constructor selection, shadowing, and references) — determine the output after calling SetValue and Display.  #include<iostream.h> class CuriousTab {  int x; float y; public:  CuriousTab(int x) { x = x; }  CuriousTab(int p = 0, int q = 10) { x …

Accepted Answer

Introduction / Context: This question explores constructor overload choice when defaults are present, name shadowing inside constructors, the most-vexing parse, and effects of passing by reference. It asks what value is ultimately printed by Display(). Given Data / Assumptions: Two constructors: CuriousTab(int) and CuriousTab(int,int) (the latter has defaults). Call CuriousTab objCuriousTab(val); with val = 12. CuriousTab objTmp(); is a function declaration (most-vexing parse), not an object. SetValue(int& y, float z) assigns to the member and mutates the caller’s variable. Concept / Approach: Overload resolution prefers the exact single-argument match (CuriousTab(int)) over using a default parameter in the two-argument constructor. Inside that constructor, the parameter name shadows the member, so x = x; assigns the parameter to itself and leaves the member x uninitialized (though it will be assigned later). SetValue(val, 3.14f) sets the member x to 12 and then casts 3.14f to 3 and stores it back into val via the reference. Step-by-Step Solution: Select one-arg ctor: member x remains uninitialized but will be set next.Call SetValue: assign x = y → x = 12; then y = (int)z → caller’s val becomes 3.Display prints the current member x, which is 12. Verification / Alternative check: Had the two-arg ctor been chosen, x would become p += 2. But default-argument overload is not preferred over the exact one-parameter constructor here. Why Other Options Are Wrong: 2: Misreads the second constructor as selected. Errors: The program compiles and runs (with legacy headers). Common Pitfalls: Name shadowing in constructors (x = x;) and misinterpreting CuriousTab objTmp(); as an object instead of a function declaration. Final Answer: The program will print the output 12.

Question 16

C++ strings (C-style) — predict the concatenated message built by the constructor with default parameters and print via Display(). #include #include class CuriousTabString { char x[50]; char y[50]; char z[50]; public: Curiou…

Accepted Answer

Introduction / Context: This item checks understanding of C-style string operations (strcpy, strcat) and how default parameters work when some but not all constructor arguments are provided. The Display() method prints the buffer z built by the three-argument constructor. Given Data / Assumptions: Constructor signature: (char* xx, char* yy = " C++", char* zz = " Programming!"). Call: CuriousTabString objStr("Learn", " Java"); so xx = "Learn", yy = " Java", zz takes the default " Programming!". Buffers are large enough for the concatenation in this example. Concept / Approach: The constructor copies xx into z, then concatenates yy, then concatenates zz. Because yy and zz include leading spaces, they create word spacing naturally in the result. Step-by-Step Solution: Start with z = "Learn".Concatenate yy: z = "Learn Java".Concatenate default zz: z = "Learn Java Programming!".Display() prints the final string. Verification / Alternative check: Changing the call to ("Learn") would use the one-parameter constructor and not initialize z; Display() would then print an uninitialized buffer (undefined). The two-parameter constructor is the correct usage here. Why Other Options Are Wrong: Other choices either omit the Learn prefix or use the wrong defaults ordering. Common Pitfalls: Forgetting that default arguments keep their specified leading spaces; omitting them causes words to touch. Final Answer: Learn Java Programming!

Question 17

C++ (recursion with default arguments in a member function) — does the call terminate or loop forever, and what would be printed?  #include<iostream.h> class CuriousTab { public:  void CuriousTab(int x = 15) {  x = x / 2;  if (x > 0)  CuriousTab(); …

Accepted Answer

Introduction / Context: This snippet highlights a common trap: recursion with a default parameter that is re-applied at each call. Although the body halves a variable and seems to move toward a base case, the recursive call does not pass that new value along, so the base case is never reached. Given Data / Assumptions: Member function signature: void CuriousTab(int x = 15). Body halves x and recurses with CuriousTab() (no argument). Default argument value 15 is used whenever the call omits the parameter. Concept / Approach: Each recursive call with no explicit argument uses the default, setting x to 15 again, then halving to 7, then recursing again with the default, and so on. The halved value is never propagated into the next call, so the condition x > 0 remains true on every activation until the call stack overflows or the runtime aborts, i.e., it behaves like an infinite loop (non-terminating recursion). Step-by-Step Solution: Initial call: default x = 15 → x = 7.Recursive call with no argument applies default again: x = 15 → 7.This process repeats indefinitely; the else branch is never reached. Verification / Alternative check: Fix by passing the updated value: CuriousTab(x). Then the sequence 15 → 7 → 3 → 1 → 0 will terminate, printing 0 % 2 = 0. Why Other Options Are Wrong: Printing 1, 2, or 15 presumes termination; it does not terminate. Compilation error does not occur; the code is syntactically valid. Common Pitfalls: Confusing default arguments with persistent state, and forgetting that defaults are reapplied at each call when the argument is omitted. Final Answer: The program will go into an infinite loop.

Question 18

C++ (name qualification in multiple-base-like contexts) — evaluate the printed sum after calling the specifically qualified BaseTwo::Display.  #include<iostream.h> static double gDouble; static float gFloat; static double gChar; static double gSum =…

Accepted Answer

Introduction / Context: This question reinforces qualified calls to resolve ambiguity in multiply-inherited interfaces and shows how arguments flow into a function with defaults overridden at the call-site. The output is a straightforward arithmetic sum of three values stored in globals. Given Data / Assumptions: We explicitly call objDev.BaseTwo::Display(10, 20, 'Z'). Inside BaseTwo::Display, the globals are set and gSum is computed as the sum of the three converted values. 'Z' has integer code 90. Concept / Approach: The computation uses gDouble = 10, gFloat = 20.0f, gChar = 90, so the sum is 10 + 20 + 90. The function itself streams that sum via cout, so the visible output is the numeric result. Step-by-Step Solution: Assign inputs: 10, 20, 'Z'.Convert and store: 10.0, 20.0f, 90.0.Compute: gSum = 10 + 20 + 90 = 120.Print gSum. Verification / Alternative check: Calling BaseOne::Display(10.0, 20.0f, 'Z') would compute the same numeric sum since the same values are used after conversions. Why Other Options Are Wrong: 0 / garbage: contradicts the explicit arithmetic. Errors: The qualified call resolves any ambiguity; the code compiles and runs. Common Pitfalls: Forgetting to qualify the call in multiple inheritance, which would make the call ambiguous and fail to compile. Final Answer: The program will print the output 120.

Question 19

C++ (recursion with static indices and post-recursion swapping) — determine the final array order printed by Display().  #include<iostream.h> struct CuriousTabArray {  int arr[5]; public:  void CuriousTabFunction();  void Display(); }; void CuriousT…

Accepted Answer

Introduction / Context: This problem checks your ability to trace a recursive function that uses static indices and performs its swap operations after unwinding recursion. The order of operations (pre-recursion index update, then post-recursion swap) is crucial to the final arrangement of the array elements. Given Data / Assumptions: Initial array: [5, 6, 3, 9, 0]. Static indices start at i = 0, j = 4. Each call increments i, decrements j, recurses while j > 0, then swaps arr[i] and arr[j] while unwinding. Concept / Approach: Because the swap happens after recursion returns, the deepest frame swaps the ends first, then higher frames swap inner pairs, potentially swapping some positions back depending on indices restored by the static variables. Carefully tracking the evolving values of i and j is the key. Step-by-Step Solution: Deepest frame (after updates): swap indices 4 and 0 → [0, 6, 3, 9, 5]; i=3, j=1.Next: swap indices 3 and 1 → [0, 9, 3, 6, 5]; i=2, j=2.Next: swap indices 2 and 2 (no change) → remains [0, 9, 3, 6, 5]; i=1, j=3.Next: swap indices 1 and 3 → [0, 6, 3, 9, 5]; i=0, j=4. Verification / Alternative check: Compare with a version that performs the swap before recursion; it yields a different ordering (see next question for a variant). Why Other Options Are Wrong: Other sequences do not match the exact swap order based on post-recursion operations with static indices. Common Pitfalls: Forgetting that i and j are static and persist across frames; assuming each function activation has its own i, j. Final Answer: 0 6 3 9 5

Question 20

C++ (recursion with static indices and pre-recursion swapping) — determine the array order produced and printed.  #include<iostream.h> struct CuriousTab {  int arr[5]; public:  void CuriousTabFunction(void);  void Display(void); }; void CuriousTab::…

Accepted Answer

Introduction / Context: This follow-up uses the same static-index idea but performs the swap before recursion. The base condition is j != i, so recursion stops when the two indices meet at the center. You must trace the swaps carefully with persistent i, j to get the final array ordering. Given Data / Assumptions: Initial array: [5, 6, 3, 9, 0]. Static i = 0, j = 4. Each call swaps arr[i] with arr[j], then increments i and decrements j. Concept / Approach: Because the swap occurs immediately, we reverse pairs from the outermost inward, then stop when i == j. With static variables, each recursive frame sees updated indices rather than independent copies. Step-by-Step Solution: Call 1: swap 0↔4 → [0, 6, 3, 9, 5]; then i=1, j=3; recurse (1 != 3).Call 2: swap 1↔3 → [0, 9, 3, 6, 5]; then i=2, j=2; stop (2 == 2).Display prints: 0 9 3 6 5. Verification / Alternative check: Compare with the variant that swaps after recursion; you will notice the middle positions differ because of the different order of operations. Why Other Options Are Wrong: Other sequences do not match the exact swap-before-recursion trace. Common Pitfalls: Thinking that recursion will reverse the entire array including the center twice; the stopping condition prevents that. Final Answer: 0 9 3 6 5

Functions Questions