CS Free MCQ Bank

[ 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 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 ]

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 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.

[ Option B ]

In C++, Overloading allows multiple functions, operators, or constructors to have the same name but behave differently based on their parameters (either number, type or sequence of parameters).

S1: Function can be overloaded – True. We can have multiple functions with the same name but different number or types or sequence of parameters.

• void addition(int a, int b);
• void addition(int a, int b, int c);

S2: Operator can be overloaded – True. Operator overloading allows defining custom behaviors for operators (like +, -, *, == etc.) for user-defined types (classes). This means you can change how operators work with your objects.

class Complex {
    int real, imag;
public:
    Complex operator+(Complex const &c) {
       Complex temp;
       temp.real = real + c.real;
       temp.imag = imag + c.imag;
        return(temp);
    }
};

S3: Constructor can be overloaded – True. Constructors are special functions called when objects are created. A class can have multiple constructors with different parameter lists.
class MyClass {
public:
    MyClass() {}                   // default constructor
    MyClass(int a) {}            // one argument constructor
    MyClass(int a, int b) {}   // two argument constructor
};

[ Option A ]

In C++, an abstract class is defined as a class that contains at least one pure virtual function. A pure virtual function is a virtual function declared by assigning it to zero (= 0) in its declaration, and it has no definition in the abstract class itself. 
This forces derived classes to provide an implementation for this function, otherwise, they also become abstract. Abstract classes cannot be instantiated directly, they serve as blueprints for other subclasses.
class Person
{
public:
    virtual void setName() = 0; // Pure Virtual Function.
};

[ Option B ]

• C++ does not allow constructors to be declared virtual. Because constructors are used to create objects, and polymorphism requires an object to already exist.
• The virtual-ness is determined only by the base class. If a function is not declared virtual in the base class, it is not virtual, even if it is marked as virtual in the derived class.
• Redefining a virtual method in a derived class is optional. If it is not redefined, the base class's version will be used. Only pure virtual functions must be redefined, not regular virtual ones.
• The virtual keyword needs to be written only in the base class where the function is first declared. In all subsequent derived classes, the function remains virtual automatically, so writing the virtual keyword again is optional—it is only for readability and clarity.
• When overriding a virtual function in a derived class, the name, parameter list, and return type must match exactly (or be covariant return types). This ensures correct function overriding at runtime using the vtable mechanism.