std::enable_if

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Technical Specifications

 

Utilities library

Type support (basic types, RTTI, type traits)

Dynamic memory management

Error handling

Program utilities

Variadic functions

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=

Pairs and tuples

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

integer_sequence (C++14)

Swap, forward and move

swap

exchange (C++14)

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

Type operations

declval (C++11)

as_const (C++17)

 

Type support

Basic types
Fundamental types
Fixed width integer types (C++11)
ptrdiff_t size_t max_align_t (C++11)	nullptr_t (C++11) offsetof NULL
Numeric limits
numeric_limits
C numeric limits interface
Runtime type information
type_info type_index (C++11)	bad_typeid bad_cast
Type traits
Type categories
is_void (C++11) is_null_pointer (C++14) is_array (C++11) is_pointer (C++11) is_enum (C++11) is_union (C++11) is_class (C++11) is_function (C++11)	is_object (C++11) is_scalar (C++11) is_compound (C++11) is_integral (C++11) is_floating_point (C++11) is_fundamental (C++11) is_arithmetic (C++11)
is_reference (C++11)
is_lvalue_reference (C++11)
is_rvalue_reference (C++11)
is_member_pointer (C++11)
is_member_object_pointer (C++11)
is_member_function_pointer (C++11)

Type properties
is_const (C++11) is_volatile (C++11) is_pod (C++11) is_empty (C++11) is_polymorphic (C++11) is_final (C++14) is_abstract (C++11)	is_trivial (C++11) is_trivially_copyable (C++11) is_standard_layout (C++11) is_literal_type (C++11) is_signed (C++11) is_unsigned (C++11)
Type trait constants
integral_constantbool_constanttrue_typefalse_type (C++11)(C++17)(C++11)(C++11)
Metafunctions
conjunction (C++17)
disjunction (C++17)
negation (C++17)

Supported operations
is_constructibleis_trivially_constructibleis_nothrow_constructible (C++11)(C++11)(C++11)
is_default_constructibleis_trivially_default_constructibleis_nothrow_default_constructible (C++11)(C++11)(C++11)
is_copy_constructibleis_trivially_copy_constructibleis_nothrow_copy_constructible (C++11)(C++11)(C++11)
is_move_constructibleis_trivially_move_constructibleis_nothrow_move_constructible (C++11)(C++11)(C++11)
is_assignableis_trivially_assignableis_nothrow_assignable (C++11)(C++11)(C++11)
is_copy_assignableis_trivially_copy_assignableis_nothrow_copy_assignable (C++11)(C++11)(C++11)
is_move_assignableis_trivially_move_assignableis_nothrow_move_assignable (C++11)(C++11)(C++11)
is_destructibleis_trivially_destructibleis_nothrow_destructible (C++11)(C++11)(C++11)
has_virtual_destructor (C++11)
Relationships and property queries
is_same (C++11) is_base_of (C++11) is_convertible (C++11)	alignment_of (C++11) rank (C++11) extent (C++11)
Type modifications
remove_cvremove_constremove_volatile (C++11)(C++11)(C++11) add_cvadd_constadd_volatile (C++11)(C++11)(C++11) make_signed (C++11) make_unsigned (C++11)	remove_reference (C++11) add_lvalue_referenceadd_rvalue_reference (C++11)(C++11) remove_pointer (C++11) add_pointer (C++11) remove_extent (C++11) remove_all_extents (C++11)
Type transformations
aligned_storage (C++11) aligned_union (C++11) decay (C++11) enable_if (C++11) void_t (C++17)	conditional (C++11) common_type (C++11) underlying_type (C++11) result_of (C++11)

 

Defined in header <type_traits>
template< bool B, class T = void > struct enable_if;		(since C++11)

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 a convenient way to leverage SFINAE to conditionally remove functions 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 (not applicable to operator overloads), as a return type (not applicable to constructors and destructors), or as a class template or function template parameter.

Member types

Type	Definition
type	either T or no such member, depending on the value of B

Helper types

template< bool B, class T = void > using enable_if_t = typename enable_if<B,T>::type;		(since C++14)

Possible implementation

template<bool B, class T = void> struct enable_if {};   template<class T> struct enable_if<true, T> { typedef T type; };

Notes

A common mistake is to declare two function templates that differ only in their default template arguments. This is illegal because default template arguments are not part of function template's signature, and declaring two different function templates with the same signature is illegal.

struct T {
    enum { int_t,float_t } m_type;
    template <typename Integer,
              typename = std::enable_if_t<std::is_integral<Integer>::value>
    >
    T(Integer) : m_type(int_t) {}
 
    template <typename Floating,
              typename = std::enable_if_t<std::is_floating_point<Floating>::value>
    >
    T(Floating) : m_type(float_t) {} // error: cannot overload
};

Example

Run this code

#include <type_traits>
#include <iostream>
#include <string>
 
namespace detail { struct inplace_t{}; }
void* operator new(std::size_t, void* p, detail::inplace_t) {
    return p;
}
 
// #1, enabled via the return type
template<class T,class... Args>
typename std::enable_if<std::is_trivially_constructible<T,Args&&...>::value>::type 
    construct(T* t,Args&&... args) 
{
    std::cout << "constructing trivially constructible T\n";
}
 
// #2
template<class T, class... Args>
std::enable_if_t<!std::is_trivially_constructible<T,Args&&...>::value> //Using helper type
    construct(T* t,Args&&... args) 
{
    std::cout << "constructing non-trivially constructible T\n";
    new(t, detail::inplace_t{}) T(args...);
}
 
// #3, enabled via a parameter
template<class T>
void destroy(T* t, 
             typename std::enable_if<std::is_trivially_destructible<T>::value>::type* = 0) 
{
    std::cout << "destroying trivially destructible T\n";
}
 
// #4, enabled via a template parameter
template<class T,
         typename std::enable_if<
             !std::is_trivially_destructible<T>{} &&
             (std::is_class<T>{} || std::is_union<T>{})
            >::type* = nullptr>
void destroy(T* t)
{
    std::cout << "destroying non-trivially destructible T\n";
    t->~T();
}
 
// #5, enabled via a template parameter
template<class T,
	typename = std::enable_if_t<std::is_array<T>::value> >
void destroy(T* t) // note, function signature is unmodified
{
    for(std::size_t i = 0; i < std::extent<T>::value; ++i) {
        destroy((*t)[i]);
    }
}
/*
template<class T,
	typename = std::enable_if_t<std::is_void<T>::value> >
void destroy(T* t){} // error: has the same signature with #5
*/
 
// the partial specialization of A is enabled via a template parameter
template<class T, class Enable = void>
class A {}; // primary template
 
template<class T>
class A<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
}; // specialization for floating point types
 
int main()
{
    std::aligned_union_t<0,int,std::string> u;
 
    construct(reinterpret_cast<int*>(&u));
    destroy(reinterpret_cast<int*>(&u));
 
    construct(reinterpret_cast<std::string*>(&u),"Hello");
    destroy(reinterpret_cast<std::string*>(&u));
 
    A<int> a1; // OK, matches the primary template
    A<double> a2; // OK, matches the partial specialization
}

Output:

constructing trivially constructible T
destroying trivially destructible T
constructing non-trivially constructible T
destroying non-trivially destructible T

See also

void_t (C++17)

void variadic alias template (alias template)

• static_assert
• SFINAE