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

# Do subsumptions and negations matter?
Subsumptions and negations matter when there are multiple versions of the same method differentiated only by their constraints. Then, the compiler has to look for the most constrained version. Let’s assume that we have a class `Ignition` with two versions of the `start` method:

```c++
template <typename Key>
class Ignition {
public:
    void start(Key key) requires (!Smart<Key>) {}

    void start(Key key) requires (!Smart<Key>) && Personal<Key> {}
};

```


The compiler uses boolean algebra to find the most constrained version of `start()`. This process is called **subsumption**.

If we call `Ignition` with a `Key` that is not `Smart`, we expect the compiler to subsume that the first constraints of the two overloads of `Ignition::start()` are common. We have to check whether the second one applies to our `Key` type or not.

It may seem simple, but appearances can be deceiving!

If we call `Ignition::start()` with a `Key` that is not `Smart` and compile the code, we will get an error message that complains about an ambiguous overload.

# Where is the problem?


The problem is that the `()` is part of the expression. When it comes to subsumption, the compiler checks the source location of the expression. The compiler can only subsume them if they originate from the same space.

Get an overview of the subsumptions and negations.

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

Subsumption and Negations

Do subsumptions and negations matter?