Function Practice Questions

The provided code contains multiple compilation errors:

1. The function definition int{char &m} is invalid C++ syntax.
2. In the call b(a(q)), the function a(q) returns an int rvalue, which cannot be bound to the non-const reference parameter int& m defined in function b.
3. In c(r), the function c expects a reference of type char&, but passing an int variable r leads to a type mismatch, as a reference cannot bind to an incompatible type.

Because these violations violate C++ standards, the program fails to compile.

The given recurrence relations are $f(x) = f(x-1) + g(x)$ and $g(x) = f(x-1) + g(x/2)$. Substituting the definition of $g(x)$ into the equation for $f(x)$, we obtain $f(x) = f(x-1) + f(x-1) + g(x/2) = 2f(x-1) + g(x/2)$. For large $x$, the term $g(x/2)$ grows much more slowly than $f(x)$, making the recurrence approximately $f(x) \approx 2f(x-1)$. A recurrence relation of the form $f(x) = af(x-1)$ where $a > 1$ represents exponential growth. Thus, $f(x)$ grows at a rate proportional to $2^x$.

The C program calculates a value recursively and prints the final count of function calls. The global variable counter is incremented each time the calc function is entered.

The initial call is calc(4, 81). The function calls itself with b divided by 3 until b equals 3.

1. calc(4, 81): counter becomes 1. Calls calc(4, 27).
2. calc(4, 27): counter becomes 2. Calls calc(4, 9).
3. calc(4, 9): counter becomes 3. Calls calc(4, 3).
4. calc(4, 3): counter becomes 4. The base case b==3 is met, and the function returns.

The main function then prints the final value of counter, which is 4.

The function fun1 receives pointers by value. Swapping the local copies of the pointers s1 and s2 inside fun1 does not alter the original pointers str1 and str2 in the main function. Thus, the first printf outputs "Hi Bye". In contrast, fun2 receives pointers to pointers (pass-by-reference). Dereferencing them allows fun2 to swap the actual pointers str1 and str2 in main. After the call to fun2, str1 points to "Bye" and str2 points to "Hi". The second printf therefore outputs "Bye Hi".

The function $swap(\int \ a, \int \ b)$ uses pass-by-value, where local parameters $a$ and $b$ receive copies of the values from arguments $x$ and $y$. Modifying $a$ and $b$ inside the function only updates these local copies, leaving the original variables $x$ and $y$ in the calling scope unchanged. Thus, the operation does not result in the desired exchange of values. This occurs because the function lacks access to the memory addresses of $x$ and $y$, making option D the correct explanation.

This problem requires tracing the execution of two mutually recursive functions. The call sequence starting with fun1(5) is as follows:

• fun1(5) prints 5, calls fun2(3).
• fun2(3) prints 3, calls fun1(4).
• fun1(4) prints 4, calls fun2(2).
• fun2(2) prints 2, calls fun1(3).
• fun1(3) prints 3, calls fun2(1).
• fun2(1) prints 1, calls fun1(2).
• fun1(2) prints 2, calls fun2(0) which returns, then prints 2 again.
  As the function calls return, the second printf statement in each function's body is executed. Tracing the entire sequence of prints gives the output 53423122233445.

The function call square(&number, &number) aliases both pointers x and y to the memory address of number, which is initially $30$.
In the expression *x = (*x) * --(*y), the compiler evaluates the left operand *x before the side effect on the right operand --(*y).
Thus, *x is evaluated as $30$.
Next, the side effect --(*y) decrements the shared number from $30$ to $29$.
The multiplication $30 \times 29$ is then performed, resulting in $870$.
Finally, this result is assigned back to number, which is then printed by the cout statement.

In the declaration int (*f) (int *);, the parentheses grouping (*f) signifies that $f$ is a pointer.
Because $f$ is followed by (int *), the pointer must refer to a function.
The argument list (int *) indicates that the function takes an integer pointer $\int *$ as its parameter.
The leading $\int$ specifies that the function returns an integer.
Therefore, $f$ is a pointer to a function that takes an integer pointer and returns an integer.

The global variable $tmp$ is initialized to $20$. In main(), the first printf("%d", tmp) outputs the value of the global $tmp$, which is $20$. When func() is called, it defines a local variable static int tmp initialized to $10$, which shadows the global variable within the function's scope. Inside func(), printf("%d", tmp) outputs $10$. Finally, control returns to main(), where the second printf("%d", tmp) accesses the original global $tmp$ again, outputting $20$. Thus, the resulting sequence is $20$ $10$ $20$.

The key to this program is the static int count variable inside the total function. A static local variable is initialized only once and retains its value across function calls.
The total(v) function adds the number of set bits of v to the persistent count and returns the new count. The main function then adds this returned value to x.

Let's trace the values of count (in total) and x (in main):

• Initially: count = 0, x = 0.
• i=5: total(5) adds 2 (for bits in '101') to count. count becomes 2. total returns 2. x = 0 + 2 = 2.
• i=4: total(4) adds 1 (for bit in '100') to count. count becomes $2+1=3$. total returns 3. x = 2 + 3 = 5.
• i=3: total(3) adds 2 (for bits in '011') to count. count becomes $3+2=5$. total returns 5. x = 5 + 5 = 10.
• i=2: total(2) adds 1 (for bit in '010') to count. count becomes $5+1=6$. total returns 6. x = 10 + 6 = 16.
• i=1: total(1) adds 1 (for bit in '001') to count. count becomes $6+1=7$. total returns 7. x = 16 + 7 = 23.

The final value printed for x is 23.

The function foo(val) contains the recursive call foo(val--). The post-decrement operator means foo is called with the same value of val repeatedly, leading to infinite recursion. This will exhaust the call stack and cause an abnormal program termination (stack overflow).

The function bar(val) contains the recursive call bar(val-1). This recursion has a base case when val becomes 0. However, the recursive call is inside a while(val > 0) loop. The value of val is never modified within the loop's scope, so once the recursion returns, the while condition remains true, and the function enters an infinite loop.

The function count is called recursively, and it uses a static integer d. A static variable is initialized only once.

1. count(3) is called. It prints n=3, d=1. d becomes 2. It calls count(2).
2. count(2) is called. It prints n=2, d=2. d becomes 3. It calls count(1).
3. count(1) is called. It prints n=1, d=3. d becomes 4. The recursion stops. It then prints d=4 before returning.
4. Execution returns to count(2), which prints d=4.
5. Execution returns to count(3), which prints d=4.
   The full output is the concatenation of these print statements.

The function mystery takes two integer pointers, ptra and ptrb, as arguments. Inside the function, it swaps the values of these local pointer variables. Since C passes arguments by value, the function receives copies of the addresses of a, b, and d. Swapping these copies inside mystery has no effect on the original variables a, b, and d in the main function. The if (a < c) condition (2016 < 4) is false, so the second call is skipped. The value of a remains unchanged from its initial value of 2016, which is what gets printed.

The program calculates a value by recursively calling the function f(p, n). Let's trace the execution with the input array a = {3, 5, 2, 6, 4} and size n=5.

• f(a, 5) returns max(f(a+1, 4), a[0]-a[1]) = max(f(a+1, 4), 3-5=-2).
• f(a+1, 4) returns max(f(a+2, 3), a[1]-a[2]) = max(f(a+2, 3), 5-2=3).
• f(a+2, 3) returns max(f(a+3, 2), a[2]-a[3]) = max(f(a+3, 2), 2-6=-4).
• f(a+3, 2) returns max(f(a+4, 1), a[3]-a[4]) = max(f(a+4, 1), 6-4=2).
• f(a+4, 1) is the base case (n <= 1), so it returns 0.

Unwinding the recursion:

• The call f(a+3, 2) returns max(0, 2) = 2.
• The call f(a+2, 3) returns max(2, -4) = 2.
• The call f(a+1, 4) returns max(2, 3) = 3.
• Finally, the initial call f(a, 5) returns max(3, -2) = 3.
  The value printed is 3.

The function f requires parameters of type (int, short).
Option A and C are invalid because s is a short variable, not a pointer; therefore, *s causes a compilation error.
Option B is invalid because f returns void, meaning the assignment i = f(i, s) is a type-checking error.
In Option D, i is an int and *p dereferences the short *p pointer to yield a short value.
Since *p is of type short, the call f(i, *p) perfectly matches the required signature (int, short).

In $C$, the use of function pointers allows the target function to be determined dynamically at runtime based on the pointer's value, meaning not all calls are resolved at compile time. Similarly, in $C++$, polymorphism implemented via virtual functions requires dynamic dispatch (typically using a $vtable$), which resolves function calls at runtime depending on the actual type of the object. Since both languages support dynamic binding, neither statement is universally true for all function calls. Consequently, both Statement I and Statement II are incorrect.

The program defines a function f and a main function. Let's trace the execution:

1. In main, i is initialized to 5 and j to 10.
2. f(&i, j) is called:
   • p points to i (so *p is 5).
   • m is a local copy of j (so m is 10).
   • m becomes 10 + 5 = 15.
   • *p (which is i) becomes 5 + 15 = 20.
3. Back in main, i is now 20, and j is still 10 (since m was a local copy).
4. printf("%d", i+j) prints 20 + 10 = 30.

[CORRECT_OPTION: N/A]

The execution is traced assuming dynamic scoping and pass-by-reference.

1. main calls m(a). Global a is 3. y in m is a reference to global a.
2. In m, a=1 creates a new local variable a. Then a = y - a evaluates to a = 3 - 1 = 2. So, m's local a is 2.
3. n(a) is called. Per the PDF's logic, this behaves like pass-by-value, so x in n gets the value 2.
4. In n, x = x * a. With dynamic scoping, a refers to the a in the caller m, which is 2. So, x = 2 * 2 = 4. print(x) outputs 4.
5. n returns. Since the call was effectively pass-by-value, m's local a is unchanged and remains 2. print(a) in m outputs 2.