Functions Questions

C++ loop with pre-incremented counter and default parameters: what value does PowerFinder::Power print for (2, 6)? #include<iostream.h> class PowerFinder { public: void Power(int x = 1, int y = 1) { int P = 1, i = 1; while (++i <= y) { P *= x; } cout << P << endl; } }; int main() { PowerFinder FP; FP.Power(2, 6); return 0; }

C++ default parameters and base-class constructor: what does this program print when calling CountIt with two arguments? #include<iostream.h> class BaseCounter { protected: long int count; public: void CountIt(int x, int y = 10, int z = 20) { count = 0; cout << x << " " << y << " " << z << endl; } BaseCounter() { count = 0; } BaseCounter(int x) { count = x; } }; class DerivedCounter : public BaseCounter { public: DerivedCounter() { } DerivedCounter(int x) : BaseCounter(x) { } }; int main() { DerivedCounter objDC(30); objDC.CountIt(40, 50); return 0; }

C++ default argument as null pointer to a 2D array parameter and uninitialized storage: what will this program display? #include<iostream.h> class CuriousTabArray { int array[3][3]; public: CuriousTabArray(int arr[3][3] = NULL) { if (arr != NULL) for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) array[i][j] = i + j; } void Display(void) { for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) cout << array[i][j] << " "; } }; int main() { CuriousTabArray objBA; // uses default argument NULL objBA.Display(); return 0; }

C++ default parameter override: what exact output is produced by this call? #include<iostream.h> void MyFunction(int a, int b = 40) { cout << " a = " << a << " b = " << b << endl; } int main() { MyFunction(20, 30); return 0; }

C++ function pointer to a function with defaults: what does Note(30) print when it calls Look(x) with a missing second argument? #include<iostream.h> typedef void(*FunPtr)(int); int Look(int = 10, int = 20); void Note(int); int main() { FunPtr ptr = Note; (*ptr)(30); return 0; } int Look(int x, int y) { return (x + y % 20); } void Note(int x) { cout << Look(x) << endl; // calls Look(x, 20) }

C++ overload resolution on integral and floating return types: which overload is called and what is printed? #include<iostream.h> long GetNumber(long int Number) { return --Number; } float GetNumber(int Number) { return ++Number; } int main() { int x = 20; int y = 30; cout << GetNumber(x) << " "; cout << GetNumber(y); return 0; }

C++ evaluation order with pre/post operators and defaults: what does this call print? #include<iostream.h> int CuriousTabFunction(int a, int b = 3, int c = 3) { cout << ++a * ++b * --c; return 0; } int main() { CuriousTabFunction(5, 0, 0); return 0; }

In C++ (recursion with a static index over a C-string), what does the following program print when searching for the character 't' in the message "Welcome to CuriousTab.com!"? #include<iostream.h> #include<string.h> class CuriousTab { char txtMsg[50]; public: CuriousTab(char *str = NULL) { if(str != NULL) strcpy(txtMsg, str); } int CuriousTabFunction(char ch); }; int CuriousTab::CuriousTabFunction(char ch) { static int i = 0; if(txtMsg[i++] == ch) return strlen((txtMsg + i)) - i; else return CuriousTabFunction(ch); } int main() { CuriousTab objCuriousTab("Welcome to CuriousTab.com!"); cout << objCuriousTab.CuriousTabFunction('t'); return 0; }

In C++ (assignment in a conditional), analyze the following program and determine what is printed by Display(). Note the deliberate use of "if (l = 0)" vs "if (l == 0)". #include<iostream.h> class AreaFinder { float l, b, h; float result; public: AreaFinder(float hh = 0, float ll = 0, float bb = 0) { l = ll; b = bb; h = hh; } void Display(int ll) { if(l = 0) result = 3.14f * h * h; else result = l * b; cout << result; } }; int main() { AreaFinder objAF(10, 10, 20); objAF.Display(0); return 0; }

In C++ (default arguments and pre-increment effects), evaluate the function call and compute the exact integer result. #include<iostream.h> long CuriousTabFunction(int x, int y = 5, float z = 5) { return (++x * ++y + (int)++z); } int main() { cout << CuriousTabFunction(20, 10); return 0; }

In C++ (overload resolution with default parameters), what does the following program print? Focus on which Addition overload is selected in each call. #include<iostream.h> struct MyData { public: int Addition(int a, int b = 10) { return (a *= b + 2); } float Addition(int a, float b); }; int main() { MyData data; cout << data.Addition(1) << " "; cout << data.Addition(3, 4); return 0; }

In C++ (const parameters and integer arithmetic), determine the output of the following code. Consider integer operator precedence and the final multiplication by 0.2. #include<iostream.h> const double CuriousTabConstant(const int, const int = 0); int main() { const int c = 2; cout << CuriousTabConstant(c, 10) << " "; cout << CuriousTabConstant(c, 20) << endl; return 0; } const double CuriousTabConstant(const int x, const int y) { return ( (y + (y * x) * x % y) * 0.2 ); }

In C++ (constructor selection with defaults and a derived-class initializer), what does this program print? Pay attention to which Base constructor is called and the values assigned. #include<iostream.h> class Base { public: int S, A, M; Base(int x, int y) { S = y - y; A = x + x; M = x * x; } Base(int, int y = 'A', int z = 'B') { S = y; A = y + 1 - 1; M = z - 1; } void Display(void) { cout << S << " " << A << " " << M << endl; } }; class Derived : public Base { int x, y, z; public: Derived(int xx = 65, int yy = 66, int zz = 67) : Base(x) { x = xx; y = yy; z = zz; } void Display(int n) { if(n) Base::Display(); else cout << x << " " << y << " " << z << endl; } }; int main() { Derived objDev; objDev.Display(-1); return 0; }

In C++ (default arguments and implicit conversions), what does this nested class call print? Pay attention to how the char literal 'b' matches the float defaulted parameter. #include<iostream.h> struct MyStructure { class MyClass { public: void Display(int x, float y = 97.50, char ch = 'a') { cout << x << " " << y << " " << ch; } } Cls; } Struc; int main() { Struc.Cls.Display(12, 'b'); return 0; }

In C++ (default pointer argument bound to a static global), what is printed? Note that a local variable named b shadows the global, but the call passes both pointers explicitly. #include<iostream.h> static int b = 0; void DisplayData(int *x, int *y = &b) { cout << *x << " " << *y; } int main() { int a = 10, b = 20; DisplayData(&a, &b); return 0; }

In C++ (recursive digit processing with a static accumulator), what number is printed for the initial value 12345? #include<iostream.h> class CuriousTab { int Num; public: CuriousTab(int x) { Num = x; } int CuriousTabFunction(void); }; int CuriousTab::CuriousTabFunction(void) { static int Sum = 0; int Dec; Dec = Num % 10; Num = Num / 10; if((Num / 100)) CuriousTabFunction(); Sum = Sum * 10 + Dec; return Sum; } int main() { CuriousTab objCuriousTab(12345); cout << objCuriousTab.CuriousTabFunction(); return 0; }

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[j][i] = i + j; } void Display(void) { for(int i = 0; i < 3; i++) for(int j = 0; j < 3; j++) cout << Matrix[j][i] << " "; } }; int main() { CuriousTabArray objCuriousTab; objCuriousTab.Display(); return 0; }

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 << FactFinder() << endl; // calls FactFinder(5) return 0; } long FactFinder(long x) { if (x < 2) return 1; long fact = 1; for (long i = 1; i <= x - 1; i++) fact = fact * i; // multiplies up to x-1 return fact; }

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 class CuriousTab { int x; int y; public: void Tester(int xx, int yy = 5) { x = xx; y = yy; cout << ++x % --y; } }; int main() { CuriousTab objCuriousTab; objCuriousTab.Tester(5, 5); return 0; }

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(); }; void Number::Modify() { int Dec; Dec = Num % 13; Num = Num / 13; if (Num > 0) Modify(); if (Dec == 10) cout << "A"; else if (Dec == 11) cout << "B"; else if (Dec == 12) cout << "C"; else if (Dec == 13) cout << "D"; // unreachable for base-13 remainders else cout << Dec; } int main() { Number objNum(130); objNum.Modify(); return 0; }