👉🏻 If you want to enjoy the full experience exploring this pdf, check it out here Templates

• Templates are used when we have a function and want to use it with different data types
• Each template much have unique parameter names because templates can be overloaded

int add (int x, int y){
		return x + y;
}

double add (double x, double y){
		return x + y;
}
/*so here I wrote the function 2 times to be 
able to add integers and doubles
what if I want to pass a string, it is not logical 
to type a definition for every data type
here is when we use templates*/

//<typename T> is called template prefix
//T x is generic data type
//T add() is type parameter
template <typename T>
T add (T x, T y){
		return x + y;
}
/*first step to convert the function to a function template 
is writing the template keyword followed by <>
inside the <> we type a special parameter 
we either call it class or typename (typename is more preferred)
then we give this parameter a name and it is 'T' by convention
then we replace every data type in the function definition with 'T' */

//If you want to pass parameter of different types, 
//you have to explicitly tell the compiler how to treat them
//or which type to choose
add(1, 1.1); //would result in an error
<int> add(1, 1.1); //tells the compiler to treat both as int
                   //the error goes away

• All data types in template prefix must be used in template definition
• No actual code is generated until the function named in the template is called

Varadic Template

• What if I have a variable number of parameters?

  • here we use something called variadic parameter (…) or parameter pack
  • the template will somehow have a recursive behavior

  template<typename T>
  T add(T start){
      return start;
  }
  
  template<typename T, typename... Args>
  T sum(T start, Args...args){
  		return start + sum(args...);
  }
  
  sum(1, 2, 3);
  /* here is how it works
  sum(1, (2,3)){
      return 1 + sum(2,3);
  }
  sum(2,3){
      return 2 + sum(3);
  }
  sum(3){
  return 3 + 0;
  }
  so, it returns 3 + 2 + 1 = 6 
  

  • Firstly, you have to declare a template function with one parameter
  • then you define a template with two types, the first is a single typename T and the second is with variable number of typename Args
  • then you define two parameters for the function, the first one is a single parameter of type T, the second one is a variable number of parameters Args
  • then you return the first parameter value + the function of the rest parameters and the function keeps calling itself