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

# Fold Expressions (C++17)

Fold expressions is a nice syntax to evaluate binary operators at compile-time. Fold expressions reduce parameter packs on binary operators.
 
C++11 provides support for parameter packs:



bool all_14(){
  return true;
}

template<typename T, typename ...Ts>
bool all_14(T t, Ts ... ts){
  return t && all_14(ts...);
}


C++17 provides support for fold expressions:


template<typename ... Args>
bool all_17(Args ... args){
  return ( ... && args);
}

bool val == all_14(true, true, true, false)
         == all_17(true, true, true, false
         == ((true && true)&& true)&& false
         == false;


## Two variations
* The fold expression either has or does not have an initial value
* The parameter pack will be processed from left or right


C++17 supports the following 32 operators in fold expressions:

`+` `-` `*` `/` `%` `^` `&` `|` `=` `<` `>` `<<` `>>` `+=` `-=` `*=` `/=` `%=` `^=` `&=` `|=` `<<=` `>>=` `==` `!=` `<=` `>=` `&&` `||` `,` `.*` `->*`

Operators with their default values:

| **Operator** |   **Symbol**   | **Defualt Value** |
| ----- | -----| ----- |
| Logical AND |   `&&`   | `true` |
| Logical OR |   `||`   | `false` |
| Comma operator |   `,`   | `void()` |


For binary operators that have no default value, you have to provide an initial value. For binary operators that have a default value, you can specify an initial value.

If the ellipsis stands left of the parameter pack, the parameter pack will be processed from the left. The same holds for right. This is also true if you provide an initial value.

The following table shows the four variations and their Haskell pendants. The C++17 standard requires that fold expressions with initial value use the same binary operator `op`.


C++ templates support Haskells `fold*` variants at compile-time, i.e., `foldl`, `foldl1`, `foldr` and `foldr1`

| **Fold Expressions** |   **Haskell**   | **Description** |
| ----- | -----| ----- |
| **... op pack** |  **fold1 op list** | Processes from left with operator `op` |
| **pack op ...**| **foldr1 op list**  | Processes from right with operator `op` |
| **init op ... op pack** |  **foldl op init list** | Processes from left with operator `op` and initial value `init` |
| **pack op ... op init** | **foldr op init list**  | Processes from right with operator `op` and initial value `init` |


The C++ and Haskell variations differ in two points. The C++ version uses the default value as the initial value while the Haskell version uses the first element as the initial value. The C++ version processes the parameter pack at compile-time and the Haskell version, at run time. 

The small code snippet shows once more the algorithm `all` -- this time, we use `true` as the initial value.

```c++
template<typename... Args>
bool all(Args... args){ 
    return (true && ... && args); 
}

```

To learn more about fold expressions, click [here](https://en.cppreference.com/w/cpp/language/fold).


---
In the next lesson, we'll have a look at the examples of fold expressions.

In this lesson, we'll study fold expressions.

Introduction

Basics

Details

Techniques

Design

Future

Conclusion

Fold Expressions

Fold Expressions (C++17)

Two variations