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-Traits Library
Type-traits enable type checks, type comparisons, and type modifications at compile-time.

Below are some applications of template metaprogramming:
  * Programming at compile-time
  * Programming with types and values
  * Compiler translates the templates and transforms it in C++ source code

We need to add a `type_traits` library in the header to enable all the functions present in the library.

```c++
#include <type_traits>
```

# Type-Traits: Goals


If you look carefully, you'll see that type-traits have a significant optimization potential. In the first step, type-traits help to analyze the code at compile-time and in the second step, to optimize the code based on that analysis. How is that possible? Depending on the type of variable, a faster variant of an algorithm will be chosen. 

## Optimization

* Code that optimizes itself. Depending on the type of a variable another code will be chosen.
* Optimized version of `std::copy`, `std::fill`, or `std::equal` is used so that algorithms can work on memory blocks. 
* The optimized version of operations happens on all the elements in a container in one step and not on each element individually.

## Correctness

* Type checks will be performed at compile-time.
* Type information, together with `static_assert`, defines the requirements for the code.
* With the [concepts](https://www.educative.io/courses/generic-templates-in-cpp/predefined-concepts) in C++20, the correctness aspect of the type-traits becomes less important.




  
# Type Checks

C++ has 14 primary type categories. They are complete and orthogonal. This means, that each type is a member of exactly one type category. The check for the type categories is independent of the type qualifiers `const` or `volatile`. 

Let's have a look at these categories syntactically:  



 

In this lesson, we'll study the type traits library and its goals along with type-checks. This section could only provide an overview of the many functions of the type-traits library. 

Introduction

Basics

Details

Techniques

Design

Future

Conclusion

Type-Traits Overview

Type-Traits Library #

Type-Traits: Goals #