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

// gcdVariation.cpp

#include <iostream>
#include <type_traits>
#include <typeinfo>

template<typename T1, typename T2, 
         typename R = typename std::conditional <(sizeof(T1) < sizeof(T2)), T1, T2>::type>
R gcdConditional(T1 a, T2 b){
  static_assert(std::is_integral<T1>::value, "T1 should be an integral type!");
  static_assert(std::is_integral<T2>::value, "T2 should be an integral type!");
  if( b == 0 ){ return a; }
  else{
    return gcdConditional(b, a % b);
  }
}


template<typename T1, typename T2, 
         typename R = typename std::common_type<T1, T2>::type>
R gcdCommon(T1 a, T2 b){
  static_assert(std::is_integral<T1>::value, "T1 should be an integral type!");
  static_assert(std::is_integral<T2>::value, "T2 should be an integral type!");
  if( b == 0 ){ return a; }
  else{
    return gcdCommon(b, a % b);
  }
}

int main(){


  std::cout << std::endl;

  std::cout << "gcdConditional(100, 10LL) = " << gcdConditional(100, 10LL) << std::endl;
  std::cout << "gcdCommon(100, 10LL) = " << gcdCommon(100, 10LL) << std::endl;
  
  std::conditional <(sizeof(int) < sizeof(long long)), int, long long>::type gcd1 = gcdConditional(100, 10LL);
  auto gcd2 = gcdCommon(100, 10LL);
  
  std::cout << std::endl;
  
  std::cout << "typeid(gcd1).name() = " << typeid(gcd1).name() << std::endl;
  std::cout << "typeid(gcd2).name() = " << typeid(gcd2).name() << std::endl;

  std::cout << std::endl;

}


## Explanation

In the above code, we have defined an automatic return type `R` which returns data based on the data type passed in the function `gcdCommon` and `gcdConditional`.

Automatic return type deduction can't be used in both algorithms, because both algorithms solve their job by recursion (lines 24 and 26). The critical observation is that this recursion swaps their arguments. For example, `gcdCommon(a, b)` invokes `gcdCommon(b, a % b)`. This recursion, therefore, creates a function with different return types. Having a function with different return types is not valid. 




In this lesson, we'll look at the solution review of the last exercise.

Introduction

Basics

Details

Techniques

Design

Future

Conclusion

- Solution

Solution Review