Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is an old version of boost. Click here for the latest version's documentation home page.
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 Tconst 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 intconst
add_const<int&>::type int&
add_const<int*>::type int*const
add_const<intconst>::type intconst

add_cv

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

type: The same type as Tconstvolatile 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 intconstvolatile
add_cv<int&>::type int&
add_cv<int*>::type int*constvolatile
add_cv<intconst>::type intconstvolatile

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<intconst&>::type intconst*
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<intconst&>::type intconst&
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 Tvolatile 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 intvolatile
add_volatile<int&>::type int&
add_volatile<int*>::type int*volatile
add_volatile<intconst>::type intconstvolatile

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,1>.

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)>::arg1_type The type int.
function_traits<long(int,long,double,void*)>::arg4_type The type void*.
function_traits<long(int,long,double,void*)>::arg5_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: classabc{virtual~abc()=0;};

is_abstract<abc> inherits from true_type.

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

is_abstract<abcconst>::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 or if both types are the same then inherits from true_type, otherwise inherits from false_type.

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

Note that is_base_of<X,X> will always inherit from true_type. This is the case even if X is not a class type. This is a change in behaviour from Boost-1.33 in order to track the Technical Report on C++ Library Extensions.

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: classBase{};classDerived:publicBase{};

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 true: a class is regarded as 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: classMyClass; then:

is_class<MyClass> inherits from true_type.

is_class<MyClassconst>::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<intconst> inherits from true_type.

is_const<intconstvolatile>::type is the type true_type.

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

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

is_const<intconst&>::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<constint,double>::type is the type true_type.

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

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

is_convertible<intconst&,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: structempty_class{};

is_empty<empty_class> inherits from true_type.

is_empty<empty_classconst>::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: enummy_enum{one,two};

is_enum<my_enum> inherits from true_type.

is_enum<my_enumconst>::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<longdouble>::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.

[Tip] Tip

Don't confuse function-types with pointers to functions:

typedefintf(double);

defines a function type,

ffoo;

declares a prototype for a function of type f,

f*pf=foo;
f&fr=foo;

declares a pointer and a reference to the function foo.

If you want to detect whether some type is a pointer-to-function then use:

is_function<remove_pointer<T>::type>::value&&is_pointer<T>::value

or for pointers to member functions you can just use is_member_function_pointer directly.

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<doubleconst>::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<constchar>::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<constint(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<constvoid>::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.

POD stands for "Plain old data". Arithmetic types, and enumeration types, a pointers and pointer to members are all PODs. Classes and unions can also be POD's if they have no non-static data members that are of reference or non-POD type, no user defined constructors, no user defined assignment operators, no private or protected non-static data members, no virtual functions and no base classes. Finally, a cv-qualified POD is still a POD, as is an array of PODs.

C++ Standard Reference: 3.9p10 and 9p4 (Note that POD's are also aggregates, see 8.5.1).

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.

[Important] Important

is_pointer detects "real" pointer types only, and not smart pointers. Users should not specialise is_pointer for smart pointer types, as doing so may cause Boost (and other third party) code to fail to function correctly. Users wanting a trait to detect smart pointers should create their own. However, note that there is no way in general to auto-magically detect smart pointer types, so such a trait would have to be partially specialised for each supported smart pointer type.

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: classpoly{virtual~poly();};

is_polymorphic<poly> inherits from true_type.

is_polymorphic<polyconst>::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<intconst,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<intconst&>::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<constvoid>::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<constvoid>::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<volatileint> inherits from true_type.

is_volatile<constvolatileint>::type is the type true_type.

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

is_volatile<intvolatile*>::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<intconst[2]>::type intconst
remove_all_extents<int[][2]>::type int
remove_all_extents<int[2][3][4]>::type int
remove_all_extents<intconst*>::type intconst*

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<intconst>::type int
remove_const<intconstvolatile>::type intvolatile
remove_const<intconst&>::type intconst&
remove_const<intconst*>::type intconst*

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<intconst>::type int
remove_cv<intconstvolatile>::type int
remove_cv<intconst&>::type intconst&
remove_cv<intconst*>::type intconst*

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<intconst[2]>::type intconst
remove_extent<int[2][4]>::type int[4]
remove_extent<int[][2]>::type int[2]
remove_extent<intconst*>::type intconst*

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<intconst*>::type intconst
remove_pointer<intconst**>::type intconst*
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<intconst&>::type intconst
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<intvolatile>::type int
remove_volatile<intconstvolatile>::type intconst
remove_volatile<intvolatile&>::type intconst&
remove_volatile<intvolatile*>::type intconst*

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