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

## `!a` is not the opposite of `a`

When we talk about concepts, the opposite of a `true` expression is not an expression that is evaluated to `false`. Let’s suppose we have a function foo() that takes two parameters, `T bar` and `U baz`. We have some constraints on them. One of them must have a nested type `Blah` that is `unsigned`.


#include <concepts>

template <typename T, typename U>
requires std::unsigned_integral<typename T::Blah> ||
std::unsigned_integral<typename U::Blah>
void foo(T bar, U baz) {
    // ...
}

class MyType {
public:
    using Blah = unsigned int;
    // ...
};

int main() {
    MyType mt;
    foo(mt, 5);
    foo(5, mt);
    // error: no operand of the disjunction is satisfied
    // foo(5, 3);
}


When we call `foo()` on **line 18** with an instance of `MyType` in the first position, the requirements are satisfied by the first part of the disjunction and the second one is short-circuited.

Let’s check the second case on **line 19**. We call `foo()` with an integer in the first place. Is its nested type `Blah unsigned`? It doesn’t even have a nested type! It’s just an `int`! It’s just an `int`!

What does this mean for us? If an expression does not evaluate to `true`, it doesn’t mean that the expression instead automatically evaluates to `false`. It can simply not be compilable at all.

For a normal boolean expression, we expect that the expression is well-formed and each subexpression is compilable.

That’s a big difference.

For concepts, the opposite of a `true` expression is not necessarily always `false`, but something that is either not well formed or `false`!

# `!a` is not the opposite of `a`

When we talk about concepts, the opposite of a `true` expression is not an expression that is evaluated to `false`. Let’s suppose we have a function foo() that takes two parameters, `T bar` and `U baz`. We have some constraints on them. One of them must have a nested type `Blah` that is `unsigned`.


Get an overview of how negation works with concepts.

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

Negations Using Concepts

`!a` is not the opposite of `a`

Negations Using Concepts

!a is not the opposite of a

`!a` is not the opposite of `a`