Templates in Modules

Yes, you can use template classes and functions within C++20 modules. Templates are a powerful feature of C++ that allows you to write generic and reusable code.

Using them within modules follows similar principles to using them in traditional header files but with some added benefits.

Templates can be declared and exported in module interface files, making them available for use in other parts of the program. Here's an example where we declare a template function in a module:

1// Math.cppm
2export module Math;
3
4export template<typename T>
5T add(T a, T b) {
6  return a + b;
7}

Once declared and exported, you can import the module and use the template functions or classes as needed. Here's an example where we use the templated function imported from our module:

1// main.cpp
2import Math;
3#include <iostream>
4
5int main() {
6  std::cout << "Int: " << add(2, 3) << "\n";
7  std::cout << "Double: " << add(2.5, 3.1) << "\n";
8}

1Int: 5
2Double: 5.6

Template classes can also be declared and used in modules similarly. Here's an example:

1// Container.cppm
2export module Container;
3
4export template<typename T>
5class Container {
6 public:
7  void add(T element) {
8    elements.push_back(element);
9  }
10
11  T get(int index) const {
12    return elements[index];
13  }
14
15 private:
16  std::vector<T> elements;
17};

1// main.cpp
2import Container;
3#include <iostream>
4
5int main() {
6  Container<int> intContainer;
7  intContainer.add(1);
8  intContainer.add(2);
9
10  std::cout << "First element: "
11    << intContainer.get(0);
12}

1First element: 1

• Encapsulation: Templates within modules benefit from the encapsulation provided by modules. Internal details can be hidden, reducing the risk of name clashes and unintended dependencies.
• Improved Compile Times: Since modules are compiled once and reused, using templates within modules can lead to improved compile times compared to repeatedly parsing template definitions in header files.
• Cleaner Code: Using modules with templates can make code cleaner and more maintainable by clearly separating interface and implementation.

Templates can be effectively used within C++20 modules for both functions and classes.

This approach leverages the benefits of modules, such as improved encapsulation and compile times, while maintaining the power and flexibility of templates.