Using member function templates with inheritance

Member function templates and inheritance interact in interesting ways. You can define member function templates in a base class and still override them in derived classes, but there are a few things to keep in mind.

First, when you define a member function template in a base class, it doesn't create a single function that can be overridden. Instead, it creates a template for functions that can be instantiated.

Here's an example:

1#include <iostream>
2
3class Base {
4 public:
5  template <typename T>
6  void func(T x) {
7    std::cout << "Base: " << x << std::endl;
8  }
9};
10
11class Derived : public Base {
12 public:
13  template <typename T>
14  void func(T x) {
15    std::cout << "Derived: " << x << std::endl;
16  }
17};
18
19int main() {
20  Derived d;
21  d.func(42);    // calls Derived::func
22  d.func(3.14);  // also calls Derived::func
23}

1Derived: 42
2Derived: 3.14

In this code, both Base and Derived have a member function template func. When we call d.func, it always calls Derived::func, regardless of the argument type. That's because Derived::func is not actually overriding Base::func, it's hiding it.

If you want to truly override a specific instantiation of a base class member function template, you need to provide an explicit specialization in both the base and the derived class:

1#include <iostream>
2
3class Base {
4 public:
5  template <typename T>
6  void func(T x) {
7    std::cout << "Base: " << x << std::endl;
8  }
9};
10
11template <>
12void Base::func<int>(int x) {
13  std::cout << "Base specialization for int: "
14    << x << std::endl;
15}
16
17class Derived : public Base {
18 public:
19  template <typename T>
20  void func(T x) {
21    std::cout << "Derived: " << x << std::endl;
22  }
23
24  // Override the base class's specialization
25  // for int
26  void func(int x) {
27    std::cout << "Derived specialization for"
28      " int: " << x << std::endl;
29  }
30};
31
32int main() {
33  Derived d;
34  d.func(42);    // calls Derived::func
35  d.func(3.14);  // also calls Derived::func
36}

1Derived specialization for int: 42
2Derived: 3.14

Now, when you call d.func(42), it will call the specialization in Derived, but d.func(3.14) will still call the generic func from Base.

Inheritance with member function templates can be complex, so it's important to consider your design carefully. In many cases, it might be simpler to use regular virtual functions for runtime polymorphism and reserve member function templates for static polymorphism within a single class.