Using Trailing Requires Clauses

Trailing requires clauses are a way to specify constraints on function templates or member functions of class templates. They are placed after the function signature and before the function body.

Trailing requires clauses are particularly useful when you want to conditionally enable or disable member functions based on the template parameters of the class. Here's an example:

1#include <concepts>
2#include <iostream>
3
4template <typename T>
5class Container {
6  T value{T(3.14)};
7
8 public:
9  void printValue()
10    requires std::integral<T>
11  {
12    std::cout << "Integral value: " << value
13      << '\n';
14  }
15
16  void printValue()
17    requires std::floating_point<T>
18  {
19    std::cout << "Floating-point value: "
20      << value << '\n';
21  }
22};
23
24int main() {
25  Container<int> intContainer;
26  // Calls the integral version
27  intContainer.printValue();
28
29  Container<double> doubleContainer;
30  // Calls the floating-point version
31  doubleContainer.printValue();
32}

1Integral value: 3
2Floating-point value: 3.14

In this example, the Container class template has two overloads of the printValue member function, each with a different trailing requires clause.

The first overload is enabled only when the template parameter T satisfies the std::integral concept, while the second overload is enabled only when T satisfies the std::floating_point concept.

This allows the appropriate version of printValue to be called based on the type used to instantiate the Container template.