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

# CRTP

The acronym [CRTP](https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern) stands for the C++ idiom **C**uriously **R**ecurring **T**emplate **P**attern and is a technique in C++ in which a `Derived` class derives from a class template `Base`. The key is that `Base` has `Derived` as a template argument.

Let's have a look at an example:
```c++
template<class T> 
class Base{
   ...
};

class Derived: public Base<Derived>{ 
   ...
};
```

> CRTP enables static polymorphism.


# Typical use-case

There are two typical use-cases for CRTP: Mixins and static polymorphism.

## Mixins

[Mixins](https://en.wikipedia.org/wiki/Mixin) is a popular concept in the design of classes to mix in new code. Therefore, it's an often-used technique in Python to change the behavior of a class by using multiple inheritances. In contrast to C++, in Python, it is legal to have more than one definition of a method in a class hierarchy. Python simply uses the method that is first in the [Method Resolution Order](https://docs.python.org/3/glossary.html#term-method-resolution-order) (MRO).

You can implement mixins in C++ by using CRTP. A prominent example is the class `std::enable_shared_from_this`. By using this class, you can create objects that return an `std::shared_ptr` to themselves. We have to derive your class `MySharedClass` public from `std::enable_shared_from_this`. Now, our class `MySharedClass` has a method `shared_from_this`. 

An additional typical use-case for mixins is a class that you want to extend with the capability that their instances support the comparison for equality and inequality.


## Static Polymorphism

Static polymorphism is quite similar to dynamic polymorphism. But contrary to dynamic polymorphism with virtual methods, the dispatch of the method calls will take place at compile-time. Now, we are at the center of the CRTP idiom.

```c++
class ShareMe: public std::enable_shared_from_this<ShareMe>{
  std::shared_ptr<ShareMe> getShared(){
    return shared_from_this();
  } 
};
```
- `std::enable_shared_from_this` creates a `shared _ptr` for an object.
- `std::enable_shared_from_this:` base class of the object.
- `shared_from_this:` returns the shared object


To learn more about CRTP, click [here](https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern).

---
In the next lesson, we'll look at a couple of examples of CRTP.

Introduction

Basics

Details

Techniques

Design

Future

Conclusion

CRTP

CRTP