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

# Automatic Return Type
A function template is automatically able to deduce their return type.

```c++
template <typename T1, typename T2>
auto add(T1 fir, T2 sec) -> decltype( fir + sec ) { 
  return fir + sec;
}
```
> The automatic return type deduction is typically used for function templates but can also be applied to non-template functions.



**Rules:**
* **`auto`:** introduces the syntax for the delayed return type
* **`auto`:** `auto` type deduction is based on the function template argument deduction. Function template argument deduction ([decays](https://en.cppreference.com/w/cpp/types/decay)). So it means `auto` does not return the exact type but a decayed type such as for [template argument deduction](https://www.educative.io/courses/generic-templates-in-cpp/template-arguments)





* **`decltype`:** declares the return type
* The alternative function syntax is obligatory

> The C++11 syntax for automatically deducing the return type breaks the crucial principle of software development: DRY. DRY stands for [**D**on't **R**epeat **Y**ourself](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself).
   
# Automatic Return Type: C++14

A function template is automatically able to deduce their return type.
```c++
template <typename T1, typename T2>
auto add(T1 fir, T2 sec){
    return fir + sec;
}
```
**Rules**
* **auto:** introduces the syntax for the delayed return type
* ~~`decltype`: declares the return type~~
* ~~The alternative function syntax is obligatory.~~
      


With the expression `decltype(auto)`, `auto` uses the same rules to determine the type as `decltype`. This means, in particular, no [decay](https://en.cppreference.com/w/cpp/types/decay) takes place.
* Both declarations are identical.
```c++
   decltype(expr) v= expr;
   decltype(auto) v= expr;
```
* The syntax also applies for the automatic return type of a function template.
```c++
   template <typename T1, typename T2> 
   decltype(auto) add(T1 fir, T2 sec){
       return fir + sec;
   }
```
> When a function template has more than one return statements, all return statements must have the same type.

---
In the next lesson, we’ll study an example of automatic return type deduction. 

In this lesson, we'll look at the technique that deduces return type automatically.

Introduction

Basics

Details

Techniques

Design

Future

Conclusion

Automatic Return Type

Automatic Return Type