| Home | Libraries | People | FAQ | More

## Alphabetical Reference

### 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, 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>:: arg`N`_type` | The `N`th 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: `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 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: `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 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: `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`.

| Tip

Don't confuse function-types with pointers to functions:
`typedef int f(double);`
defines a function type,
`f foo;`
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<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.

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

`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: `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