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

# Recap
So far in this course, we’ve seen what concepts are and why they were introduced in C++20. We’ve also discussed how concepts can be used with functions, classes, and templates. We’ve explored what concepts are shipped with the standard library as well as how to write our own. In the previous chapter, we saw how to use constraints with various types of concepts. 

# Using Numbers

We’ve been playing with a concept called `Number` throughout the entire course. Let’s go over a quick reminder why:

#include <concepts>
#include <iostream>

template <typename T>
concept Number = std::integral<T> || std::floating_point<T>;

auto add(Number auto a, Number auto b) {
    return a+b;
}

int main() {
    std::cout << "add(1, 2): " << add(1, 2) << '\n';
    std::cout << "add(1, 2.5): " << add(1, 2.14) << '\n';

    // std::cout << "add(\"one\", \"two\"): " << add("one", "two") << '\n'; 
    // error: invalid operands of types 'const char*' and 'const char*' to binary 'operator+'
    std::cout << "add(true, false): " << add(true, false) << '\n';
}


## Before C++20
Our problem is that even though we only want to accept integrals and floating-point numbers, boolean values are also accepted. They are accepted because `bool` is an integral type.

Furthermore, `add(0, 'a')` returns 97 because `a` is a character and it’s considered an integral type. The ASCII code of `a` is 97. If we add that to 0, we get the result of this function call.

Let’s suppose that we want to accept any numbers, particularly real numbers.

For that, we have to limit the types we accept. Because `std::is_floating_point` returns `true` only for `float`, `double`, and `long double` values, we can accept its results. However, it’s not enough. As we already saw, `std::is_integral` returns `true` for some types that we might not want to accept as numbers.

The following types and their `const` and/or `unsigned` versions are considered integral:

* `bool`
* `char`, `char8_t`, `char16_t`, `char32_t`, `wchar_t` 
* `short`, `int`, `long`, `long long`

We, however, want to accept types from the third line only, not any boolean values or characters. Before C++20, we’d have to either disallow certain overloads or use static assertions with templates to make sure that only certain types would be accepted.

```c++
template<typename T>
T addPreCpp20(T a, T b) {
    static_assert(std::is_integral_v<T>, "addPreCpp20 requires integral types");
    return a+b;
}

```

The main problem with the previous methods is that we have to do the same steps for each function and parameter.

With overloads, we might end up with a too-long list of combinations. Templates are too permissive and they accept just any type regardless of our intentions.


## After C++20

In C++20, however, we have concepts! We only need to define the concept `Number` once. It’s easy to use it anywhere later on.

Let’s revisit our requirements:
* We only deal with built-in types, so we ignore user-defined numeric types.
* We want to accept floating-point numbers.
* We want to accept integral numbers.
* We don’t want to accept integral types that can be converted to `int` values, such as `bool` and `char` values.

As the first trial, we can try something like this:


Let’s see a couple of real-world examples and areas where concepts are applicable.



Use Cases for Numbers

Let’s see a couple of real-world examples and areas where concepts are applicable.

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

Use Cases for Numbers

Recap

Using Numbers

Before C++20