Functions and Recursion : MCQs & PYQs with Explanation

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 B

In C++, when a function parameter is passed using a reference using & (Call by Reference), it means the function works directly on the original variable, not on a copy. Any change made inside the function will affect the original variable.
Here, the function check(int &arg1) takes the argument by reference. In main(), the variable arg is initialized to 10 and passed to the function. Inside the function, arg1=550; modifies the same memory location as arg.
So, after the function call, the value of arg becomes 550.

Option C

In C/C++, the inline keyword is used to suggest the compiler to replace a function call with the actual code of the function. This means that instead of jumping to the function during execution, the compiler directly inserts the function’s code wherever it is called.
This substitution, occurs at compile time and can improve performance for small, frequently called functions by reducing execution time, though it may increase the overall program size due to code duplication.
#include <iostream>
using namespace std;
inline int add(int a, int b)
{
    return(a+b);
}

int main()
{
    int x=5, y=3;
    int result=add(x,y);
    cout<<"Addition: "<<result;
    
    return 0;
}
In this, instead of calling the add() function normally, the compiler may replace add(x,y) with x+y directly in the code.
Note:

• The inline is only a request, not a command. The compiler may ignore it if the function is too large, complex, involves loops or recursion. So, inline expansion is not guaranteed.
• The inline functions are generally defined in header files because the compiler needs to see the function definition wherever it is used.
• It increases code size. Since the function code is copied at every call.
• The functions with loops, recursion, or static variables are usually not inlined by the compiler because they are complex to expand.
• The functions defined inside a class are automatically treated as inline if defined inside the class body.

Finally, inline functions are best suited for small, simple, frequently called functions, such as getters or small arithmetic operations.

Option A

In C++, a static member function belongs to the class rather than to the objects of the class. It is declared using the static keyword.
A static member function:

• can access only static data members and other static member functions directly, and
• it can be called using the class name without creating any object.

#include<iostream>
using namespace std;
class Demo
{
    static int a;
public:
    static void show()
    {
        cout<<a;
    }
};
int Demo::a=10;
int main()
{
    Demo::show();
    return 0;
}

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

In C++, an inline function is a function whose code is expanded or copied at the place where it is called, instead of performing a normal function call. This helps in reducing function call overhead and improves performance for small functions.

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 D

In C++, a function prototype is a declaration of a function that provides information to the compiler before the function is actually defined. It tells the compiler how the function will be used.
A function prototype specifies:

• the return type of the function.
• the name of function.
• the number and types of arguments.

Syntax:

• Return_Type FunctionName(ArgumentList);

E.g.:

• int addition(int,int);

Option B

In C++, a friend function is a special function that is not a member of a class but is still allowed to access its private and protected members. This is done using the friend keyword inside the class definition.
For example, a function declared as friend inside a class can directly access private variables of that class, even though it is defined outside the class.
E.g.:
#include <iostream>
using namespace std;
class Demo
{
    private:
    int a;
    public:
    Demo() 
    { 
        a=22;
    }
    friend void showData(Demo);
};
void showData(Demo d1)
{
    cout<<"Value : "<<d1.a; // Accessing private member.
}
int main()
{
    Demo obj;
    showData(obj);
    return 0;
}
OUTPUT
Value : 22

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.