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

With classes, we can’t use the ______.

What is the output of the following code?

```c++
#include <concepts>
#include <iostream>

template <typename T>
concept my_integer = std::integral<T>;

template<typename U>
concept my_floating = std::floating_point;


template <typename T, typename U>
requires my_integer<T> && my_floating 
class WrappedNumber {
public:
 WrappedNumber(T num, U anotherNum) : m_num(num), m_anotherNum(anotherNum) {}
 T add(){ 
 return m_num + m_anotherNum;
 }
private:
 T m_num;
 U m_anotherNum;
};

int main() {
 WrappedNumber wn{42, 45.5};
 std::cout<<wn.add()<<std::endl;
}

```

What is the output of the following code?
<pre><code class="language-c++">#include &lt;concepts&gt;
#include &lt;iostream&gt;

template &lt;typename T&gt;
concept my_integer = std::integral&lt;T&gt;;

template&lt;typename U&gt;
concept my_floating = std::floating_point&lt;U&gt;;


template &lt;typename T, typename U&gt;
requires my_integer&lt;T&gt; &amp;&amp; my_floating &lt;U&gt;
class WrappedNumber {
public:
 WrappedNumber(T num, U anotherNum) : m_num(num), m_anotherNum(anotherNum) {}
 T add(){ 
 return m_num + m_anotherNum;
 }
private:
 T m_num;
 U m_anotherNum;
};

int main() {
 WrappedNumber wn{42, 45.5};
 std::cout&lt;&lt;wn.add()&lt;&lt;std::endl;
}

</code></pre>

What is the output of the following code?

```c++
#include <concepts>
#include <iostream>

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

template <Number T, std::same_as<T> U>
class WrappedNumbers {
 public:
 WrappedNumbers(T num, U anotherNum) : m_num(num), m_anotherNum(anotherNum) {}
 auto add(){
 return m_num + m_anotherNum;
 }
 private:
 T m_num;
 U m_anotherNum;
};

int main() {
 WrappedNumbers wns{5, 6.5};
 std::cout<<wns.add()<<std::endl;
}


```

What is the output of the following code?
<pre><code class="language-c++">#include &lt;concepts&gt;
#include &lt;iostream&gt;

template &lt;typename T&gt;
concept Number = std::integral&lt;T&gt; || std::floating_point&lt;T&gt;;

template &lt;Number T, std::same_as&lt;T&gt; U&gt;
class WrappedNumbers {
 public:
 WrappedNumbers(T num, U anotherNum) : m_num(num), m_anotherNum(anotherNum) {}
 auto add(){
 return m_num + m_anotherNum;
 }
 private:
 T m_num;
 U m_anotherNum;
};

int main() {
 WrappedNumbers wns{5, 6.5};
 std::cout&lt;&lt;wns.add()&lt;&lt;std::endl;
}


</code></pre>

What can be constrained in template classes with concepts?

What can be constrained in template classes with concepts?

**(True or False)** Member functions can be overloaded by constraining parameter types or return values.

(True or False) Member functions can be overloaded by constraining parameter types or return values.

Declare one overload with the constraint and one with its negated form

Declare one overload without the constraint and one with the constraint

Imagine you want to have two overloads: one in which `MyConcept` should be `true` and another in which `!MyConcept` should apply. Which implementation strategy below is the best?

Imagine you want to have two overloads: one in which <code>MyConcept</code> should be <code>true</code> and another in which <code>!MyConcept</code> should apply. Which implementation strategy below is the best?

When there are multiple overloads for member functions based on constraints, the ________ takes precedence. 

When there are multiple overloads for member functions based on constraints, the ________ takes precedence.

C++ concepts with classes

C++ concepts with classes

Let’s test your knowledge of concepts used with classes in C++

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

Quiz on C++ Concepts with Classes