boost.png (6897 bytes) Home Libraries People FAQ More

PrevUpHomeNext

Alphabetical Reference

add_const
add_cv
add_pointer
add_reference
add_volatile
aligned_storage
alignment_of
extent
function_traits
has_nothrow_assign
has_nothrow_constructor
has_nothrow_copy
has_trivial_assign
has_trivial_constructor
has_trivial_copy
has_trivial_destructor
has_virtual_destructor
integral_constant
is_abstract
is_arithmetic
is_array
is_base_of
is_class
is_compound
is_const
is_convertible
is_empty
is_enum
is_floating_point
is_function
is_fundamental
is_integral
is_member_function_pointer
is_member_object_pointer
is_member_pointer
is_object
is_pod
is_pointer
is_polymorphic
is_same
is_scalar
is_stateless
is_reference
is_union
is_void
is_volatile
rank
remove_all_extents
remove_const
remove_cv
remove_extent
remove_pointer
remove_reference
remove_volatile
type_with_alignment

add_const

template <class T>
struct add_const
{
   typedef see-below type;
};

type: The same type as T const for all T.

C++ Standard Reference: 3.9.3.

Compiler Compatibility: If the compiler does not support partial specialization of class-templates then this template will compile, but the member type will always be the same as type T except where compiler workarounds have been applied.

Header: #include <boost/type_traits/add_const.hpp> or #include <boost/type_traits.hpp>

Examples

Expression Result Type
add_const<int>::type int const
add_const<int&>::type int&
add_const<int*>::type int* const
add_const<int const>::type int const

add_cv

template <class T>
struct add_cv
{
   typedef see-below type;
};

type: The same type as T const volatile for all T.

C++ Standard Reference: 3.9.3.

Compiler Compatibility: If the compiler does not support partial specialization of class-templates then this template will compile, but the member type will always be the same as type T except where compiler workarounds have been applied.

Header: #include <boost/type_traits/add_cv.hpp> or #include <boost/type_traits.hpp>

Examples

Expression Result Type
add_cv<int>::type int const volatile
add_cv<int&>::type int&
add_cv<int*>::type int* const volatile
add_cv<int const>::type int const volatile

add_pointer

template <class T>
struct add_pointer
{
   typedef see-below type;
};

type: The same type as remove_reference<T>::type*.

The rationale for this template is that it produces the same type as TYPEOF(&t), where t is an object of type T.

C++ Standard Reference: 8.3.1.

Compiler Compatibility: If the compiler does not support partial specialization of class-templates then this template will compile, but the member type will always be the same as type T except where compiler workarounds have been applied.

Header: #include <boost/type_traits/add_pointer.hpp> or #include <boost/type_traits.hpp>

Examples

Expression Result Type
add_pointer<int>::type int*
add_pointer<int const&>::type int const*
add_pointer<int*>::type int**
add_pointer<int*&>::type int**

add_reference

template <class T>
struct add_reference
{
   typedef see-below type;
};

type: If T is not a reference type then T&, otherwise T.

C++ Standard Reference: 8.3.2.

Compiler Compatibility: If the compiler does not support partial specialization of class-templates then this template will compile, but the member type will always be the same as type T except where compiler workarounds have been applied.

Header: #include <boost/type_traits/add_reference.hpp> or #include <boost/type_traits.hpp>

Examples

Expression Result Type
add_reference<int>::type int&
add_reference<int const&>::type int const&
add_reference<int*>::type int*&
add_reference<int*&>::type int*&

add_volatile

template <class T>
struct add_volatile
{
   typedef see-below type;
};

type: The same type as T volatile for all T.

C++ Standard Reference: 3.9.3.

Compiler Compatibility: If the compiler does not support partial specialization of class-templates then this template will compile, but the member type will always be the same as type T except where compiler workarounds have been applied.

Header: #include <boost/type_traits/add_volatile.hpp> or #include <boost/type_traits.hpp>

Examples

Expression Result Type
add_volatile<int>::type int volatile
add_volatile<int&>::type int&
add_volatile<int*>::type int* volatile
add_volatile<int const>::type int const volatile

aligned_storage

template <std::size_t Size, std::size_t Align>
struct aligned_storage
{
   typedef see-below type;
};

type: a built-in or POD type with size Size and an alignment that is a multiple of Align.

Header: #include <boost/type_traits/aligned_storage.hpp> or #include <boost/type_traits.hpp>

alignment_of

template <class T>
struct alignment_of : public integral_constant<std::size_t, ALIGNOF(T)> {};

Inherits: Class template alignment_of inherits from integral_constant<std::size_t, ALIGNOF(T)>, where ALIGNOF(T) is the alignment of type T.

Note: strictly speaking you should only rely on the value of ALIGNOF(T) being a multiple of the true alignment of T, although in practice it does compute the correct value in all the cases we know about.

Header: #include <boost/type_traits/alignment_of.hpp> or #include <boost/type_traits.hpp>

Examples:

alignment_of<int> inherits from integral_constant<std::size_t, ALIGNOF(int)>.

alignment_of<char>::type is the type integral_constant<std::size_t, ALIGNOF(char)>.

alignment_of<double>::value is an integral constant expression with value ALIGNOF(double).

alignment_of<T>::value_type is the type std::size_t.

extent

template <class T, std::size_t N = 0>
struct extent : public integral_constant<std::size_t, EXTENT(T,N)> {};

Inherits: Class template extent inherits from integral_constant<std::size_t, EXTENT(T,N)>, where EXTENT(T,N) is the number of elements in the N'th array dimention of type T.

If T is not an array type, or if N > rank<T>::value, or if the N'th array bound is incomplete, then EXTENT(T,N) is zero.

Header: #include <boost/type_traits/extent.hpp> or #include <boost/type_traits.hpp>

Examples:

extent<int[1]> inherits from integral_constant<std::size_t, 0>.

extent<double[2][3][4], 1>::type is the type integral_constant<std::size_t, 3>.

extent<int[4]>::value is an integral constant expression that evaluates to 4.

extent<int[][2]>::value is an integral constant expression that evaluates to 0.

extent<int[][2], 1>::value is an integral constant expression that evaluates to 2.

extent<int*>::value is an integral constant expression that evaluates to 0.

extent<T>::value_type is the type std::size_t.

function_traits

template <class T>
struct function_traits
{
   static const std::size_t    arity = see-below;
   typedef see-below           result_type;
   typedef see-below           argN_type; 
};

The class template function_traits will only compile if:

  • The compiler supports partial specialization of class templates.
  • The template argument T is a function type, note that this is not the same thing as a pointer to a function.

Function Traits Members

Member Description
function_traits<T>::arity An integral constant expression that gives the number of arguments accepted by the function type F.
function_traits<T>::result_type The type returned by function type F.
function_traits<T>::argN_type The Nth argument type of function type F, where 1 <= N <= arity of F.

Examples

Expression Result
function_traits<void (void)>::arity An integral constant expression that has the value 0.
function_traits<long (int)>::arity An integral constant expression that has the value 1.
function_traits<long (int, long, double, void*)>::arity An integral constant expression that has the value 4.
function_traits<void (void)>::result_type The type void.
function_traits<long (int)>::result_type The type long.
function_traits<long (int)>::arg0_type The type int.
function_traits<long (int, long, double, void*)>::arg3_type The type void*.
function_traits<long (int, long, double, void*)>::arg4_type A compiler error: there is no arg4_type since there are only three arguments.
function_traits<long (*)(void)>::arity A compiler error: argument type is a function pointer, and not a function type.

has_nothrow_assign

template <class T>
struct has_nothrow_assign : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) type with a non-throwing assignment-operator then inherits from true_type, otherwise inherits from false_type. Type T must be a complete type.

Compiler Compatibility: If the compiler does not support partial-specialization of class templates, then this template can not be used with function types.

Without some (as yet unspecified) help from the compiler, has_nothrow_assign will never report that a class or struct has a non-throwing assignment-operator; this is always safe, if possibly sub-optimal. Currently (May 2005) only Visual C++ 8 has the necessary compiler support to ensure that this trait "just works".

Header: #include <boost/type_traits/has_nothrow_assign.hpp> or #include <boost/type_traits.hpp>

has_nothrow_constructor

template <class T>
struct has_nothrow_constructor : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) type with a non-throwing default-constructor then inherits from true_type, otherwise inherits from false_type. Type T must be a complete type.

Compiler Compatibility: If the compiler does not support partial-specialization of class templates, then this template can not be used with function types.

Without some (as yet unspecified) help from the compiler, has_nothrow_constructor will never report that a class or struct has a non-throwing default-constructor; this is always safe, if possibly sub-optimal. Currently (May 2005) only Visual C++ 8 has the necessary compiler intrinsics to ensure that this trait "just works".

Header: #include <boost/type_traits/has_nothrow_constructor.hpp> or #include <boost/type_traits.hpp>

has_nothrow_copy

template <class T>
struct has_nothrow_copy : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) type with a non-throwing copy-constructor then inherits from true_type, otherwise inherits from false_type. Type T must be a complete type.

Compiler Compatibility: If the compiler does not support partial-specialization of class templates, then this template can not be used with function types.

Without some (as yet unspecified) help from the compiler, has_nothrow_copy will never report that a class or struct has a non-throwing copy-constructor; this is always safe, if possibly sub-optimal. Currently (May 2005) only Visual C++ 8 has the necessary compiler intrinsics to ensure that this trait "just works".

Header: #include <boost/type_traits/has_nothrow_copy.hpp> or #include <boost/type_traits.hpp>

has_trivial_assign

template <class T>
struct has_trivial_assign : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) type with a trivial assignment-operator then inherits from true_type, otherwise inherits from false_type.

If a type has a trivial assignment-operator then the operator has the same effect as copying the bits of one object to the other: calls to the operator can be safely replaced with a call to memcpy.

Compiler Compatibility: If the compiler does not support partial-specialization of class templates, then this template can not be used with function types.

Without some (as yet unspecified) help from the compiler, has_trivial_assign will never report that a user-defined class or struct has a trivial constructor; this is always safe, if possibly sub-optimal. Currently (May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler intrinsics to detect user-defined classes with trivial constructors.

C++ Standard Reference: 12.8p11.

Header: #include <boost/type_traits/has_trivial_assign.hpp> or #include <boost/type_traits.hpp>

Examples:

has_trivial_assign<int> inherits from true_type.

has_trivial_assign<char*>::type is the type true_type.

has_trivial_assign<int (*)(long)>::value is an integral constant expression that evaluates to true.

has_trivial_assign<MyClass>::value is an integral constant expression that evaluates to false.

has_trivial_assign<T>::value_type is the type bool.

has_trivial_constructor

template <class T>
struct has_trivial_constructor : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) type with a trivial default-constructor then inherits from true_type, otherwise inherits from false_type.

If a type has a trivial default-constructor then the constructor have no effect: calls to the constructor can be safely omitted. Note that using meta-programming to omit a call to a single trivial-constructor call is of no benefit whatsoever. However, if loops and/or exception handling code can also be omitted, then some benefit in terms of code size and speed can be obtained.

Compiler Compatibility: If the compiler does not support partial-specialization of class templates, then this template can not be used with function types.

Without some (as yet unspecified) help from the compiler, has_trivial_constructor will never report that a user-defined class or struct has a trivial constructor; this is always safe, if possibly sub-optimal. Currently (May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler intrinsics to detect user-defined classes with trivial constructors.

C++ Standard Reference: 12.1p6.

Header: #include <boost/type_traits/has_trivial_constructor.hpp> or #include <boost/type_traits.hpp>

Examples:

has_trivial_constructor<int> inherits from true_type.

has_trivial_constructor<char*>::type is the type true_type.

has_trivial_constructor<int (*)(long)>::value is an integral constant expression that evaluates to true.

has_trivial_constructor<MyClass>::value is an integral constant expression that evaluates to false.

has_trivial_constructor<T>::value_type is the type bool.

has_trivial_copy

template <class T>
struct has_trivial_copy : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) type with a trivial copy-constructor then inherits from true_type, otherwise inherits from false_type.

If a type has a trivial copy-constructor then the constructor has the same effect as copying the bits of one object to the other: calls to the constructor can be safely replaced with a call to memcpy.

Compiler Compatibility: If the compiler does not support partial-specialization of class templates, then this template can not be used with function types.

Without some (as yet unspecified) help from the compiler, has_trivial_copy will never report that a user-defined class or struct has a trivial constructor; this is always safe, if possibly sub-optimal. Currently (May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler intrinsics to detect user-defined classes with trivial constructors.

C++ Standard Reference: 12.8p6.

Header: #include <boost/type_traits/has_trivial_copy.hpp> or #include <boost/type_traits.hpp>

Examples:

has_trivial_copy<int> inherits from true_type.

has_trivial_copy<char*>::type is the type true_type.

has_trivial_copy<int (*)(long)>::value is an integral constant expression that evaluates to true.

has_trivial_copy<MyClass>::value is an integral constant expression that evaluates to false.

has_trivial_copy<T>::value_type is the type bool.

has_trivial_destructor

template <class T>
struct has_trivial_destructor : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) type with a trivial destructor then inherits from true_type, otherwise inherits from false_type.

If a type has a trivial destructor then the destructor has no effect: calls to the destructor can be safely omitted. Note that using meta-programming to omit a call to a single trivial-constructor call is of no benefit whatsoever. However, if loops and/or exception handling code can also be omitted, then some benefit in terms of code size and speed can be obtained.

Compiler Compatibility: If the compiler does not support partial-specialization of class templates, then this template can not be used with function types.

Without some (as yet unspecified) help from the compiler, has_trivial_destructor will never report that a user-defined class or struct has a trivial destructor; this is always safe, if possibly sub-optimal. Currently (May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler intrinsics to detect user-defined classes with trivial constructors.

C++ Standard Reference: 12.4p3.

Header: #include <boost/type_traits/has_trivial_destructor.hpp> or #include <boost/type_traits.hpp>

Examples:

has_trivial_destructor<int> inherits from true_type.

has_trivial_destructor<char*>::type is the type true_type.

has_trivial_destructor<int (*)(long)>::value is an integral constant expression that evaluates to true.

has_trivial_destructor<MyClass>::value is an integral constant expression that evaluates to false.

has_trivial_destructor<T>::value_type is the type bool.

has_virtual_destructor

template <class T>
struct has_virtual_destructor : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) type with a virtual destructor then inherits from true_type, otherwise inherits from false_type.

Compiler Compatibility: This trait is provided for completeness, since it's part of the Technical Report on C++ Library Extensions. However, there is currently no way to portably implement this trait. The default version provided always inherits from false_type, and has to be explicitly specialized for types with virtual destructors unless the compiler used has compiler intrinsics that enable the trait to do the right thing: currently (May 2005) only Visual C++ 8 has the necessary intrinsics.

C++ Standard Reference: 12.4.

Header: #include <boost/type_traits/has_virtual_destructor.hpp> or #include <boost/type_traits.hpp>

integral_constant

template <class T, T val>
struct integral_constant
{
   typedef integral_constant<T, val>  type;
   typedef T                          value_type;
   static const T value = val;
};

typedef integral_constant<bool, true>  true_type;
typedef integral_constant<bool, false> false_type;

Class template integral_constant is the common base class for all the value-based type traits. The two typedef's true_type and false_type are provided for convenience: most of the value traits are Boolean properties and so will inherit from one of these.

is_abstract

template <class T>
struct is_abstract : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) abstract type then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 10.3.

Header: #include <boost/type_traits/is_abstract.hpp> or #include <boost/type_traits.hpp>

Compiler Compatibility: The compiler must support DR337 (as of April 2005: GCC 3.4, VC++ 7.1 (and later), Intel C++ 7 (and later), and Comeau 4.3.2). Otherwise behaves the same as is_polymorphic; this is the "safe fallback position" for which polymorphic types are always regarded as potentially abstract. The macro BOOST_NO_IS_ABSTRACT is used to signify that the implementation is buggy, users should check for this in their own code if the "safe fallback" is not suitable for their particular use-case.

Examples:

Given: class abc{ virtual ~abc() = 0; };

is_abstract<abc> inherits from true_type.

is_abstract<abc>::type is the type true_type.

is_abstract<abc const>::value is an integral constant expression that evaluates to true.

is_abstract<T>::value_type is the type bool.

is_arithmetic

template <class T>
struct is_arithmetic : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) arithmetic type then inherits from true_type, otherwise inherits from false_type. Arithmetic types include integral and floating point types (see also is_integral and is_floating_point).

C++ Standard Reference: 3.9.1p8.

Header: #include <boost/type_traits/is_arithmetic.hpp> or #include <boost/type_traits.hpp>

Examples:

is_arithmetic<int> inherits from true_type.

is_arithmetic<char>::type is the type true_type.

is_arithmetic<double>::value is an integral constant expression that evaluates to true.

is_arithmetic<T>::value_type is the type bool.

is_array

template <class T>
struct is_array : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) array type then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 3.9.2 and 8.3.4.

Header: #include <boost/type_traits/is_array.hpp> or #include <boost/type_traits.hpp>

Compiler Compatibility: If the compiler does not support partial-specialization of class templates, then this template can give the wrong result with function types.

Examples:

is_array<int[2]> inherits from true_type.

is_array<char[2][3]>::type is the type true_type.

is_array<double[]>::value is an integral constant expression that evaluates to true.

is_array<T>::value_type is the type bool.

is_base_of

template <class Base, class Derived>
struct is_base_of : public true_type-or-false_type {};

Inherits: If Base is base class of type Derived then inherits from true_type, otherwise inherits from false_type.

This template will detect non-public base classes, and ambiguous base classes.

Note that a class is not considered to be it's own base class, likewise, if either Base or Derived are non-class types, then the class will always inherit from false_type.

Types Base and Derived must not be incomplete types.

C++ Standard Reference: 10.

Header: #include <boost/type_traits/is_base_of.hpp> or #include <boost/type_traits.hpp>

Compiler Compatibility: If the compiler does not support partial-specialization of class templates, then this template can not be used with function types. There are some older compilers which will produce compiler errors if Base is a private base class of Derived, or if Base is an ambiguous base of Derived. These compilers include Borland C++, older versions of Sun Forte C++, Digital Mars C++, and older versions of EDG based compilers.

Examples:

Given: class Base{}; class Derived : public Base{};

is_base_of<Base, Derived> inherits from true_type.

is_base_of<Base, Derived>::type is the type true_type.

is_base_of<Base, Derived>::value is an integral constant expression that evaluates to true.

is_base_of<Base, Base>::value is an integral constant expression that evaluates to false: a class is not it's own base.

is_base_of<Derived, Base>::value is an integral constant expression that evaluates to false: the arguments are the wrong way round.

is_base_of<T>::value_type is the type bool.

is_class

template <class T>
struct is_class : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) class type then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 3.9.2 and 9.2.

Header: #include <boost/type_traits/is_class.hpp> or #include <boost/type_traits.hpp>

Compiler Compatibility: Without (some as yet unspecified) help from the compiler, we cannot distinguish between union and class types, as a result this type will erroneously inherit from true_type for union types. See also is_union. Currently (May 2005) only Visual C++ 8 has the necessary compiler intrinsics to correctly identify union types, and therefore make is_class function correctly.

Examples:

Given: class MyClass; then:

is_class<MyClass> inherits from true_type.

is_class<MyClass const>::type is the type true_type.

is_class<MyClass>::value is an integral constant expression that evaluates to true.

is_class<MyClass&>::value is an integral constant expression that evaluates to false.

is_class<MyClass*>::value is an integral constant expression that evaluates to false.

is_class<T>::value_type is the type bool.

is_compound

template <class T>
struct is_compound : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) compound type then inherits from true_type, otherwise inherits from false_type. Any type that is not a fundamental type is a compound type (see also is_fundamental).

C++ Standard Reference: 3.9.2.

Header: #include <boost/type_traits/is_compound.hpp> or #include <boost/type_traits.hpp>

Examples:

is_compound<MyClass> inherits from true_type.

is_compound<MyEnum>::type is the type true_type.

is_compound<int*>::value is an integral constant expression that evaluates to true.

is_compound<int&>::value is an integral constant expression that evaluates to true.

is_compound<int>::value is an integral constant expression that evaluates to false.

is_compound<T>::value_type is the type bool.

is_const

template <class T>
struct is_const : public true_type-or-false_type {};

Inherits: If T is a (top level) const-qualified type then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 3.9.3.

Header: #include <boost/type_traits/is_const.hpp> or #include <boost/type_traits.hpp>

Examples:

is_const<int const> inherits from true_type.

is_const<int const volatile>::type is the type true_type.

is_const<int* const>::value is an integral constant expression that evaluates to true.

is_const<int const*>::value is an integral constant expression that evaluates to false: the const-qualifier is not at the top level in this case.

is_const<int const&>::value is an integral constant expression that evaluates to false: the const-qualifier is not at the top level in this case.

is_const<int>::value is an integral constant expression that evaluates to false.

is_const<T>::value_type is the type bool.

is_convertible

template <class From, class To>
struct is_convertible : public true_type-or-false_type {};

Inherits: If an imaginary lvalue of type From is convertible to type To then inherits from true_type, otherwise inherits from false_type.

Type From must not be an incomplete type.

Type To must not be an incomplete, or function type.

No types are considered to be convertible to array types or abstract-class types.

This template can not detect whether a converting-constructor is public or not: if type To has a private converting constructor from type From then instantiating is_convertible<From, To> will produce a compiler error. For this reason is_convertible can not be used to determine whether a type has a public copy-constructor or not.

This template will also produce compiler errors if the conversion is ambiguous, for example:

struct A {};
struct B : A {};
struct C : A {};
struct D : B, C {};
// This produces a compiler error, the conversion is ambiguous:
bool const y = boost::is_convertible<D*,A*>::value;

C++ Standard Reference: 4 and 8.5.

Compiler Compatibility: This template is currently broken with Borland C++ Builder 5 (and earlier), for constructor-based conversions, and for the Metrowerks 7 (and earlier) compiler in all cases. If the compiler does not support is_abstract, then the template parameter To must not be an abstract type.

Header: #include <boost/type_traits/is_convertible.hpp> or #include <boost/type_traits.hpp>

Examples:

is_convertible<int, double> inherits from true_type.

is_convertible<const int, double>::type is the type true_type.

is_convertible<int* const, int*>::value is an integral constant expression that evaluates to true.

is_convertible<int const*, int*>::value is an integral constant expression that evaluates to false: the conversion would require a const_cast.

is_convertible<int const&, long>::value is an integral constant expression that evaluates to true.

is_convertible<int>::value is an integral constant expression that evaluates to false.

is_convertible<T>::value_type is the type bool.

is_empty

template <class T>
struct is_empty : public true_type-or-false_type {};

Inherits: If T is an empty class type then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 10p5.

Header: #include <boost/type_traits/is_empty.hpp> or #include <boost/type_traits.hpp>

Compiler Compatibility: In order to correctly detect empty classes this trait relies on either:

  • the compiler implementing zero sized empty base classes, or
  • the compiler providing intrinsics to detect empty classes.

Can not be used with incomplete types.

Can not be used with union types, until is_union can be made to work.

If the compiler does not support partial-specialization of class templates, then this template can not be used with abstract types.

Examples:

Given: struct empty_class {};

is_empty<empty_class> inherits from true_type.

is_empty<empty_class const>::type is the type true_type.

is_empty<empty_class>::value is an integral constant expression that evaluates to true.

is_empty<T>::value_type is the type bool.

is_enum

template <class T>
struct is_enum : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) enum type then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 3.9.2 and 7.2.

Header: #include <boost/type_traits/is_enum.hpp> or #include <boost/type_traits.hpp>

Compiler Compatibility: Requires a correctly functioning is_convertible template; this means that is_enum is currently broken under Borland C++ Builder 5, and for the Metrowerks compiler prior to version 8, other compilers should handle this template just fine.

Examples:

Given: enum my_enum { one, two };

is_enum<my_enum> inherits from true_type.

is_enum<my_enum const>::type is the type true_type.

is_enum<my_enum>::value is an integral constant expression that evaluates to true.

is_enum<my_enum&>::value is an integral constant expression that evaluates to false.

is_enum<my_enum*>::value is an integral constant expression that evaluates to false.

is_enum<T>::value_type is the type bool.

is_floating_point

template <class T>
struct is_floating_point : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) floating point type then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 3.9.1p8.

Header: #include <boost/type_traits/is_floating_point.hpp> or #include <boost/type_traits.hpp>

Examples:

is_floating_point<float> inherits from true_type.

is_floating_point<double>::type is the type true_type.

is_floating_point<long double>::value is an integral constant expression that evaluates to true.

is_floating_point<T>::value_type is the type bool.

is_function

template <class T>
struct is_function : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) function type then inherits from true_type, otherwise inherits from false_type. Note that this template does not detect /pointers to functions, or /references to functions, these are detected by is_pointer and is_reference respectively:

typedef int f1();      // f1 is of function type.
typedef int (f2*)();   // f2 is a pointer to a function.
typedef int (f3&)();   // f3 is a reference to a function.

C++ Standard Reference: 3.9.2p1 and 8.3.5.

Header: #include <boost/type_traits/is_function.hpp> or #include <boost/type_traits.hpp>

Examples:

is_function<int (void)> inherits from true_type.

is_function<long (double, int)>::type is the type true_type.

is_function<long (double, int)>::value is an integral constant expression that evaluates to true.

is_function<long (*)(double, int)>::value is an integral constant expression that evaluates to false: the argument in this case is a pointer type, not a function type.

is_function<long (&)(double, int)>::value is an integral constant expression that evaluates to false: the argument in this case is a reference to a function, not a function type.

is_function<long (MyClass::*)(double, int)>::value is an integral constant expression that evaluates to false: the argument in this case is a pointer to a member function.

is_function<T>::value_type is the type bool.

is_fundamental

template <class T>
struct is_fundamental : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) fundamental type then inherits from true_type, otherwise inherits from false_type. Fundamental types include integral, floating point and void types (see also is_integral, is_floating_point and is_void)

C++ Standard Reference: 3.9.1.

Header: #include <boost/type_traits/is_fundamental.hpp> or #include <boost/type_traits.hpp>

Examples:

is_fundamental<int)> inherits from true_type.

is_fundamental<double const>::type is the type true_type.

is_fundamental<void>::value is an integral constant expression that evaluates to true.

is_fundamental<T>::value_type is the type bool.

is_integral

template <class T>
struct is_integral : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) integral type then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 3.9.1p7.

Header: #include <boost/type_traits/is_integral.hpp> or #include <boost/type_traits.hpp>

Examples:

is_integral<int> inherits from true_type.

is_integral<const char>::type is the type true_type.

is_integral<long>::value is an integral constant expression that evaluates to true.

is_integral<T>::value_type is the type bool.

is_member_function_pointer

template <class T>
struct is_member_function_pointer : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) pointer to a member function then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 3.9.2 and 8.3.3.

Header: #include <boost/type_traits/is_member_function_pointer.hpp> or #include <boost/type_traits.hpp>

Examples:

is_member_function_pointer<int (MyClass::*)(void)> inherits from true_type.

is_member_function_pointer<int (MyClass::*)(char)>::type is the type true_type.

is_member_function_pointer<int (MyClass::*)(void)const>::value is an integral constant expression that evaluates to true.

is_member_function_pointer<int (MyClass::*)>::value is an integral constant expression that evaluates to false: the argument in this case is a pointer to a data member and not a member function, see is_member_object_pointer and is_member_pointer

is_member_function_pointer<T>::value_type is the type bool.

is_member_object_pointer

template <class T>
struct is_member_object_pointer : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) pointer to a member object (a data member) then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 3.9.2 and 8.3.3.

Header: #include <boost/type_traits/is_member_object_pointer.hpp> or #include <boost/type_traits.hpp>

Examples:

is_member_object_pointer<int (MyClass::*)> inherits from true_type.

is_member_object_pointer<double (MyClass::*)>::type is the type true_type.

is_member_object_pointer<const int (MyClass::*)>::value is an integral constant expression that evaluates to true.

is_member_object_pointer<int (MyClass::*)(void)>::value is an integral constant expression that evaluates to false: the argument in this case is a pointer to a member function and not a member object, see is_member_function_pointer and is_member_pointer

is_member_object_pointer<T>::value_type is the type bool.

is_member_pointer

template <class T>
struct is_member_pointer : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) pointer to a member (either a function or a data member) then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 3.9.2 and 8.3.3.

Header: #include <boost/type_traits/is_member_pointer.hpp> or #include <boost/type_traits.hpp>

Examples:

is_member_pointer<int (MyClass::*)> inherits from true_type.

is_member_pointer<int (MyClass::*)(char)>::type is the type true_type.

is_member_pointer<int (MyClass::*)(void)const>::value is an integral constant expression that evaluates to true.

is_member_pointer<T>::value_type is the type bool.

is_object

template <class T>
struct is_object : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) object type then inherits from true_type, otherwise inherits from false_type. All types are object types except references, void, and function types.

C++ Standard Reference: 3.9p9.

Header: #include <boost/type_traits/is_object.hpp> or #include <boost/type_traits.hpp>

Examples:

is_object<int> inherits from true_type.

is_object<int*>::type is the type true_type.

is_object<int (*)(void)>::value is an integral constant expression that evaluates to true.

is_object<int (MyClass::*)(void)const>::value is an integral constant expression that evaluates to true.

is_object<int &>::value is an integral constant expression that evaluates to false: reference types are not objects

is_object<int (double)>::value is an integral constant expression that evaluates to false: function types are not objects

is_object<const void>::value is an integral constant expression that evaluates to false: void is not an object type

is_object<T>::value_type is the type bool.

is_pod

template <class T>
struct is_pod : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) POD type then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 3.9p10 and 9p4.

Compiler Compatibility: If the compiler does not support partial-specialization of class templates, then this template can not be used with function types.

Without some (as yet unspecified) help from the compiler, is_pod will never report that a class or struct is a POD; this is always safe, if possibly sub-optimal. Currently (May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler-intrinsics.

Header: #include <boost/type_traits/is_pod.hpp> or #include <boost/type_traits.hpp>

Examples:

is_pod<int> inherits from true_type.

is_pod<char*>::type is the type true_type.

is_pod<int (*)(long)>::value is an integral constant expression that evaluates to true.

is_pod<MyClass>::value is an integral constant expression that evaluates to false.

is_pod<T>::value_type is the type bool.

is_pointer

template <class T>
struct is_pointer : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) pointer type (includes function pointers, but excludes pointers to members) then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 3.9.2p2 and 8.3.1.

Header: #include <boost/type_traits/is_pointer.hpp> or #include <boost/type_traits.hpp>

Examples:

is_pointer<int*> inherits from true_type.

is_pointer<char* const>::type is the type true_type.

is_pointer<int (*)(long)>::value is an integral constant expression that evaluates to true.

is_pointer<int (MyClass::*)(long)>::value is an integral constant expression that evaluates to false.

is_pointer<int (MyClass::*)>::value is an integral constant expression that evaluates to false.

is_pointer<T>::value_type is the type bool.

is_polymorphic

template <class T>
struct is_polymorphic : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) polymorphic type then inherits from true_type, otherwise inherits from false_type. Type T must be a complete type.

C++ Standard Reference: 10.3.

Compiler Compatibility: The implementation requires some knowledge of the compilers ABI, it does actually seem to work with the majority of compilers though.

Header: #include <boost/type_traits/is_polymorphic.hpp> or #include <boost/type_traits.hpp>

Examples:

Given: class poly{ virtual ~poly(); };

is_polymorphic<poly> inherits from true_type.

is_polymorphic<poly const>::type is the type true_type.

is_polymorphic<poly>::value is an integral constant expression that evaluates to true.

is_polymorphic<T>::value_type is the type bool.

is_same

template <class T, class U>
struct is_same : public true_type-or-false_type {};

Inherits: If T and U are the same types then inherits from true_type, otherwise inherits from false_type.

Header: #include <boost/type_traits/is_same.hpp> or #include <boost/type_traits.hpp>

Compiler Compatibility: If the compiler does not support partial-specialization of class templates, then this template can not be used with abstract, incomplete or function types.

Examples:

is_same<int, int> inherits from true_type.

is_same<int, int>::type is the type true_type.

is_same<int, int>::value is an integral constant expression that evaluates to true.

is_same<int const, int>::value is an integral constant expression that evaluates to false.

is_same<int&, int>::value is an integral constant expression that evaluates to false.

is_same<T>::value_type is the type bool.

is_scalar

template <class T>
struct is_scalar : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) scalar type then inherits from true_type, otherwise inherits from false_type. Scalar types include integral, floating point, enumeration, pointer, and pointer-to-member types.

C++ Standard Reference: 3.9p10.

Header: #include <boost/type_traits/is_scalar.hpp> or #include <boost/type_traits.hpp>

Compiler Compatibility: If the compiler does not support partial-specialization of class templates, then this template can not be used with function types.

Examples:

is_scalar<int*> inherits from true_type.

is_scalar<int>::type is the type true_type.

is_scalar<double>::value is an integral constant expression that evaluates to true.

is_scalar<int (*)(long)>::value is an integral constant expression that evaluates to true.

is_scalar<int (MyClass::*)(long)>::value is an integral constant expression that evaluates to true.

is_scalar<int (MyClass::*)>::value is an integral constant expression that evaluates to true.

is_scalar<T>::value_type is the type bool.

is_stateless

template <class T>
struct is_stateless : public true_type-or-false_type {};

Inherits: Ff T is a stateless type then inherits from true_type, otherwise from false_type.

Type T must be a complete type.

A stateless type is a type that has no storage and whose constructors and destructors are trivial. That means that is_stateless only inherits from true_type if the following expression is true:

::boost::has_trivial_constructor<T>::value
&& ::boost::has_trivial_copy<T>::value
&& ::boost::has_trivial_destructor<T>::value
&& ::boost::is_class<T>::value
&& ::boost::is_empty<T>::value

C++ Standard Reference: 3.9p10.

Header: #include <boost/type_traits/is_stateless.hpp> or #include <boost/type_traits.hpp>

Compiler Compatibility: If the compiler does not support partial-specialization of class templates, then this template can not be used with function types.

Without some (as yet unspecified) help from the compiler, is_stateless will never report that a class or struct is stateless; this is always safe, if possibly sub-optimal. Currently (May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler intrinsics to make this template work automatically.

is_reference

template <class T>
struct is_reference : public true_type-or-false_type {};

Inherits: If T is a reference pointer type then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 3.9.2 and 8.3.2.

Compiler Compatibility: If the compiler does not support partial-specialization of class templates, then this template may report the wrong result for function types, and for types that are both const and volatile qualified.

Header: #include <boost/type_traits/is_reference.hpp> or #include <boost/type_traits.hpp>

Examples:

is_reference<int&> inherits from true_type.

is_reference<int const&>::type is the type true_type.

is_reference<int (&)(long)>::value is an integral constant expression that evaluates to true (the argument in this case is a reference to a function).

is_reference<T>::value_type is the type bool.

is_union

template <class T>
struct is_union : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) union type then inherits from true_type, otherwise inherits from false_type. Currently requires some kind of compiler support, otherwise unions are identified as classes.

C++ Standard Reference: 3.9.2 and 9.5.

Compiler Compatibility: Without (some as yet unspecified) help from the compiler, we cannot distinguish between union and class types using only standard C++, as a result this type will never inherit from true_type, unless the user explicitly specializes the template for their user-defined union types, or unless the compiler supplies some unspecified intrinsic that implements this functionality. Currently (May 2005) only Visual C++ 8 has the necessary compiler intrinsics to make this trait "just work" without user intervention.

Header: #include <boost/type_traits/is_union.hpp> or #include <boost/type_traits.hpp>

Examples:

is_union<void> inherits from true_type.

is_union<const void>::type is the type true_type.

is_union<void>::value is an integral constant expression that evaluates to true.

is_union<void*>::value is an integral constant expression that evaluates to false.

is_union<T>::value_type is the type bool.

is_void

template <class T>
struct is_void : public true_type-or-false_type {};

Inherits: If T is a (possibly cv-qualified) void type then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 3.9.1p9.

Header: #include <boost/type_traits/is_void.hpp> or #include <boost/type_traits.hpp>

Examples:

is_void<void> inherits from true_type.

is_void<const void>::type is the type true_type.

is_void<void>::value is an integral constant expression that evaluates to true.

is_void<void*>::value is an integral constant expression that evaluates to false.

is_void<T>::value_type is the type bool.

is_volatile

template <class T>
struct is_volatile : public true_type-or-false_type {};

Inherits: If T is a (top level) volatile-qualified type then inherits from true_type, otherwise inherits from false_type.

C++ Standard Reference: 3.9.3.

Header: #include <boost/type_traits/is_volatile.hpp> or #include <boost/type_traits.hpp>

Examples:

is_volatile<volatile int> inherits from true_type.

is_volatile<const volatile int>::type is the type true_type.

is_volatile<int* volatile>::value is an integral constant expression that evaluates to true.

is_volatile<int volatile*>::value is an integral constant expression that evaluates to false: the volatile qualifier is not at the top level in this case.

is_volatile<T>::value_type is the type bool.

rank

template <class T>
struct rank : public integral_constant<std::size_t, RANK(T)> {};

Inherits: Class template rank inherits from integral_constant<std::size_t, RANK(T)>, where RANK(T) is the number of array dimensions in type T.

If T is not an array type, then RANK(T) is zero.

Header: #include <boost/type_traits/rank.hpp> or #include <boost/type_traits.hpp>

Examples:

rank<int[]> inherits from integral_constant<std::size_t, 1>.

rank<double[2][3][4]>::type is the type integral_constant<std::size_t, 3>.

rank<int[1]>::value is an integral constant expression that evaluates to 1.

rank<int[][2]>::value is an integral constant expression that evaluates to 2.

rank<int*>::value is an integral constant expression that evaluates to 0.

rank<T>::value_type is the type std::size_t.

remove_all_extents

template <class T>
struct remove_all_extents
{
   typedef see-below type;
};

type: If T is an array type, then removes all of the array bounds on T, otherwise leaves T unchanged.

C++ Standard Reference: 8.3.4.

Compiler Compatibility: If the compiler does not support partial specialization of class-templates then this template will compile, but the member type will always be the same as type T except where compiler workarounds have been applied.

Header: #include <boost/type_traits/remove_all_extents.hpp> or #include <boost/type_traits.hpp>

Examples

Expression Result Type
remove_all_extents<int>::type int
remove_all_extents<int const[2]>::type int const
remove_all_extents<int[][2]>::type int
remove_all_extents<int[2][3][4]>::type int
remove_all_extents<int const*>::type int const*

remove_const

template <class T>
struct remove_const
{
   typedef see-below type;
};

type: The same type as T, but with any top level const-qualifier removed.

C++ Standard Reference: 3.9.3.

Compiler Compatibility: If the compiler does not support partial specialization of class-templates then this template will compile, but the member type will always be the same as type T except where compiler workarounds have been applied.

Header: #include <boost/type_traits/remove_const.hpp> or #include <boost/type_traits.hpp>

Examples

Expression Result Type
remove_const<int>::type int
remove_const<int const>::type int
remove_const<int const volatile>::type int volatile
remove_const<int const&>::type int const&
remove_const<int const*>::type int const*

remove_cv

template <class T>
struct remove_cv
{
   typedef see-below type;
};

type: The same type as T, but with any top level cv-qualifiers removed.

C++ Standard Reference: 3.9.3.

Compiler Compatibility: If the compiler does not support partial specialization of class-templates then this template will compile, but the member type will always be the same as type T except where compiler workarounds have been applied.

Header: #include <boost/type_traits/remove_cv.hpp> or #include <boost/type_traits.hpp>

Examples

Expression Result Type
remove_cv<int>::type int
remove_cv<int const>::type int
remove_cv<int const volatile>::type int
remove_cv<int const&>::type int const&
remove_cv<int const*>::type int const*

remove_extent

template <class T>
struct remove_extent
{
   typedef see-below type;
};

type: If T is an array type, then removes the topmost array bound, otherwise leaves T unchanged.

C++ Standard Reference: 8.3.4.

Compiler Compatibility: If the compiler does not support partial specialization of class-templates then this template will compile, but the member type will always be the same as type T except where compiler workarounds have been applied.

Header: #include <boost/type_traits/remove_extent.hpp> or #include <boost/type_traits.hpp>

Examples

Expression Result Type
remove_extent<int>::type int
remove_extent<int const[2]>::type int const
remove_extent<int[2][4]>::type int[4]
remove_extent<int[][2]>::type int[2]
remove_extent<int const*>::type int const*

remove_pointer

template <class T>
struct remove_pointer
{
   typedef see-below type;
};

type: The same type as T, but with any pointer modifier removed.

C++ Standard Reference: 8.3.1.

Compiler Compatibility: If the compiler does not support partial specialization of class-templates then this template will compile, but the member type will always be the same as type T except where compiler workarounds have been applied.

Header: #include <boost/type_traits/remove_pointer.hpp> or #include <boost/type_traits.hpp>

Examples

Expression Result Type
remove_pointer<int>::type int
remove_pointer<int const*>::type int const
remove_pointer<int const**>::type int const*
remove_pointer<int&>::type int&
remove_pointer<int*&>::type int*&

remove_reference

template <class T>
struct remove_reference
{
   typedef see-below type;
};

type: The same type as T, but with any reference modifier removed.

C++ Standard Reference: 8.3.2.

Compiler Compatibility: If the compiler does not support partial specialization of class-templates then this template will compile, but the member type will always be the same as type T except where compiler workarounds have been applied.

Header: #include <boost/type_traits/remove_reference.hpp> or #include <boost/type_traits.hpp>

Examples

Expression Result Type
remove_reference<int>::type int
remove_reference<int const&>::type int const
remove_reference<int*>::type int*
remove_reference<int*&>::type int*

remove_volatile

template <class T>
struct remove_volatile
{
   typedef see-below type;
};

type: The same type as T, but with any top level volatile-qualifier removed.

C++ Standard Reference: 3.9.3.

Compiler Compatibility: If the compiler does not support partial specialization of class-templates then this template will compile, but the member type will always be the same as type T except where compiler workarounds have been applied.

Header: #include <boost/type_traits/remove_volatile.hpp> or #include <boost/type_traits.hpp>

Examples

Expression Result Type
remove_volatile<int>::type int
remove_volatile<int volatile>::type int
remove_volatile<int const volatile>::type int const
remove_volatile<int volatile&>::type int const&
remove_volatile<int volatile*>::type int const*

type_with_alignment

template <std::size_t Align>
struct type_with_alignment
{
   typedef see-below type;
};

type: a built-in or POD type with an alignment that is a multiple of Align.

Header: #include <boost/type_traits/type_with_alignment.hpp> or #include <boost/type_traits.hpp>

Copyright © 2000, 2005 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Thorsten Ottosen, Robert Ramey and Jeremy Siek

PrevUpHomeNext