Home
Creating a Vector of Multiple Objects with Different Classes in C Using Templates and Polymorphism

Creating a Vector of Multiple Objects with Different Classes in C Using Templates and Polymorphism

January 04, 2025 Digital

Creating a Vector of Multiple Objects with Different Classes in C Using Templates and Polymorphism

In C , you can create a vector that contains multiple objects of different classes by utilizing polymorphism and inheritance. The general approach involves defining a common base class that all the different classes derive from. You then create a vector of pointers to this base class. This guide provides a step-by-step explanation of how to achieve this.

Step 1: Define a Base Class

Create a base class that will serve as the common interface for all derived classes.

Source Code

class Base {
public:
    virtual void display() const  0; // Pure virtual function
    virtual ~Base() {} // Virtual destructor
};

Step 2: Define Derived Classes

Create classes that inherit from the base class.

Source Code

class ClassA : public Base {
public:
    void display() const override {
        std::cout  "ClassA Display"  std::endl;
    }
};
class ClassB : public Base {
public:
    void display() const override {
        std::cout  "ClassB Display"  std::endl;
    }
};
class ClassC : public Base {
public:
    void display() const override {
        std::cout  "ClassC Display"  std::endl;
    }
};

Step 3: Create a Vector of Base Class Pointers

Now you can create a vector that holds pointers to the base class, allowing you to store objects of different derived classes.

Source Code

int main() {
    std::vectorstd::shared_ptrBase objects;
    objects.push_back(std::make_sharedClassA());
    objects.push_back(std::make_sharedClassB());
    objects.push_back(std::make_sharedClassC());
    // Iterate and call the display function
    for (const auto obj : objects) {
        obj-display();
    }
    return 0;
}

Explanation

Base Class: The Base class defines a pure virtual function display making it an abstract class.

Derived Classes: ClassA, ClassB, and ClassC implement the display method.

Vector of Pointers: A std::vector of std::shared_ptrBase is created. Using smart pointers helps manage memory automatically.

Adding Objects: Objects of different classes are created and added to the vector.

Polymorphism: When iterating over the vector calling display on each object will invoke the correct method for the actual object type thanks to polymorphism.

Summary

This approach allows you to store and manage a collection of objects of different types while ensuring that they can be treated uniformly through the base class interface. This is a common pattern in C when dealing with heterogeneous collections and is often used in game engine development and many other areas of software engineering.

Keywords: C Templates, Polymorphism, Vector of Different Classes, Game Engine Development, C Inheritance

Related Posts