Welcome to C++ Programming Tutorial

Pointers to Derived Classes

In C++, a pointer to a base class can be used to point to an object of a derived class. This feature is essential in implementing polymorphism, where the base class pointer can invoke derived class methods, provided the methods are either overridden or declared as virtual in the base class.

However, the reverse isn't always true. A pointer to a derived class cannot be directly assigned an address of a base class object because a derived class may contain additional members not present in the base class, leading to potential memory access issues.

Key Points to Remember:

• Base Class Pointer to Derived Class Object: This is allowed and forms the basis of polymorphism. The base class pointer can only access members of the base class unless functions are virtual.
• Derived Class Pointer to Base Class Object: This is not allowed directly due to potential memory layout issues.
• Virtual Functions: If a base class function is declared as virtual, calling it through a base class pointer that points to a derived class object will invoke the derived class's version of the function.

Example: Pointers to Derived Classes

#include <iostream>
using namespace std;

class Base {
public:
    virtual void display() {
        cout << "Base class display function" << endl;
    }
    
    void baseFunction() {
        cout << "Function specific to Base class" << endl;
    }
};

class Derived : public Base {
public:
    void display() override {
        cout << "Derived class display function" << endl;
    }
    
    void derivedFunction() {
        cout << "Function specific to Derived class" << endl;
    }
};

int main() {
    Base* basePtr;
    Derived derivedObj;

    // Pointing Base class pointer to Derived class object
    basePtr = &derivedObj;

    // Calling the virtual function using base class pointer
    basePtr->display(); // Output: Derived class display function

    // Calling a base class function using base class pointer
    basePtr->baseFunction(); // Output: Function specific to Base class

    return 0;
}
                    

Breakdown of the Example:

Base Class:

class Base {
public:
    virtual void display() {
        cout << "Base class display function" << endl;
    }
    
    void baseFunction() {
        cout << "Function specific to Base class" << endl;
    }
};
                    

The Base class contains a virtual function display() and a regular member function baseFunction(). The display() function is marked as virtual to allow dynamic binding.

Derived Class:

class Derived : public Base {
public:
    void display() override {
        cout << "Derived class display function" << endl;
    }
    
    void derivedFunction() {
        cout << "Function specific to Derived class" << endl;
    }
};
                    

The Derived class inherits from the Base class and overrides the display() function. It also introduces a new function, derivedFunction(), which is specific to the Derived class.

Main Function:

int main() {
    Base* basePtr;
    Derived derivedObj;

    // Pointing Base class pointer to Derived class object
    basePtr = &derivedObj;

    // Calling the virtual function using base class pointer
    basePtr->display(); // Output: Derived class display function

    // Calling a base class function using base class pointer
    basePtr->baseFunction(); // Output: Function specific to Base class

    return 0;
}
                    

The pointer basePtr of type Base* is assigned the address of a Derived object. Since display() is virtual, calling basePtr->display() invokes the Derived class’s version of display().

The basePtr can access the baseFunction() of the Base class, but it cannot access derivedFunction() because basePtr is a pointer to the Base type, and the Base class does not have a member named derivedFunction().