Gain insights into C++20 Concepts to enhance type safety. Delve into creating compiler-checked criteria for templates and improving error clarity for seamless generic code development.

C++ Concepts by Sándor Dargo_468 x 60 copy.png

clang-gcc.tar.gz

c++20

clang

This course will walk you through the newest version of C++ 20, C++ Concepts.

You will go through one of the most significant new features in C++20, which is Concepts. Concepts allow you to create compiler-checked criteria for template parameters, revolutionizing the way you think about and develop generic code. You can use them to provide both syntactic and semantic requirements. They also allow you to explicitly express your goal in the type system. If something goes wrong, you'll get a clear error message from the compiler.

While useful, Concepts can be difficult to apply and even confusing sometimes. This course provides you with the knowledge you need to overcome these obstacles and move on to more complex topics.

Let's get started.

C++ Concepts: Improve Type Safety with C++ 20


# Example with no constraints on the exponent
Let’s have a look at the full example below:

#include <cmath>
#include <iostream>
#include <string>
#include <concepts>
#include <type_traits>

template <typename Base, typename Exponent>
concept HasPower = std::convertible_to<Exponent, int> &&
                    requires (Base base, Exponent exponent) {
    base.power(exponent);
};

//class having a conversion operator
class IntWithPower {
public:
    IntWithPower(int num) : m_num(num) {}

    int power(IntWithPower exp) {
       return pow(m_num, exp);
    }
    operator int() const { return m_num; }
private:
    int m_num;
};

//function on which concept is applied
template<typename Exponent>
void printPower(HasPower<Exponent> auto number, Exponent exponent) {
    std::cout << number.power(exponent) << '\n';
}

int main() {
    printPower(IntWithPower{5}, IntWithPower{4});
    printPower(IntWithPower{5}, 4L);
    printPower(IntWithPower{5}, 3.0);
}


The concept `HasPower` expects two template parameters, `Base` and `Exponent`, and has two explicit constraints:
- Using the concept defined on **line 8**, `Exponent` must be convertible to `int`.
- On **line 28**, the types modeling `HasPower` must have a method called power that takes one parameter that is convertible to an int.

The `printPower` template takes two template parameters. The `number` must satisfy `HasPower` because `number` itself represents only one type that is bound to the first argument of  `HasPower`.


Our example class `IntWithPwer` perfectly fits this concept as it has a `power` method that takes a parameter of its own type. As we defined `operator int()` on `IntWithPwer`, it also satisfies the requirement to be convertible to an integer.

The other two examples, where we use a long type `4L` on **line 34** and a double type `3.0` on **line 35**, show that those types are convertible to `int`.

In this example, we observed how to write a concept that expects the presence of a certain function that can accept a parameter of different constrained types. We also learned that we cannot specialize type traits such as `std::is_integral` without risking the consequences of undefined behavior. We should completely avoid that.


Let's see a complete example of the interface using requirements.

Introduction

The Concept Behind C++ Concepts

Four Ways to use Concepts in Functions

C++ Concepts with Classes

Concepts Shipped with the C++ Standard Library

How to Write Your Own C++ Concepts

How to Use C++ Concepts in Real Life

Summary

Full Example of Interface

Example with no constraints on the exponent