std::enable_if
From Cppreference
| Defined in header <type_traits>
|
||
| template< bool B, class T = void >
struct enable_if; |
(C++11 feature) | |
If B is true, std::enable_if has a public member typedef type, equal to T; otherwise, there is no member typedef. This metafunction is used to conditionally remove functions and classes from overload resolution based on type traits and to provide separate function overloads and specializations for different type traits. std:enable_if can be used as an additional function argument (the only option for constructors and destructors), as a return type (the only option for operators), or as a class template parameter.
Contents |
[edit] Member types
| Type | Definition |
| type | either T or no such member, depending on the value of B |
[edit] Equivalent definition
template<bool B, class T = void> struct enable_if {}; template<class T> struct enable_if<true, T> { typedef T type; }; |
[edit] Example
#include <type_traits> #include <iostream> // foo1 overloads are enabled via the return type template<class T> typename std::enable_if<std::is_floating_point<T>::value, T>::type foo1(T t) { std::cout << "foo1: float\n"; return t; } template<class T> typename std::enable_if<std::is_integral<T>::value, T>::type foo1(T t) { std::cout << "foo1: int\n"; return t; } // foo2 overload is enabled via a parameter template<class T> T foo2(T t, typename std::enable_if<std::is_integral<T>::value >::type* = 0) { return t; } // A is enabled via a template parameter template<class T, class Enable = void> class A; // undefined template<class T> class A<T, typename std::enable_if<std::is_floating_point<T>::value >::type> { }; int main() { foo1(1.2); // OK, calls the first version of foo1() foo1(10); // OK, calls the second version of foo1() // foo2(0.1); // compile-time error foo2(7); // OK // A<int> a1; // compile-time error A<double> a1; // OK }
Output:
foo1: float foo1: int