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

// templateClassTemplate.cpp

#include <iostream>

class Account{
public:
  explicit Account(double amount=0.0): balance(amount){}

  void deposit(double amount){
    balance+= amount;
  }

  void withdraw(double amount){
    balance-= amount;
  }
  
  double getBalance() const{
    return balance;
  }

private:
  double balance;
};

template <typename T, int N>
class Array{

public:
  Array()= default;
  int getSize() const;

private:
  T elem[N];
};

template <typename T, int N>
int Array<T,N>::getSize() const {
  return N;
}

int main(){

  std::cout << std::endl;

  Array<double,10> doubleArray;
  std::cout << "doubleArray.getSize(): " << doubleArray.getSize() << std::endl;

  Array<Account,1000> accountArray;
  std::cout << "accountArray.getSize(): " << accountArray.getSize() << std::endl;

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

## Explanation

We have created two `Array` class objects, i.e., `doubleArray` and `accountArray` in lines 45 and 48. By calling generic function `getSize()` in line 37, we can access the size of different objects.

# Example 2: Inheritance in Class Templates

// templateClassTemplateInheritance.cpp

#include <iostream>

template <typename T>
class Base{
public:
  void func1() const {
    std::cout << "func1()" << std::endl;
  }
  void func2() const {
    std::cout << "func2()" << std::endl;
  }
  void func3() const {
    std::cout << "func3()" << std::endl;
  }
};

template <typename T>
class Derived: public Base<T>{
public:
  using Base<T>::func2;
  
  void callAllBaseFunctions(){
    this->func1();
    func2();
    Base<T>::func3();
  }
};

int main(){
  std::cout << std::endl;

  Derived<int> derived;
  derived.callAllBaseFunctions();

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

## Explanation

We have implemented both a `Base` and a `Derived` class. `Derived` is publicly inherited from `Base` and may, therefore, use in its method `callAllBaseFunctions` in line 24, the methods `func1`, `func2`, and `func3` from the `Base` class.

* **Make the name dependent:** The call `this->func1` in line 25 is dependent. The name lookup will consider in this case all base classes.

* **Introduce the name into the current scope:** The expression `using Base<T>::func2` (line 22) introduces `func2` into the current scope.

* **Call the name fully qualified:** Calling `func3` fully qualified (line 27) will break a virtual dispatch and may cause new surprises.

We have created a `Derived` class object named `derived`. By using this object, we can access the base class functions by calling the method `callAllBaseFunctions`.




In this lesson, we'll learn about the examples of class templates.

Introduction

Basics

Details

Techniques

Design

Future

Conclusion

- Examples