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

# Type Erasure
Type Erasure enables you to use various concrete types through a single generic interface.
> Type erasure is duck typing applied in C++

“*When I see a bird that walks like a duck and swims like
a duck and quacks like a duck, I call that bird a duck.*” ([James Whitcomb Rileys](https://en.wikipedia.org/wiki/James_Whitcomb_Riley))

Of course, you've already used type erasure in C++ or C. The C-ish way of type erasure is a `void` pointer; the C++ish way of type erasure is object-orientation.

# Typical Use Case

Type erasure can be performed with `void` pointers, object-orientation, or templates.
  

## Case 1: Void Pointers 
```c++
void qsort(void *ptr, std::size_t count, std::size_t size, cmp);
```
Before the `qsort()`, consider using:
```c++
int cmp(const void *a, const void *b);
```

The comparison function `cmp` should return a

 *   **negative integer:** the first argument is less than the second
 *  **zero:** both arguments are equal
 *  **positive integer:** the first argument is greater than the second

Thanks to the `void` pointer, `std::qsort` is generally applicable but also quite error-prone.

Maybe you want to sort a `std::vector<int>`, but you used a comparator for C-strings. The compiler cannot catch this error because the type of information was removed and we end up with undefined behavior.

In C++ we can do better.


## Case 2: Object-Orientation

Having a class hierarchy and using the `BaseClass` pointer instead of concrete types is one way to enable type erasure
```c++
std::vector<const BaseClass*> vec;
```
The `vec` object has a pointer to a `constant BaseClasses`. 
## Case 3: `std::function`

`std::function` as a polymorphic function wrapper is a nice example of type erasure in `C++`. `std::function` can accept everything, which behaves like a function. To be more precise, this can be any callable such as a function, a function object, a function object created by `std::bind`, or just a lambda function.

Let's have a look at the difference between the three types listed above in the following table:
|**Technique**| **Each Datatype**|**Type-safe Interface**| **Easy to implment**| **Common Base Class**|
|----|-----|----|----|----|
| **void\***| Yes | No| Yes| No|
| **Object-Orientation**| No| Yes| Yes| Yes|
|  **Templates** |Yes| Yes| No| No|




In this lesson, we'll learn about type erasure in detail.

Introduction

Basics

Details

Techniques

Design

Future

Conclusion

Idioms and Patterns: Type Erasure

Type Erasure

Typical Use Case