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

// templateTypeParameter.cpp

#include <iostream>
#include <typeinfo>

class Account{
public:
  explicit Account(double amt): balance(amt){}
private:
  double balance;

};

union WithString{
  std::string s;
  int i;
  WithString():s("hello"){}
  ~WithString(){}
};

template <typename T>
class ClassTemplate{
public:
  ClassTemplate(){
    std::cout << "typeid(T).name(): "  << typeid(T).name() << std::endl;
  }
};

int main(){

  std::cout << std::endl;

  ClassTemplate<int> clTempInt;
  ClassTemplate<double> clTempDouble;
  ClassTemplate<std::string> clTempString;

  ClassTemplate<Account> clTempAccount;
  ClassTemplate<WithString> clTempWithString;

  std::cout << std::endl;

}

## Explanation 

In the above code, we are identifying the type of different data types that we have passed in the parameter list. We can identify the type of variable passed to the function by using the keyword `typeid` in line 25. If we pass `string` or `class` type object in the parameter list, it will display the type of parameter passed along with the size of the object.

// array.cpp

#include <algorithm>
#include <array>
#include <iostream>

int main(){

  std::cout << std::endl;

  // output the array
  std::array <int,8> array1{1,2,3,4,5,6,7,8};
  std::for_each( array1.begin(),array1.end(),[](int v){std::cout << v << " ";});

  std::cout << std::endl;

  // calculate the sum of the array by using a global variable
  int sum = 0;
  std::for_each(array1.begin(), array1.end(),[&sum](int v) { sum += v; });
  std::cout << "sum of array{1,2,3,4,5,6,7,8}: " << sum << std::endl;

  // change each array element to the second power
  std::for_each(array1.begin(), array1.end(),[](int& v) { v=v*v; });
  std::for_each( array1.begin(),array1.end(),[](int v){std::cout << v << " ";});
  std::cout << std::endl;

  std::cout << std::endl;
}

## Explanation


When you define an `std::array` in line 12, you have to specify its size. The size is a non-type template argument, which has to be specified at compile-time.

Therefore, you can output `array1` in line 13 with a lambda-function `[]` and the range-based for-loop. By using the summation variable `sum` in line 19, you can sum up the elements of the `std::array`. The lambda-function in line 23 takes its arguments by reference and can, therefore, map each element to its square. There is nothing really special, but we are dealing with an `std::array`.




With C++11 we have the free function templates `std::begin` and `std::end` returning iterators for a C array. A `C` array is quite comfortable and safe to use with these function templates because we don't have to remember its size.

In this lesson, we'll learn about the examples of template parameters.

Introduction

Basics

Details

Techniques

Design

Future

Conclusion

- Examples

Example 1: Type Parameter

Explanation

Exam