Static vs Dynamic Polymorphism in C++ Explained

Introduction

Polymorphism is a core concept in object-oriented programming, allowing objects to be treated as instances of their parent class rather than their actual class. In C++, polymorphism can be achieved in two primary ways: static (compile-time) and dynamic (run-time). Understanding the differences between static and dynamic polymorphism in C++ is crucial for writing efficient and maintainable code. This blog post will delve into the topic of static vs dynamic polymorphism in C++ explained in detail, providing practical examples and best practices.

Understanding the Concept

Static Polymorphism

Static polymorphism, also known as compile-time polymorphism, is achieved through function overloading and template metaprogramming. The decision about which function to call is made at compile time. This type of polymorphism is faster because it eliminates the need for dynamic dispatch at runtime.

Function overloading allows multiple functions with the same name but different parameters to coexist. The compiler determines which function to call based on the arguments passed.

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

Template metaprogramming allows functions and classes to operate with generic types. This is another form of static polymorphism.

template <typename T>
T add(T a, T b) {
    return a + b;
}

Dynamic Polymorphism

Dynamic polymorphism, or run-time polymorphism, is achieved through inheritance and virtual functions. The decision about which function to call is made at runtime. This type of polymorphism is more flexible but comes with a performance cost due to dynamic dispatch.

In C++, dynamic polymorphism is typically implemented using base class pointers or references to call derived class methods.

class Base {
public:
    virtual void show() {
        std::cout << "Base class" << std::endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        std::cout << "Derived class" << std::endl;
    }
};

int main() {
    Base* b = new Derived();
    b->show(); // Outputs: Derived class
    delete b;
    return 0;
}

Practical Implementation

Static Polymorphism Example

Let's implement a simple example of static polymorphism using function overloading and templates.

class Printer {
public:
    void print(int i) {
        std::cout << "Printing int: " << i << std::endl;
    }
    void print(double d) {
        std::cout << "Printing double: " << d << std::endl;
    }
    void print(std::string s) {
        std::cout << "Printing string: " << s << std::endl;
    }
};

int main() {
    Printer p;
    p.print(5);
    p.print(3.14);
    p.print("Hello, World!");
    return 0;
}

In this example, the Printer class has three overloaded print methods, each accepting a different type of argument. The compiler determines which method to call based on the argument type.

Dynamic Polymorphism Example

Now, let's implement a simple example of dynamic polymorphism using inheritance and virtual functions.

class Animal {
public:
    virtual void speak() {
        std::cout << "Animal speaks" << std::endl;
    }
};

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

class Cat : public Animal {
public:
    void speak() override {
        std::cout << "Cat meows" << std::endl;
    }
};

int main() {
    Animal* a1 = new Dog();
    Animal* a2 = new Cat();
    a1->speak(); // Outputs: Dog barks
    a2->speak(); // Outputs: Cat meows
    delete a1;
    delete a2;
    return 0;
}

In this example, the Animal class has a virtual speak method, which is overridden by the Dog and Cat classes. The actual method called is determined at runtime based on the object type.

Common Pitfalls and Best Practices

Static Polymorphism

• Code Bloat: Overusing templates can lead to code bloat, as the compiler generates separate code for each template instantiation.
• Complexity: Template metaprogramming can become complex and hard to debug.

Dynamic Polymorphism

• Performance Overhead: Dynamic polymorphism introduces a performance overhead due to dynamic dispatch.
• Memory Management: Proper memory management is crucial to avoid memory leaks when using pointers.

Best Practices

• Use static polymorphism when performance is critical and the types are known at compile time.
• Use dynamic polymorphism when flexibility and extensibility are more important than performance.
• Always use smart pointers (e.g., std::unique_ptr, std::shared_ptr) for dynamic memory management to avoid memory leaks.

Advanced Usage

Static Polymorphism with CRTP

The Curiously Recurring Template Pattern (CRTP) is a technique in C++ where a class template derives from itself. This can be used to achieve static polymorphism.

template <typename T>
class Base {
public:
    void interface() {
        static_cast<T*>(this)->implementation();
    }
};

class Derived : public Base<Derived> {
public:
    void implementation() {
        std::cout << "Derived implementation" << std::endl;
    }
};

int main() {
    Derived d;
    d.interface(); // Outputs: Derived implementation
    return 0;
}

In this example, the Base class template uses CRTP to call the implementation method of the Derived class, achieving static polymorphism.

Dynamic Polymorphism with Abstract Classes

Abstract classes in C++ are classes that contain at least one pure virtual function. They are used to define interfaces for derived classes.

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

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

class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Square" << std::endl;
    }
};

int main() {
    Shape* s1 = new Circle();
    Shape* s2 = new Square();
    s1->draw(); // Outputs: Drawing Circle
    s2->draw(); // Outputs: Drawing Square
    delete s1;
    delete s2;
    return 0;
}

In this example, the Shape class is an abstract class with a pure virtual draw method. The Circle and Square classes override this method, providing their own implementations.

Conclusion

Understanding the differences between static and dynamic polymorphism in C++ is essential for writing efficient and maintainable code. Static polymorphism, achieved through function overloading and template metaprogramming, offers performance benefits but can lead to code bloat and complexity. Dynamic polymorphism, achieved through inheritance and virtual functions, provides flexibility and extensibility at the cost of performance overhead. By following best practices and understanding the trade-offs, you can effectively utilize both forms of polymorphism in your C++ projects.