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++

Concepts are part of the template declaration.

# Functions 
Using the concept `Sortable`.

### Implicit
```c++
template<Sortable Cont>
void sort(Cont& container){
...
}
```

The container has to be `Sortable`. 

The implicit version from the left is syntactic sugar to the explicit version:

### Explicit
```c++
template<typename Cont> 
   requires Sortable<Cont>()
void sort(Cont& container){
    ...
}
```


`Sortable` has to be a constant expression that is a predicate. That means that the expression has to be evaluable at compile-time and has to return a boolean.

If you invoke the sort algorithm with a container `lst` that is not sortable, you will get a unique error message from the compiler.

- Usage:
```c++
std::list<int> lst = {1998, 2014, 2003, 2011};
sort(lst); // ERROR: lst is no random-access container with <
```

> You can use concepts for all kind of templates.



# Classes

We can define a class template `MyVector` that will only accept objects as template arguments:

```c++
template<Object T>
class MyVector{};

MyVector<int> v1; // OK
MyVector<int&> v2 // ERROR: int& does not satisfy the constraint Object
```

Now, the compiler complains that the reference `(int&)`  is not an object. `MyVector` can be further adjusted.

>A reference is not an object.
  
## Methods of a Class   
```c++
template<Object T>
class MyVector{
   ...
   requires Copyable<T>()
   void push_back(const T& e);
   ...
};
```

Now the method  `push_back`  from `MyVector` requires that the template argument has to be copy-able. The concepts have to be placed before the method declaration.
  
# More Requirements
A template can have more than one requirement for its template parameters.

```c++
template <SequenceContainer S,
         EqualityComparable<value_type<S>> T>
Iterator_type<S> find(S&& seq, const T& val){ 
    ...
}
```
The function template `find` has two requirements. On one hand, the container has to store its elements in a linear arrangement (`SequenceContainer`), on the other hand, the elements of the container have to be equally comparable: `EqualityComparable<value_type<S>>`.

# Overloading

Concepts support the overloading of functions.
```c++
template<InputIterator I>
void advance(I& iter, int n){...}

template<BidirectionalIterator I>
void advance(I& iter, int n){...}

template<RandomAccessIterator I>
void advance(I& iter, int n){...}

std::list<int> lst{1,2,3,4,5,6,7,8,9}; 
std::list<int>:: iterator i = lst.begin();
std::advance(i, 2); // BidirectionalIterator
```
The function template `std::advance` puts its iterator `n` positions further. Depending if the iterator is a forward, a bidirectional, or a random access iterator, different function templates will be used. In case of a `std::list`, the `BidirectionalIterator` will be chosen.

Concepts also support the specialization of class templates.   


# Specialization
```c++
template<typename T>
class MyVector{};

template<Object T>
class MyVector{};

MyVector<int> v1; // Object T
MyVector<int&> v2; // typename T
```
For `MyVector<int&> v2`, the compiler uses the general template in the first line; on the contrary, the compiler uses for `MyVector<int>` the specialization `template<Object T> class MyVector{}`. 

* `MyVector<int&>` goes to the unconstrained template parameter. 
* `MyVector<int>` goes to the constrained template parameter.
   

Let's learn about coming C++ concepts in detail in this lesson.

Introduction

Basics

Details

Techniques

Design

Future

Conclusion

Functions and Classes

Functions

Implicit