![]() |
Home | Libraries | People | FAQ | More |
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>