Concepts in C++20

We can imagine a concept being a set of requirements for a type. We pass the type to a concept at compile time, and the concept returns true if the type meets the requirements. Requirements can include things like:

• Is the type a number?
• Is the type a class?
• Is the type a class that is derived from Player?
• Does the type have a member function called Render() that accepts an int and returns void?

The standard library includes a collection of pre-defined concepts that cover the first three examples. In the next lesson, we'll see how we can create our own concepts for our highly specific requirements.

Most of the standard library concepts are available from the <concepts> header:

1#include <concepts>

For example, the std::integral concept can tell us if a type is an integer: We pass the type as a template argument, and get a boolean back at compile time:

1#include <iostream>
2#include <concepts>
3
4int main() {
5  if constexpr (std::integral<int>) {
6    std::cout << "int is an integral";
7  }
8
9  if constexpr (!std::integral<float>) {
10    std::cout << "\nfloat isn't";
11  }
12}

1int is an integral
2float isn't

Of course, we could have done this exact same thing using type traits. What makes concepts different from type traits is that the C++ specification allows concepts to interact with templates as a feature of the language itself.

This capability is baked into the syntax of the language, and there are four main ways we can use it.

Within a template parameter list, we can replace typename types with the name of a concept. This parameter will still receive a type name as an argument. But now, for the template to be a valid candidate, that type must implement the requirements specified in the concept.

So, if we wanted to ensure our type was an integer, we no longer need to manually create assertions or implement SFINAE. Instead, we can just replace typename with the name of a concept in our template parameter list.

So, instead of writing this:

1template <typename T>
2void SomeFunction(T x) {
3  // ...
4}

We can instead write this:

1template <std::integral T>
2void SomeFunction(T x) {
3  // ...
4}

We're now fully documenting our type requirements, and our template will not appear within the overload candidate list when non-integral arguments are provided.

Additionally, the compiler will generate meaningful error messages explaining why our template wasn't an option: In this case, it was because the double arguments we provided were not integral:

1#include <concepts>
2
3template <std::integral T>
4T Average(T x, T y) {
5  return (x + y) / 2;
6}
7
8int main() {
9  // This is fine
10  Average(1, 2);
11  
12  // This is not
13  Average(1.5, 2.2); 
14}

1error: 'Average': no matching overloaded function found
2could be 'T Average(T,T)' but the associated constraints are not satisfied
3the concept 'std::integral<double>' evaluated to false

Similar to the example we showed using std::enable_if in the previous lesson, concepts allow us to route function calls to different templates, in a much clearer way:

1#include <iostream>
2#include <concepts>
3
4template <std::integral T>
5T Average(T x, T y) {
6  std::cout << "Using integral function\n";
7  return (x + y) / 2;
8}
9
10template <std::floating_point T>
11T Average(T x, T y) {
12  std::cout << "Using floating point function";
13  return (x + y) / 2;
14}
15
16int main() {
17  Average(1, 2);
18  Average(1.5, 2.2);
19}

1Using integral function
2Using floating point function

Constrained vs Unconstrained Templates

In our Overload Resolution lesson, we mentioned that the compiler prefers to choose templates that are constrained by concepts over those that aren't.

Below, we have a general, unconstrained function template that can be instantiated with any typename.

We also have a template function with the same name, constrained such that only type names that satisfy std::integral are supported. When the arguments are integral, the compiler selects the more specialized template:

1#include <concepts>
2#include <iostream>
3
4template <std::integral T>  
5T Average(T x, T y) {
6  std::cout << "Using integral function\n";
7  return (x + y) / 2;
8}
9
10template <typename T>  
11T Average(T x, T y) {
12  std::cout << "Using generic function";
13  return (x + y) / 2;
14}
15
16int main() {
17  Average(1, 2);
18  Average(1.5, 2.2);
19}

1Using integral function
2Using generic function

This gives us similar behaviour to what we described in our section on template specialization. The key difference is that with template specialization, we need to specify an exact type.

With concepts, we can be much more flexible.

The addition of concepts also came with a new piece of syntax - the requires keyword. This keyword is used in a few different ways, which we'll cover in this lesson.

Below, we use the requires keyword in a function template. It has access to the types our template is using, and will return true if the template can handle those types.

We could rewrite our previous example using requires like this:

1#include <iostream>
2#include <concepts>
3
4template <typename T>
5  requires std::integral<T>
6T Average(T x, T y) {
7  std::cout << "Using integral function\\n";
8  return (x + y) / 2;
9}
10
11template <typename T>
12  requires std::floating_point<T>
13T Average(T x, T y) {
14  std::cout << "Using floating point function";
15  return (x + y) / 2;
16}
17
18int main() {
19  Average(1, 2);
20  Average(3.4, 5.3);
21}

1Using integral function
2Using floating point function

The requires method is more verbose than simply replacing typename, but it gives us some more options. For example, we can use boolean logic. In the below example, we allow our type to match one of two concepts, using a requires clause and the || operator:

1#include <concepts>
2
3template <typename T>
4  requires std::integral<T> ||     
5           std::floating_point<T>  
6T Average(T x, T y) {
7  return (x + y) / 2;
8}
9
10int main() {
11  // This is fine
12  Average(1, 2);
13  Average(3.4, 5.3);
14
15  // This is not
16  Average("Hello", "World");
17}

1error: 'Average': no matching overloaded function found
2the associated constraints are not satisfied
3the concept 'std::integral<const char*>' evaluated to false
4the concept 'std::floating_point<const char*>' evaluated to false

We're also not restricted to just using concepts within requires statements - we can use other compile-time techniques too.

Below, we use the std::is_base_of type trait from the previous lesson to state our template is only compatible with types that derive from Player or Monster:

1#include <concepts>
2
3class Player {};
4class Monster {};
5class Goblin : public Monster {};
6class Rock {};
7
8template <typename T>
9  requires std::is_base_of_v<Player, T> ||
10           std::is_base_of_v<Monster, T>
11void Function(T Character) {}
12
13int main() {
14  // This is fine
15  Function(Player{});
16  Function(Monster{});
17  Function(Goblin{});
18
19  // This is not
20  Function(Rock{});
21}

1error: 'Function': no matching overloaded function found
2the associated constraints are not satisfied

When creating function templates, we have the option of using a requires statement in a slightly different way. It can be placed between the function signature and the function body, like this:

1template <typename T>
2T Average(T x, T y)
3  requires std::integral<T>
4{
5  return (x + y) / 2;
6}

The main use case for this is when we have a function that is not a template, but is a member of a class or struct that is.

This effectively allows us to disable member functions based on the template parameters of the class or struct they're part of:

1#include <concepts>
2
3template <typename T>
4struct Container {
5  void Function()
6    requires std::integral<T>  
7  {}
8};
9
10int main() {
11  // This is fine
12  Container<int> IntContainer;
13  IntContainer.Function();
14
15  // This is not
16  Container<float> FloatContainer;
17  FloatContainer.Function();
18}

1error: 'Function': no function satisfied its constraints
2the 'Container<float>::Function' constraint was not satisfied
3the concept 'std::integral<float>' evaluated to false

The final way we can use concepts is within abbreviated function templates. As a reminder, abbreviated function templates let us create template functions simply by setting one or more parameter types to auto:

1auto Average(auto x, auto y) {
2  return (x + y) / 2;
3}

We can constrain these parameters using concepts too. We insert the concept before the auto type:

1#include <concepts>
2
3auto Average(std::integral auto x,    
4             std::integral auto y) {  
5  return (x + y) / 2;
6}
7
8int main() {
9  // This is fine
10  Average(1, 2);
11
12  // This is not
13  Average(1.0, 2.0);
14}

1error: 'Average': no matching overloaded function found
2the concept 'std::integral<double>' evaluated to false
3the constraint was not satisfied

We are free to combine the previous techniques as we see fit. Below, we use a constrained template parameter to specify requirements for the first type, and a requires statement to restrict the second type.

For the template to be eligible for a given function call, all the requirements need to be met. In this case, the first type must be integral, whilst the second must be either integral or floating point:

1template <std::integral T1, typename T2>
2  requires std::integral<T2> ||
3    std::floating_point<T2>
4void Function(T1x , T2 y){}

In this lesson, we explored the powerful new feature introduced in C++20: concepts. Concepts provide a more expressive and readable way to constrain template parameters and improve template error messages. The key takeaways from this lesson are:

• Concepts are sets of requirements for types, allowing us to enforce type constraints on template parameters without relying on SFINAE.
• Concepts make template error messages more readable and easier to understand, improving code documentation and clarity.
• The standard library includes pre-defined concepts that cover common type requirements, such as std::integral and std::floating_point.

There are four main ways to use concepts with templates, and we can combine them as needed:

1. Constrained Template Parameters: Replace typename with the name of a concept to constrain the template parameter.
2. The requires Keyword: Use the requires keyword to specify constraints on template parameters using boolean logic and type traits.
3. Trailing Requires Clause: Place a requires statement between the function signature and the function body to disable member functions based on the template parameters of the class or struct they're part of.
4. Abbreviated Function Template: Constrain auto parameters in abbreviated function templates by inserting the concept before the auto type.