CS Free MCQ Bank

[ Option C ]

Here the concept used is function with default argument. The key rule:

• Default arguments are applied from right to left.
• The first parameter cannot have a default value. So, at least the first argument must be supplied in a function call.
• Type-compatible values like char to int are allowed due to implicit type conversion.

Now check each calling statement: 

• The (I) demo(23); is valid and a=23, b=10 (default), c=5 (default).
• The (II) demo(); is invalid because the first argument a has no default value, so at least one argument is required.
• The (III) demo(10,20,30); is valid, all arguments are explicitly provided.
• The (IV) demo(14,15); is valid and a=14, b=15, c=5 (default).
• The (V) demo('a','b','c'); is valid, character constants are implicitly converted to integers.
• The (VI) demo(5,'c');is valid, 'c' is converted to int, and c takes the default value 5.

[ Option A ]

When a function is called in a program, the system needs to perform several additional operations apart from executing the actual function code. These operations include passing arguments from the calling function to the called function, transferring control (jumping) to the function’s code, and after execution, returning control back to the calling function along with any return value.
An inline function reduces this overhead by replacing the function call with the actual function code at the place where it is called.
inline int add(int a, int b)
{
    return a+b;
}
Here, instead of calling add(), the compiler directly inserts a+b, which saves execution time.

[ Option B ]

In C++, a variable declared inside a user-defined function has local scope, meaning it is accessible only within the curly braces { } block of that function. It cannot be accessed from other functions or outside the function in which it is declared. Once the function execution ends, the variable is destroyed and its memory is released.

[ Option C ]

Normally, factorial of n is calculated as n*factorial(n-1). Here, factorial(a+1) increases a instead of decreasing it, so the function never reaches the base case (a<=1). This causes infinite recursion, which eventually overflows the stack.
When the program runs, it will produce a runtime error called a segmentation fault, because the system runs out of memory due to too many recursive calls.

[ Option B ]

Inline functions in C++ are meant to improve performance by avoiding the overhead of a function call. Instead of jumping to a function and returning back, the compiler substitutes the function’s code directly at the place where it is called. 
This helps save time, especially for small and frequently used functions. However, inline functions are not supposed to be large or complex.

[ Option C ]

In this C++ program, the function change is defined to take an integer reference as its parameter (int &x). Passing by reference (call by reference) means any changes made to x inside the function will directly affect the original variable passed in.

[ Option B ]

A friend function is not a member of the class, even though it is allowed to access the private, protected, or public members of that class. Friend functions are declared inside the class using the friend keyword.

• They do not belong to the class, so they do not have this pointer.
• Friend functions are mostly used where, if two or more classes want to share a common function means friend function can be a friend of more than one class.

[ Option D ]

In C++, default arguments are values provided to function parameters at the time of function declaration. These default values are automatically used when the function call does not supply enough arguments.

• If all arguments are provided during the call, the default values are ignored.

#include <iostream>
using namespace std;
void addition(int x, int y=0, int z=0)
{
    int p=x+y+z;
    cout<<"Addition : "<<p<<endl;
}
int main()
{
    addition(10);
    addition(10,20);
    addition(10,20,30);
    return 0;
}
OUTPUT
Addition : 10
Addition : 30
Addition : 60

[ Option A ]

An inline function is a function whose code is substituted at the place of function call by the compiler to reduce function call overhead.
However, inline expansion is not suitable in certain cases, especially when it increases code size unnecessarily.
If a function contains a loop, inlining it may cause the loop body to be copied multiple times, resulting in larger code. Therefore, such functions are generally not considered inline.

[ Option B ]

In the given C++ code, two overloaded versions of the function myfunc are defined—one taking a single int parameter and another taking two int parameters. Correspondingly, two function pointers are declared:

• int (*fp)(int a, int b);    // Pointer to function for function with two int parameters
• int (*fp1)(int a);          // Pointer to function for function with one int parameter

When assigning an overloaded function to a function pointer, the type of the pointer determines which overload is selected. Since fp is of type int (*)(int, int), it correctly binds to myfunc(int, int), and similarly, fp1 binds to myfunc(int).