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

# Example 1: Type Erasure Using Object-Oriented  Programming

// typeErasureOO.cpp

#include <iostream>
#include <string>
#include <vector>

struct BaseClass{
	virtual std::string getName() const = 0;
};

struct Bar: BaseClass{
	std::string getName() const override {
		return "Bar";
	}
};

struct Foo: BaseClass{
	std::string getName() const override{
		return "Foo";
	}
};

void printName(std::vector<BaseClass*> vec){
    for (auto v: vec) std::cout << v->getName() << std::endl;
}


int main(){
	
	std::cout << std::endl;
	
	Foo foo;
	Bar bar; 
	
	std::vector<BaseClass*> vec{&foo, &bar};
	
	printName(vec);
	
	std::cout << std::endl;
}

## Explanation

The key point is that you can use instances of `Foo` or `Bar` instead of an instance for `BaseClass`. `std::vector<BaseClass*>` (line 35) has a pointer to `BaseClass`. Well, actually it has two pointers to `BaseClass` (derived) objects and it is a vector of such pointers.
 `BaseClass` is an abstract base class, which is used in line 23. `Foo` and `Bar` (lines 11 and 17) are the concrete classes.

What are the pros and cons of this implementation with object-orientation?

### Pros:

* Type-safe
* Easy to implement

### Cons:

* Virtual dispatch
* Intrusive because the derived class must know about its base class


In this lesson, we'll look at a couple of examples of type erasure.

Introduction

Basics

Details

Techniques

Design

Future

Conclusion

- Examples

Example 1: Type Erasure Using Object-Oriented Programming

Explanation