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

PrevUpHomeNext

Alphabetical Reference

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

add_const

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

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

C++ Standard Reference: 3.9.3.

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

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

Examples

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

add_cv

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

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

C++ Standard Reference: 3.9.3.

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

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

Examples

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

add_pointer

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

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

The rationale for this template is that it produces the same type as TYPEOF(&t title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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 title=" Examples"> 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>