Cpp Programming Function Overriding And Virtual Functions Complete Guide

Top 10 Questions and Answers on C++ Programming: Function Overriding and Virtual Functions

Answer: Function overriding in C++ occurs when a derived class has a function with the same name, return type, and parameters as a member function in the base (parent) class. The purpose of function overriding is to allow a derived class to provide a specific implementation for a function that is already defined in its base class. This mechanism supports polymorphism, enabling calls to the correct function based on the type of the object at runtime.

Example:

class Shape {
public:
    virtual void draw() {
        cout << "Drawing a generic shape." << endl;
    }
};

class Circle : public Shape {
public:
    void draw() override { // overriding Shape::draw()
        cout << "Drawing a circle." << endl;
    }
};

In this example, Circle overrides the draw() function from the Shape class.

2. How is Function Overloading Different from Function Overriding?

Answer: Function overloading refers to multiple functions with the same name but different parameters or return types within the same class. On the other hand, function overriding involves defining a function in a derived class that has the exact same signature as a function in the base class, effectively replacing it during method calls.

Example:

Overloading:

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }
};

Overriding:

class Base {
public:
    virtual void display() {
        cout << "Base class display function." << endl;
    }
};

class Derived : public Base {
public:
    void display() override {
        cout << "Derived class display function." << endl;
    }
};

In the overloading example, two add functions have different parameter types, while in the overriding example, Derived::display is a redefinition of Base::display.

3. What is the use of the virtual Keyword in C++?

Answer: The virtual keyword in C++ is used to specify that a function in a base class is intended to be overridden by functions in derived classes. It enables dynamic dispatch, which refers to deciding at runtime which function to call based on the actual object's type, rather than the pointer/reference type.

4. Explain Runtime Polymorphism in C++ with an Example.

Answer: Runtime polymorphism in C++ is accomplished through inheritance and virtual functions. It allows a program to decide dynamically which function to call based on the concrete class of the object pointed/referenced at runtime.

Example:

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void sound() {
        cout << "Animal makes a sound." << endl;
    }
};

class Dog : public Animal {
public:
    void sound() override {
        cout << "Dog barks." << endl;
    }
};

int main() {
    Animal* p = new Dog();
    p->sound(); // Output: Dog barks.
    delete p;
    return 0;
}

Here, sound() is a virtual function in the Animal class, thus allowing the main function to determine the actual sound based on the object the pointer p points to (Dog, in this case).

5. Can Constructors and Destructors be Overridden in C++?

Answer: Constructors cannot be overridden in C++ because each class has a unique constructor corresponding to its class type that initializes its own data members. Destructors are virtual by default in derived classes if the base class destructor is virtual.

6. What are Pure Virtual Functions in C++?

Answer: Pure virtual functions make a class abstract, meaning no instances of this class can be created, and they must be implemented by non-abstract derived classes. They are declared with = 0 in their declaration within an abstract base class.

Example:

class Shape {
public:
    virtual void draw() = 0; // Pure virtual function
};

// Any class inheriting from Shape must implement 'draw'.
class Rectangle : public Shape {
public:
    void draw() override {
        cout << "Drawing rectangle." << endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing circle." << endl;
    }
};

7. What is a Virtual Destructor? Why is it Important?

Answer: A virtual destructor in a base class allows the destructor of the derived class to be called correctly through a base class pointer. Without a virtual destructor, deleting a derived class object via a base class pointer may lead to memory leaks or undefined behavior since only the base class destructor would be called.

Example:

#include <iostream>
using namespace std;

class Base {
public:
    virtual ~Base() {
        cout << "Base class destructor." << endl;
    }
};

class Derived : public Base {
public:
    ~Derived() override {
        cout << "Derived class destructor." << endl;
    }
};

int main() {
    Base* b = new Derived();
    delete b; // Correctly calls both Derived and Base destructors
    return 0;
}

8. What is the Difference Between Static and Dynamic Binding in C++?

Answer: Static binding occurs at compile time, where the method binding is determined by the type of the reference/pointer. Static binding is associated with compile-time polymorphism (function overloading).

Dynamic binding occurs at runtime, where the method binding is decided based on the content of the pointer/reference (i.e., the type of the actual object). Dynamic binding is linked with run-time polymorphism (function overriding through virtual functions).

9. When should you use Virtual Functions?

Answer: Virtual functions should be used when you anticipate the need for polymorphic behavior in your code. Specifically, when methods need to be overridden in derived classes, and function calls should be resolved dynamically based on the object's type to ensure the most appropriate method is invoked during execution.

10. Is it Possible to Override a Non-virtual Function in C++?

Answer: Though you can define a function with the same signature in a derived class, it is not considered an override of the base class function unless the base class function is marked as virtual. If the base function is not virtual, calling the function via a base class pointer will always invoke the base class version, regardless of the actual object pointed to.

Example:

class Base {
public:
    void greet() {
        cout << "Hello from Base class!" << endl;
    }
};

class Derived : public Base {
public:
    void greet() { // Not overriding, just hiding Base::greet()
        cout << "Hello from Derived class!" << endl;
    }
};

int main() {
    Base* b = new Derived();
    b->greet(); // Output: Hello from Base class!
    delete b;
    return 0;
}

In the above code snippet, Derived::greet hides Base::greet since the latter is not virtual, thus leading to the wrong function being called at runtime when using a base class pointer to a derived class object.