C++ Templates. SFINAE

C++ Templates. SFINAE.
Denys Petrov
September 2019

3
Agenda
1. Template syntax by standards
2. SFINAE
3. Introspection and reflection at compile-time
4. Partial and full specialization
5. Conditional expressions
6. Transformations
7. Conditional statements
8. Tag dispatching

4
Template Syntax by Standards

5
Templates of:
● functions
● classes
Kind of template parameters:
● type
● non-type integral types only
● template
template <typename T>
void function() {}
class Class {};
template <int i>
template <template < typename > class T>
Keywords:
● template
● typename
● class
С++03

6
class vs typename
typename
• introduced to replace class
keyword and to avoid confusions
• used in template context only
class
• initially used as template parameter
by Bjarne Stroustrup before official
C++98
• used for class declarations
Both keywords are interchangeable except two cases:
• template <template < typename > class T> // until С++17
• typename T::type;

7
Parameter pack and operator sizeof...
template <typename... T>
void function(T... args)
{
const int num = sizeof...(args);
const int sum = (args + ...);
}
constexpr int x = 42;
constexpr int pow2(int n)
{
return n * n;
}
Keyword constexpr
С++11
New context for keyword using
using AliasType = MyClass;
using AliasType = MyClass <int>;
template<typename T>
using AliasType = MyClass <T>;
int x = 42;
decltype(x) var1; // int
int& function(int);
decltype(function(x)) var2; // int&
Keyword decltype

8
typedef vs using
typedef
assign synonyms to:
• types
• fully specialized templates
typedef int Int;
typedef void (*FuncPtr) (int);
typedef typename std::vector < int >::iterator IteratorInt;
template<typename T> using Vector = std::vector < T >;
template<typename T> using Iterator = typename std::vector < T >::iterator;
using Int = int;
using FuncPtr = void (*) (int);
using IteratorInt = typename std::vector < int >::iterator;
using
assign aliases to:
• types
• fully specialized templates
• partially specialized templates

9
Return auto Rvalue reference declarator
auto function()-> int
{
return 42;
}
auto function2(T t)-> typename T::value_type
{
typename T::value_type v = 42;
return v;
}
auto function3(T t)-> decltype(t[0])
{
return t[0];
}
void func_int(int&) { }
void func_int(int&&) { }
void function(T&& t){
func_int(t);
}
function(i); //t = int&, func_int(int&)
function(42); //t = int&&, func_int(int&)
void function(T&& t){
func_int(std::forward <T> (t));
}
function(i); //t = int&, func_int(int&)
function(42); //t = int&&, func_int(int&&)
С++11

10
Added templates of variables
//function
void function() {}
//class
class Class {};
//variables
const T PI = static_cast <T> (3.14159265);
constexpr int value = T::value;
С++14

11
Added operator constexpr if
if constexpr (true)
{
// compiled
}
else
{
// discarded
}
if constexpr (sizeof...(args) == 2)
{
// ...
}
if constexpr (false)
{
//static_assert(false);
static_assert(std::dependent_false<T>::value);
}
С++17

12
Template auto as unknown non-type parameter
//function
template <auto value>
void function() {}
//class
template <auto value>
class Class {};
//variadic class
template <auto... value>
class Class {};
Class <42, 'X', true> //heterogeneous
//function
template <typename T, T value>
void function() {}
//class
template <typename T, T value>
class Class {};
//variadic class
template <typename T, T... value>
class Class {};
Class <int, 42, 43, 44> //homogeneous
C++17 C++14
С++17

13
1. Debug > Project Properties > C/C++ > Language > C++ Language Standard
1. Debug > Project Properties > General > C++ Language Standard
Changing Standard in Visual Studio
1
2
3
4

14
Concepts
concept MyConcept1 = sizeof(T) == 1;
concept MyConcept2 = false;
template <class T>
concept MyConcept3 = MyConcept1<T> && ! MyConcept2<T>;
template <MyConcept3 T>
struct S {};
С++20

16
SFINAE - SUBSTITUTION FAILURE IS NOT AN ERROR
• Abbreviation introduced by David Vandevoorde
• Based on a template syntax
• Result of the order of a template substitution
• Make possible a reflection
• Constrains the range of applied types

17
Existing Implementations of SFINAE
• <boost/type_traits.hpp> boost
• <type_traits> STL
• <xtr1common> STL
• <Windows Kits10Include10.0.16299.0winrtwrlinternal.h>
• <Windows Kits10Include10.0.16299.0ucrtcorecrt.h>
• <Windows Kits10Include10.0.16299.0winrtwindows.foundation.collections.h>

18
Introspection and Reflection at
Compile-time

19
Introspection and Reflection
Metaprogramming (or Generic Programming) is a technique in which
program have the ability to generate, analyze or transform code using
compile-time computation.
Reflection is the ability of a program to examine, introspect, and modify its
own structure and behavior.
Introspection is the ability of a program to examine the type or properties of
an object at runtime.
Runtime for metaprogramming is a compile-time.

20
Correct Incorrect
template <typename T1, typename T2>
class Class { };
class Class <T, typename T::NestedType> { };
class Class : T::NestedType1 { };
class Class <const T> : T::NestedType2 { };
template <typename T,
typename = typename T::NestedType>
class Class { };
class Class
{ using type = typename T::NestedType };
template <typename T,
typename = typename T::NestedType>
void function ()
{
}
void function ()
{
typename T::NestedType var;
}
auto function (T t) -> decltype(t.foo())
{
return t.foo();
}
auto function (T t)
{
return t.foo();
}
Use Cases

21
Object Inspection
• Partial and full specialization
- Classes
- Functions
• Conditional expressions
- Boolean types
- Logical operators
- Predicates
• Transformations
- Modifiers
• Conditional statements
- If operator
- Switch operator
• Tag dispatching

22
Partial and Full Specialization

23
Class Template Specialization
Primary class template:
class Class { };
Full specialization:
template <>
class Class <int, char> { };
Partial specialization:
class Class <int, const T> { };
Examples:
Class <const char, int&> c1;
Class <int, const int*> c2;
Class <char*, int[10]> c3;

24
class Class {};
class Class <const T *> {};
class Class <const T> {};
Class <int> -> Class <T> -> T = int
Class <const int> -> Class <const T> -> T = int
Class <int * const> -> Class <const T> -> T = int*
Class <const int *> -> Class <const T *> -> T = int
Class <const int * const> -> Class <const T> -> T = const int*
Template Type Deduction
Instantiation Substitution Deduction

25
Type Deduction Table
C - const V - volatile T - type
Parameter
Specialization

26
Example
Class specialization
class Class {};
class Class <const T> { };
Class <const volatile int> c1; -> Class <const T> -> T = volatile int

27
Type Deduction Table &

28
Type Deduction Table &&

29
Instantiated type: const volatile int * const volatile
1. Class <const volatile T * const volatile> -> T = int
1. Class <volatile T * const volatile> -> T = const int
1. Class <const T * const volatile> -> T = volatile int
1. Class <T * const volatile> -> T = const volatile int
1. Class <const volatile T> -> T = const volatile int *
1. Class <volatile T> -> T = const volatile int * const
1. Class <const T> -> T = const volatile int * volatile
1. Class <T> -> T = const volatile int * const volatile
* error C2752: more than one partial specialization matches the template argument list
Substitution Preference Order
*
*

30
Partial specialization with lower or equal amount of parameters:
class Class <int, const T> { }; // ONE type
One More Class Template Specialization
Partial specialization with bigger amount of parameters:
template <template <typename, typename> typename T1, typename T2, typename T3>
class Class <???> { }; // THREE types (one of them is a template type)
template <typename T, size_t value>
class Class <???> { }; // ONE type, ONE variable
template <typename T1, typename T2, typename... T3>
class Class <???> { }; // Variable amount of types (minimum TWO)
class Class { }; // TWO types

31
One More Class Template Specialization
Partial specialization with bigger amount of parameters:
template <template <typename, typename> typename T1, typename T2, typename T3>
class Class <T1 <T2, T3>, T2&> { }; // std::vector<int>
template <typename T, size_t value>
class Class <T[value], T> { }; // char[10]
template <typename T1, typename T2, typename... T3>
class Class <T1(*)(T3...), T2> { }; // int(*)(float&, const int)
Partial specialization with lower or equal amount of parameters:
class Class <int, const T> { };
class Class { };

32
Function Template Specialization
Function template:
void func (T) { };
Full specialization:
template <>
void func <int *> (int *) { };
Example:
int i = 42;
func(i);
func(&i);
“Partial” specialization (Overloading):
void func (T *) { };

33
Function Template Argument Deduction Table
Parameter
Argument

34
Example
Function declaration
void func(const T arg) { };
int* ptr = nullptr;
function(ptr); -> func <T*> -> decltype(arg) = int * const

35
Function Template Argument Deduction Table &

36
Function Template Argument Deduction Table &&

38
Boolean types
bool value1 = true;
bool value2 = false;
struct True
{
};
struct False
{
};
Traditional Programming Metaprogramming

39
Logical operators. Conjunction.
&&
Traditional Programming
template <typename BOOL1, typename BOOL2>
struct AND
{
using result = False;
};
template <>
struct AND <True, True>
{
using result = True;
};
Metaprogramming

40
Logical operators. Disjunction.
||
template <typename BOOL1, typename BOOL2>
struct OR
{
};
template <>
struct OR <False, False>
{
};

41
Logical operators. Inversion.
!
template <typename BOOL>
struct NOT
{
};
template <>
struct NOT <False>
{
};
Metaprogramming

42
Example
typename AND <
typename OR <
True,
False
>::result,
typename NOT <
False
>::result
>::result
OR
NOT
AND
( true || false ) && ( ! false )
typename AND < typename OR < True, False >::result, typename NOT < False >::result >::result;
Metaprogramming

43
Predicates. Qualifier Check.
bool IsConst(T);
struct IsConst
{
};
struct IsConst <const T>
{
};

44
Predicates. Reference Check.
bool IsReference(T);
struct IsReference
{
};
struct IsReference <T&>
{
};

45
Class Template With Default Parameter
template <typename T, typename = void>
struct Class { };
struct Class <T, void> { };
Class <int>; -> struct Class <T, void>
Class <int, void>; -> struct Class <T, void>
Class <int, char>; -> struct Class

46
Complicated Predicates. Method Check.
using Wrap = void;
template <typename T, typename = void>
struct HasMethodFooImpl { using result = False; };
struct HasMethodFooImpl <T, Wrap <decltype(&T::foo)> > { using result = True; };
constexpr bool HasMethodFoo = HasMethodFooImpl <T>::result;

47
Method Check. Painfull version before C++11
struct HasMethodFooImpl
{
typedef char One;
typedef struct { One x[2]; } Two;
template <typename T, void(T::*func)() = &T::foo>
static One test();
static Two test(...);
static const bool value = sizeof(test<T>(0)) == sizeof(One);
};
Example
const bool HasMethodFoo = HasMethodFooImpl <T>::value;

49
Add Сonstancy
Result AddConst(T);
struct AddConst
{
using result = const T;
};

50
Remove Сonstancy
Result RemoveConst(T);
struct RemoveConst
{
using result = T;
};
struct RemoveConst <const T>
{
using result = T;
};

51
Add Method
Result AddMethodFoo(T);
struct AddMethodFoo
{
using result = struct : T
{
void foo() {}
};
};

52
Remove Method
Result RemoveMethodFoo(T);
struct RemoveMethodFoo
{
using result = struct : T
{
void f() = delete;
};
};

54
If Statement
if (<bool expression>)
{
}
struct IF
{
};
template <>
struct IF <True>
{
using allow = void;
};

55
If Statement Usage
You can put IF statement to the next places:
● Return type
typename IF <True>::allow function (T) { }
● Function argument
void function (T, typename IF <True>::allow* = 0) { }
● Default template argument
template < typename T, typename = typename IF <True>::allow >
void function (T) { }
template < typename T, typename = typename IF <True>::allow >
class Class { };

56
Example
if( IsConst(T) || IsReference( RemoveConst(T) ) ) && ( ! IsConst( AddConst(T) ) )
{
function(t);
}
template < typename T, typename = typename IF < typename AND < typename OR < typename
IsConst <T>::result, typename IsReference < typename RemoveConst <T>::result
>::result >::result, typename NOT < typename IsConst < typename AddConst <T>::result
>::result >::result >::result >::allow >
void function (T)
{
}
Metaprogramming

57
Example
template < typename T, typename = typename IF < typename AND < typename OR < typename
IsConst <T>::result, typename IsReference < typename RemoveConst <T>::result >::result
>::result, typename NOT < typename IsConst < typename AddConst <T>::result >::result
>::result >::result >::allow >
void function (T)
{
}
{
function(t);
}
Metaprogramming

58
Previous syntax Refined syntax
struct True {};
struct False{};
template <bool b>
struct Bool { static constexpr bool value = b; };
struct True : Bool <true> { };
struct False : Bool <false> { };
struct IsConst { using result = False; };
struct IsConst <const T> { using result = True; };
struct IsConstImpl : False { };
struct IsConstImpl <const T> : True { };
constexpr bool IsConst = IsConstImpl <T>::value;
struct AddConst { using result = const T; };
using AddConst = const T;
struct IF { };
template <>
struct IF <True> { using allow = void; };
template<bool b>
struct IFImpl;
template <>
struct IFImpl <true> { using allow = void; };
template <bool b>
using IF = typename IFImpl <b>::allow;
Syntax Sugar

59
Example
{
function(t);
}
template < typename T, typename =
IF < IsConst <T> || IsReference < RemoveConst <T> > && ! IsConst < AddConst <T> > > >
void function (T)
{
}
Metaprogramming

60
Meta-Map
struct key_1 { };
struct key_2 { };
template <typename KEY> class MapTypes { };
template <> struct MapTypes <key_1>
{ using Value = int; };
template <> struct MapTypes <key_2>
{ using Value = float; };
template <typename T> struct MapTypes <const T>
{ using Value = const int; };
template <typename ARRAY, size_t size>
struct MapTypes <ARRAY[size]>
{ using Value = void*; };
Example:
typename MapTypes <???> ::Value x;
template <int KEY> class MapVars { };
template <> struct MapVars <0>
{ static constexpr auto value = 42; };
{ static constexpr auto value = 3.14; };
{ static constexpr auto value = “Hello”; };
{ static constexpr auto value = nullptr; };
Example:
auto x = MapVars <???> ::value;

61
Switch Statement. Cases.
template <bool Value, int Index, int Size = 0>
struct CASE : Bool <Value>
{
static constexpr int index = Index;
static constexpr int size = Size;
};
template <int Size>
using CASE_DEFAULT = CASE <false, 0, Size>;
template <typename T, int index>
struct MyCases : CASE_DEFAULT <4> {};
struct MyCases <T, 1> : CASE <IsConst <T>, 1> {};
struct MyCases <T, 2> : CASE <IsReference <T>, 2> {};
struct MyCases <T, 3> : CASE <HasMethodFoo <T>, 3> {};

62
Switch Statement
template <template <typename, int> typename Cases, typename T, int size = Cases <T, 0>::size>
struct SWITCHImpl
{
static constexpr int index = size > 0 ?
( Cases <T, size>::value ? Cases <T, size>::index : SWITCHImpl <Cases, T, size - 1>::index ) : 0;
};
template <template<typename, int> typename Cases, typename T>
struct SWITCHImpl <Cases, T, 0>
{
static constexpr int index = 0;
};
template <template<typename, int> typename Cases, typename T>
constexpr int SWITCH = SWITCHImpl <Cases, T>::index;
Start
Go through all of
the cases using argument T
Find first true
condition
return index of the
condition
End

63
Switch Statement Usage
if (IsConst <T>)
{
Class <T, 1> c;
}
else if (IsReference <T>)
{
Class <T, 2> c;
}
else if (HasMethodFoo <T>)
{
Class <T, 3> c;
}
template <typename T, int X>
struct Class { static_assert(false); /*error*/ };
struct Class <T, 1> { /* implementation #1 */ };
Example
Class <T, SWITCH <MyCases, T>> c;

64
Switch Statement Usage. C++17.
/*
...
a lot preceding stuff...
...
*/
void function (T)
{
Class <T, SWITCH <MyCases, T>> c;
}
C++14 C++17
void function (T)
{
if constexpr (IsConst <T>)
{
Class <T, 1> c;
}
else if constexpr (IsReference <T>)
{
Class <T, 2> c;
}
else if constexpr (HasMethodFoo <T>)
{
Class <T, 3> c;
}
else
{
static_assert(false); // error
}
}

65
Switch Statement For Functions
if (IsConst <T>)
{
function1 ();
}
else if (IsReference <T>)
{
function2 ();
}
else if (HasMethodFoo <T>)
{
function3 ();
}
template <int index> struct Tag { };
void function (Tag <0>)
{ static_assert(template_false <T>); }
void function (Tag <1>) { /* implementation #1 */ }
Example
function <T> ( Tag <SWITCH <MyCases, T>> () );

66
Static Assert at Compile-time
Compiler generates an error every time while meeting a false condition.
Use variable template to make compiler generate an error only when it
instantiates the template. It allows to avoid an instant error.
Wrong
struct Class
{
static_assert(false);
};
Correct
constexpr bool template_false = false;
struct Class
{
static_assert(template_false <T>);
};

68
Dummy Type
// created from GUID {A031ECDEA-A7E5-4D9F-B7F8-77756FC30480}
struct A031ECDEA7E54D9FB7F877756FC30480{ };
using Dummy = A031ECDEA7E54D9FB7F877756FC30480;
struct FunctionReturnTypeImpl
{
using result = Dummy;
};
template <typename Return, typename... Args>
struct FunctionReturnTypeImpl <Return(*)(Args...)>
{
using result = Return;
};
using FunctionReturnType = typename FunctionReturnTypeImpl <T>::result;

69
Tag Dispatching in STL Iterators
random access
iterator
bidirectional
iterator
forward iterator
input iterator ++ (single-pass only) !=
++
--
+= -= + - > < >= <=

70
Tag Dispatching in STL Iterators
iterator_base
vector_iterator list_iterator forward_list_iterator deque_iterator string_iterator
input_iterator_tag
forward_iterator_tag
bidirectional_iterator_tag
random_access_iterator_tag

71
Iterator Tags
struct input_iterator_tag { };
struct forward_iterator_tag : input_iterator_tag { };
struct bidirectional_iterator_tag : forward_iterator_tag { };
struct random_access_iterator_tag : bidirectional_iterator_tag { };
template <class _Iter>
constexpr bool _Is_input_iter_v = is_convertible_v <_Iter_cat_t <_Iter>, input_iterator_tag>;
constexpr bool _Is_fwd_iter_v = is_convertible_v <_Iter_cat_t <_Iter>, forward_iterator_tag>;
constexpr bool _Is_bidi_iter_v = is_convertible_v <_Iter_cat_t <_Iter>, bidirectional_iterator_tag>;
constexpr bool _Is_random_iter_v = is_convertible_v <_Iter_cat_t <_Iter>,
random_access_iterator_tag>;

72
std::advance
template <class Iterator, class Diff>
void advance (Iterator & iter, Diff offset)
{
static_assert (_Is_input_iter_v <Iterator>, "next requires input iterator");
if constexpr (_Is_random_iter_v <Iterator>)
{
iter += offset;
}
else
{
if constexpr (is_signed_v <Diff>)
{
if constexpr (_Is_bidi_iter_v <Iterator>)
{
for (; offset < 0; ++offset, --iter)
}
else
{
static_assert (offset >= 0, "negative advance of non-bidirectional iterator");
}
}
for (; 0 < offset; --offset, ++iter);
}
}

73
Use SFINAE when
● Diagnose and warn about wrong code usage
● Create self-sufficient common components
● Create ecosystem of objects, common algorithms, libraries
● It is hidden from code users
● It helps to use the code easier
● There is someone who can review and maintain your code

74
Acknowledgement
● youtube.com (CppCon 2017: Arthur O'Dwyer “A Soupçon of SFINAE”)
● youtube.com (Compile-time type introspection using SFINAE)
● youtube.com (C++Now 2018: Agustín Bergé “SFINAE: Substitution Failure Is Not An Error”)
● youtube.com (Compile-time type introspection using SFINAE)
● cppreference.com (Templates)
● habr.com (Упрощение кода с помощью if constexpr в C++17)
● habr.com (Жизнь во время компиляции)
● wikipedia.org (SFINAE)
● isocpp.org (Templates)
● Visual Studio STL sources

September 2019
Thank you
Denys Petrov
Senior Software Engineer

C++ Templates. SFINAE

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à C++ Templates. SFINAE

Similaire à C++ Templates. SFINAE (20)

Plus de GlobalLogic Ukraine

Plus de GlobalLogic Ukraine (20)

Dernier

Dernier (20)

C++ Templates. SFINAE