Explore the power of C++ templates, from function and class basics to advanced features like instantiation and concepts, enhancing code flexibility, reusability, and abstraction without performance loss.

cpp17.tar.gz

C++17

C++20

Templates are one of the many powerful features of Modern C++ programming. And with each new C++ standard, they become more important. 

Templates provide an efficient way to make your code more flexible and reusable, this way you can avoid repeating code that would otherwise be identical except for different types. Templates also give you the ability to provide abstraction without a performance penalty.

However, templates can be difficult to apply, can be counterintuitive, and have tricky error messages.

This course gives you the necessary information to overcome these hurdles and dive into the advanced topics. You’ll visit the basics such as function and class templates, and then explore the details to templates such as instantiation and fold expressions. Our journey also includes techniques based on templates, the design, and future directions of templates such as concepts. Based on this exhaustive tour of templates, a basic understanding of C++ is sufficient to master this course.

Let’s get started!

Generic Programming Templates in C++

The first question we have to answer is quite obvious. What is a Regular or a SemiRegular type? Our answer is based on the proposal [p0898](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0898r3.pdf). We assume you may have already guessed it that Regular and SemiRegular are concepts, which are defined by other concepts. Given is the list of all concepts.

## Regular

* DefaultConstructible
* CopyConstructible, CopyAssignable
* MoveConstructible, MoveAssignable
* Destructible
* Swappable
* EqualityComparable




## SemiRegular

* Regular without EqualityComparable

The term Regular goes back to the father of the Standard Template Library [Alexander Stepanov](https://en.wikipedia.org/wiki/Alexander_Stepanov). He introduced the term in his book Fundamentals of Generic Programming. Here is a [short excerpt](http://stepanovpapers.com/DeSt98.pdf). It's quite easy to remember the eight concepts used to define a regular type. First, there is the well-known [rule of six](https://www.modernescpp.com/index.php/c-core-guidelines-constructors-assignments-and-desctructors):

*  Default constructor: `X()`
*  Copy constructor: `X(const X&)`
*  Copy assignment: `operator=(const X&)`
*  Move constructor: `X(X&&)`
*  Move assignment: `operator=(X&&)`
*  Destructor: `~X()`


Second, add the Swappable and `EqualityComparable` concepts to it. There is a more informal way to say that a type `T` is regular: `T` behaves like an `int`. 

To get SemiRegular, we have to subtract `EqualityComparable` from Regular.



In this lesson, we'll gain an understanding of the important predefined concepts: Regular and SemiRegular.

Introduction

Basics

Details

Techniques

Design

Future

Conclusion

Define your Concept: Regular and SemiRegular

Regular

SemiRegular