Polymorphism (Function and Operator Overloading, Virtual Functions) : MCQs & PYQs with Explanation

Option B

A virtual function is a member function of a base class that is declared using the virtual keyword. It is intended to be redefined (overridden) in the derived class.
Virtual functions enable runtime polymorphism (dynamic binding), which means that the function to be executed is determined at runtime based on the type of the object.

Option C

In C++, function overloading and function overriding are two different concepts used to achieve polymorphism.
Function overloading occurs when multiple functions have the same name but different parameter lists in the same scope. The compiler decides which function to call at compile time, so overloading is an example of static (compile-time) binding.
Function overriding occurs when a derived class provides its own implementation of a function that already exists in the base class with the same signature. The function call is resolved at run time, so overriding is an example of dynamic (run-time) binding.

Option A

Compile-time polymorphism in C++ means the decision about which function to invoke is made during compilation, not at runtime. There are two main features in C++ that support compile-time polymorphism:

• Function overloading
  • Templates
• Operator overloading

Templates enable generic programming, where functions or classes can work with different data types without being rewritten. The compiler generates code at compile-time for each data type used, which is compile-time polymorphism.

Option A

In C++, when a derived class defines a function with the same name and parameters as a function in the base class, the base class function is overridden (or hidden).
To access the overridden function of the base class from the derived class, the Scope Resolution Operator (::) is used.

#include <iostream>
using namespace std;
class Base
{
public:
    void display()
    {
        cout << "Base Class display()"<<endl;
    }
};
class Derived : public Base
{
public:
    void display()
    {
        cout << "Derived Class display()"<<endl;
    }
    void show()
    {
        Base::display();
    }
};
int main()
{
    Derived obj;
    obj.display();
    obj.show();
    return 0;
}
OUTPUT
Derived Class display()
Base Class display()

Option C

In C++, a pure virtual function is a virtual function that has no implementation in the base class and is declared using =0.
virtual void display()=0; //Pure-Virtual Function.
A class that contains at least one pure virtual function is called an abstract class.

• An abstract class cannot be instantiated means objects cannot be created.
• It is used as a base class to enforce that derived classes must implement the pure virtual function.

Option C

An abstract class in C++ is a class that is designed only to be a base class and cannot be instantiated on its own mean we cannot create object of abstract class.
The key feature of an abstract class is that it contains at least one pure virtual function. A do-nothing function is called pure virtual function which is declared using the syntax virtual returnType functionName() = 0;.
Derived classes must override these pure virtual functions to provide a concrete implementation.

Option B

Here, fun() in the base class is virtual, which means if a base class pointer points to a derived class object, the derived class function will be called.

Option C

In object-oriented programming (C++), function overriding occurs when a derived class provides its own implementation of a function that is already defined in the base class, with the same signature.

• This supports runtime polymorphism, usually with virtual functions.

#include <iostream>
using namespace std;
class Base
{
    public:
    virtual void show()
    {
        cout<<"Base class show() Called."<<endl;
    }
};
class Derived : public Base 
{
    public:
    void show()
    {
        cout<<"Derived Class show() Called."<<endl;
    }
};
int main() 
{
    Base obj1;
    Derived obj2;
    obj1.show();
    obj2.show();
}
OUTPUT
Base class show() Called.
Derived Class show() Called.

Option A

C++ resolves function overloading based on the exact match of argument types. In this case, max(2.3, 6.8) passes two double values, so the compiler selects the function double max(double a, double b). Since the argument types match exactly, there is no ambiguity or type conversion required.

Option A

In C++, when a derived class declares a function with the same name as a function in the base class, but with different arguments, the base class function becomes hidden. This situation is called function hiding, not overloading, or overriding.

Option D

A virtual function in C++ is a non-static member function declared using the virtual keyword in a base class. 
Virtual functions are used to achieve runtime polymorphism, where the function call is resolved during program execution rather than during compilation.
The statement (I) is correct. In C++, a virtual function must be a non-static member function of a class. You cannot declare global or static functions as virtual.
The statement (II) is correct. The statement most likely means “object pointers.” Virtual functions are generally accessed through base class pointers or references. This allows the program to decide at runtime which function should execute.
#include<iostream>
using namespace std;
class Base
{
    public:
    virtual void display()
    {
        cout<<"Base Class";
    }
};
class Derived : public Base
{
    public:
    void display()
    {
        cout<<"Derived Class";
    }
};
int main()
{
    Base *ptr;
    Derived d;
    ptr=&d;
    ptr->display();
    return 0;
}

Option D

In class A, vfunc() is declared as virtual, which means that when this function is called through a base class pointer, the function of the actual object type will be executed. This concept is called Runtime Polymorphism.

• p is a pointer of type A* (Base Class Pointer).
• When p points to an object of class B (p = &d1;), calling p->vfunc() invokes the overridden version in class B due to the virtual mechanism.
• When p points to an object of class A (p = &b;), calling p->vfunc() invokes A’s own version.
• When p points to an object of class C (p = &d2;), calling p->vfunc() invokes the overridden version in class C.

Option B

In C++, a constructor is a special member function that is automatically called when an object is created, whereas a destructor is automatically called when an object is destroyed.
Constructors and destructors have special rules regarding inheritance and virtual functions.
Constructors and destructors are not inherited by derived classes. Every derived class has its own constructor and destructor. 
However, the base class constructor is automatically called when a derived class object is created, and the base class destructor is automatically called when the object is destroyed.

#include <iostream>
using namespace std;
class Base
{
public:
    Base()
    {
        cout << "Base Constructor" << endl;
    }
    ~Base()
    {
        cout << "Base Destructor" << endl;
    }
};
class Derived : public Base
{
public:
    Derived()
    {
        cout << "Derived Constructor" << endl;
    }
    ~Derived()
    {
        cout << "Derived Destructor" << endl;
    }
};
int main()
{
    Derived obj;
    return 0;
}
OUTPUT
Base Constructor
Derived Constructor
Derived Destructor
Base Destructor

A destructor can be declared as virtual. Virtual destructors are used in inheritance to ensure that when a derived class object is deleted through a base class pointer, the destructors of both the derived class and the base class are called in the correct order.

#include <iostream>
using namespace std;
class Base
{
public:
    virtual ~Base()
    {
        cout << "Base Destructor" << endl;
    }
};
class Derived : public Base
{
public:
    ~Derived()
    {
        cout << "Derived Destructor" << endl;
    }
};
int main()
{
    Base *ptr = new Derived();
    delete ptr;
    return 0;
}
OUTPUT
Derived Destructor
Base Destructor

A constructor cannot be declared as virtual because it is responsible for creating the object. Virtual functions require an object to exist before they can be invoked. Therefore, virtual constructors are not allowed in C++.
Therefore,

• Constructors are never inherited and cannot be virtual.
• Destructors are not inherited but can be declared virtual, especially in base classes, to ensure proper destruction of derived class objects.

Option A

In C++, compile-time polymorphism is achieved when the function or class behavior is determined at compile time. This can be done using:
Function Overloading: Multiple functions with the same name but different parameters.
Operator Overloading: Redefining operators for user-defined types.
Templates: Allow writing generic functions or classes that work with any data type.

Option D

C++ primarily uses static type checking (at compile time) for variables and functions, catching most errors early. It also supports dynamic type checking at runtime via RTTI (Run-Time Type Information) features like dynamic_cast and typeid, allowing safe polymorphic casts. 
Additionally, C++ allows const member functions, which promise not to modify class data and can be called on const objects.