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

# Template Metaprogramming
## How this all started:
* 1994 Erwin Unruh discovered template metaprogramming by accident.
* His program failed to compile but calculated the first 30 prime numbers at compile-time.
* To prove his point, he used the error messages to display the first 30 prime numbers.


Let's have a look at the screenshot of the error: 

We have highlighted the important parts in red. We hope you can see the pattern. The program calculates at compile-time the first *30* prime numbers. This means template instantiation can be used to do math at compile-time. It gets even better. Template metaprogramming is [Turing-complete](https://simple.wikipedia.org/wiki/Turing_complete) and can, therefore, be used to solve any computational problem. Of course, Turing-completeness holds only in theory for template metaprogramming because the recursion depth (at least 1024 with C++11) and the length of the names which are generated during template instantiation provide some limitations.

The `Factorial` program is the _Hello World_ of template metaprogramming.

template <int N>
struct Factorial{
    static int const value= N * Factorial<N-1>::value;
};

template <> struct Factorial<1>{
    static int const value = 1;
};

std::cout << Factorial<5>::value << std::endl;
std::cout << 120 << std::endl;

The call `Factorial<5>::value` in line 10 causes the instantiation of the primary or general template in line 3. During this instantiation, `Factorial<4>::value` will be instantiated. This recursion will end if the fully specialized class template `Factorial<1>` (line 6) kicks in as the boundary condition. Maybe, you like it more pictorial.

The following picture shows this process.

In this lesson, we'll learn about template metaprogramming.

Introduction

Basics

Details

Techniques

Design

Future

Conclusion

Template Metaprogramming

Template Metaprogramming

How this all started:

Calculating at Compile-Time