Compile-Time Polymorphism with Templates

Yes, you can use templates to implement compile-time polymorphism in C++. This is often referred to as static polymorphism or compile-time polymorphism, as opposed to runtime polymorphism achieved through virtual functions and inheritance.

Compile-time polymorphism with templates allows you to write code that works with different types without the overhead of virtual function calls. It's resolved at compile-time, which can lead to better performance compared to runtime polymorphism.

Here's an example demonstrating compile-time polymorphism using templates:

1#include <iostream>
2#include <list>
3#include <vector>
4
5// Base template for Shape
6template <typename T>
7class Shape {
8 public:
9  void Draw() const {
10    static_cast<const T*>(this)->DrawImpl();
11  }
12};
13
14// Derived "class" Circle
15class Circle : public Shape<Circle> {
16 public:
17  void DrawImpl() const {
18    std::cout << "Drawing a circle\n";
19  }
20};
21
22// Derived "class" Square
23class Square : public Shape<Square> {
24 public:
25  void DrawImpl() const {
26    std::cout << "Drawing a square\n";
27  }
28};
29
30// Function template that works with any Shape
31template <typename T>
32void DrawShape(const Shape<T>& shape) {
33  shape.Draw();
34}
35
36int main() {
37  Circle circle;
38  Square square;
39
40  DrawShape(circle);
41  DrawShape(square);
42
43  // We can even use it with containers
44  std::vector<Shape<Circle>*> circles = {
45    new Circle, new Circle
46  };
47  std::list<Shape<Square>*> squares = {
48    new Square, new Square
49  };
50
51  for (auto& c : circles) DrawShape(*c);
52  for (auto& s : squares) DrawShape(*s);
53
54  // Clean up
55  for (auto& c : circles) delete c;
56  for (auto& s : squares) delete s;
57}

1Drawing a circle
2Drawing a square
3Drawing a circle
4Drawing a circle
5Drawing a square
6Drawing a square

This example demonstrates the Curiously Recurring Template Pattern (CRTP), a form of compile-time polymorphism. Here's how it works:

1. We define a base Shape template that declares a Draw() function. This function calls DrawImpl() on the derived class using static_cast.
2. Derived classes (like Circle and Square) inherit from Shape<DerivedClass> and implement their own DrawImpl() method.
3. The DrawShape() function template can work with any type derived from Shape<T>.
4. At compile-time, the correct DrawImpl() method is selected based on the actual type of the object.

Key benefits of this approach:

1. Performance: There's no virtual function call overhead. The correct function is determined at compile-time.
2. Flexibility: You can add new "derived" classes without modifying existing code.
3. Static checking: Errors, like forgetting to implement DrawImpl(), are caught at compile-time.

Some considerations:

1. Code bloat: Each instantiation of the template generates new code, which can increase compile times and binary size.
2. Debugging: Template-heavy code can be more challenging to debug due to complex error messages.
3. Lack of runtime polymorphism: You can't have containers of mixed shape types or change behavior at runtime.

Compile-time polymorphism with templates is a powerful technique in C++. It's particularly useful in scenarios where you need high performance and know the types you're working with at compile-time. However, it's not a replacement for runtime polymorphism in all cases. The choice between compile-time and runtime polymorphism depends on your specific requirements for flexibility, performance, and design.