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 D

A friend function is a function that is not a member of a class, but it is declared inside the class using the friend keyword. 
A friend function is granted special permission to access all members of the class, including private, protected, and public members.
Although a friend function is defined outside the class, it can access the class private and protected data just like a member function.

#include <iostream>
using namespace std;
class Student
{
private:
    int marks=90;
protected:
    int rollNo=101;
public:
    char name[20]="Suresh Kulahry";
    friend void display(Student);
};
void display(Student st)
{
    cout <<"Roll No : "<<st.rollNo<<endl;
    cout <<"Name : "<<st.name<<endl;
    cout <<"Marks : "<<st.marks<<endl;
}
int main()
{
    Student std;
    display(std);
    return 0;
}
OUTPUT
Roll No : 101
Name : Suresh Kulahry
Marks : 90

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.