How can I use concepts and constraints with template classes split across files?

Question

Ryan McCombe · Accepted Answer

Using concepts and constraints with template classes split across files is a powerful way to improve code clarity and catch errors early. Let's explore how to implement this effectively.

Defining Concepts

First, let's define some concepts in a header file:

1// Concepts.h
2#pragma once
3#include <concepts>
4#include <iostream>
5
6template <typename T>
7concept Numeric = std::integral<T>
8  || std::floating_point<T>;
9
10template <typename T>
11concept Printable = requires(T t) {
12  { std::cout << t } -> std::same_as<std::ostream&>;
13};

Template Declaration with Concepts

Now, let's declare our template class using these concepts:

1// MyTemplate.h
2#pragma once
3#include "Concepts.h"
4
5template <Numeric T, Printable U>
6class MyTemplate {
7 public:
8  void foo();
9  void bar();
10};

Implementation in Separate File

Implement the template methods in a separate .cpp file:

1// MyTemplate.cpp
2#include <iostream>
3#include "MyTemplate.h"
4
5template <Numeric T, Printable U>
6void MyTemplate<T, U>::foo() {
7  std::cout << "foo() called\n";
8}
9
10template <Numeric T, Printable U>
11void MyTemplate<T, U>::bar() {
12  std::cout << "bar() called\n";
13}
14
15// Explicit instantiations
16template class MyTemplate<int, std::string>;
17template class MyTemplate<double, char>;

Usage

Here's how you might use this template:

1// main.cpp
2#include <string>
3#include "MyTemplate.h"
4
5int main() {
6  MyTemplate<int, std::string> obj1;
7  obj1.foo(); // Logs "foo() called"
8
9  MyTemplate<double, char> obj2;
10  obj2.bar(); // Logs "bar() called"
11
12  // Compile-time error:
13  MyTemplate<std::string, int> obj3; 
14}

1error: 'MyTemplate': the associated constraints are not satisfied

Implications and Best Practices

Early Error Detection: Concepts help catch errors at compile-time, providing clearer error messages.
Improved Readability: Concepts make template requirements explicit, enhancing code readability.
Separate Compilation: You still need to use explicit instantiation in the .cpp file to avoid linker errors.
Concept Definitions: Keep concept definitions in a separate header for reusability across your project.
Constraint Checking: The compiler checks constraints where the template is instantiated, not where it's defined.

Advanced Usage: Requiring Specific Methods

You can use concepts to require specific methods:

1// Concepts.h
2#include <concepts>
3
4template <typename T>
5concept Drawable = requires(T t) {
6  { t.draw() } -> std::same_as<void>;
7};
8
9// MyTemplate.h
10template <Drawable T>
11class Renderer {
12 public:
13  void render(T& obj);
14};
15
16// MyTemplate.cpp
17template <Drawable T>
18void Renderer<T>::render(T& obj) {
19  obj.draw();
20}
21
22// Explicit instantiation for a Drawable type
23class Circle {
24 public:
25  void draw() { /* ... */
26  }
27};
28
29template class Renderer<Circle>;

Remember, while concepts and constraints add compile-time checks, they don't affect runtime performance.

They're a tool for better design and earlier error detection. When using them with separate implementation files, make sure to explicitly instantiate all the template specializations you need.

Templates and Header Files

Concepts and Constraints with Separate Files