We will analyse such code
#include <iostream>
template <typename T, typename U>
class SomeClass {
public:
T getValue() { return value; }
private:
T value = {};
U* ptr = nullptr;
};
int main() {
SomeClass<int, void> sc;
std::cout << sc.getValue() << std::endl;
return 0;
} template <typename T1, typename T2, typename I>
class A {}; // primary template
template<typename T, typename I>
class A<T, T*, I> {}; // #1: partial specialization where T2 is a pointer to T1
template<typename T, typename T2, typename I>
class A<T*, T2, I> {}; // #2: partial specialization where T1 is a pointer
template<typename T>
class A<int, T*, double> {}; // #3: partial specialization where T1 is int, I is double,
// and T2 is a pointer
template<typename X, typename T, typename I>
class A<X, T*, I> {}; // #4: partial specialization where T2 is a pointer Your abilities after Templates – Basics training
- can read and understand the code with function and class templates
- can write universal and generic code with function and class templates
- know how to specialize templates
- know how to partially specialize template classes and variables
- know when to avoid template specialization
- know the overload resolution rules and can predict which overload will be called
Agenda
- intro and pre-test
- function templates
- type traits library
- class templates
- specializations
- overload resolution rules
- partial specializations
- variable templates
- recap
Activities
- pre-work to be done before our training
- pre-test pre-test at the beginning
- exercises followed by trainers implementation
- coding dojo
- participants solutions code review
- post-work with code review
- post-test one week after the training
- certificate of completion
Duration
- 1 day (7 hours with breaks)
Form
- online
- classroom
