Header <boost/type_traits.hpp>

struct A {};
struct B : A {};
struct C : A {};
struct D : B, C {};
bool const x = boost::is_base_and_derived<A,D>::value;  // エラー
bool const y = boost::is_convertible<D*,A*>::value;     // エラー

BOOST_STATIC_ASSERT((is_same<char, remove_reference<char&>::type>::value));

BOOST_STATIC_ASSERT((is_same<char const, remove_reference<char const&>::type>::value));

BOOST_STATIC_ASSERT((is_same<char volatile, remove_reference<char volatile&>::type>::value));

BOOST_STATIC_ASSERT((is_same<char const volatile, remove_reference<char const volatile&>::type>::value));

BOOST_STATIC_ASSERT((is_same<char*, remove_reference<char*&>::type>::value));

BOOST_STATIC_ASSERT((is_same<char const*, remove_reference<char const*&>::type>::value));

...

BOOST_STATIC_ASSERT((is_same<char const volatile* const volatile* const volatile, remove_reference<char const volatile* const volatile* const volatile&>::type>::value));

struct my {};

BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(my)

BOOST_STATIC_ASSERT((is_same<my, remove_reference<my&>::type>::value));

BOOST_STATIC_ASSERT((is_same<my, remove_const<my const>::type>::value));

// etc.

#include <boost/type_traits.hpp>

//
// opt::copy
// std::copy と同じセマンティクス
// 適宜 memcpy を呼び出す。
//

namespace detail{

template<typename I1, typename I2>
I2 copy_imp(I1 first, I1 last, I2 out)
{
    while(first != last)
    {
        *out = *first;
        ++out;
        ++first;
    }
    return out;
}

template <bool b>
struct copier
{
    template<typename I1, typename I2>
    static I2 do_copy(I1 first, I1 last, I2 out)
    { return copy_imp(first, last, out); }
};

template <>
struct copier<true>
{
    template<typename I1, typename I2>
    static I2* do_copy(I1* first, I1* last, I2* out)
    {
        memcpy(out, first, (last-first)*sizeof(I2));
        return out+(last-first);
    }
};

}

template<typename I1, typename I2>
inline I2 copy(I1 first, I1 last, I2 out)
{
    typedef typename boost::remove_cv<typename std::iterator_traits<I1>::value_type>::type v1_t;
    typedef typename boost::remove_cv<typename std::iterator_traits<I2>::value_type>::type v2_t;
    return detail::copier<
        ::boost::type_traits::ice_and<
            ::boost::is_same<v1_t, v2_t>::value,
            ::boost::is_pointer<I1>::value,
            ::boost::is_pointer<I2>::value,
            ::boost::has_trivial_assign<v1_t>::value
        >::value>::do_copy(first, last, out);
}

namespace opt{
//
// fill
// std::fill と同じ。引数の受け渡しの"最適化"のために
// call_traits とともに適宜 memset を使用する。
//
//
namespace detail{

template <typename I, typename T>
void do_fill_(I first, I last, typename boost::call_traits<T>::param_type val)
{
    while(first != last)
    {
        *first = val;
        ++first;
    }
}

template <bool opt>
struct filler
{
    template <typename I, typename T>
    struct rebind
    {
        static void do_fill(I first, I last, typename boost::call_traits<T>::param_type val)
        { do_fill_<I,T>(first, last, val); }
    };
};

template <>
struct filler<true>
{
    template <typename I, typename T>
    struct rebind
    {
        static void do_fill(I first, I last, T val)
        {
            std::memset(first, val, last-first);
        }
    };
};

}

template <class I, class T>
inline void fill(I first, I last, const T& val)
{
    typedef detail::filler<
        ::boost::type_traits::ice_and<
            ::boost::is_pointer<I>::value,
            ::boost::is_arithmetic<T>::value,
            (sizeof(T) == 1)
        >::value> filler_t;
    typedef typename filler_t:: template rebind<I,T> binder;
    binder::do_fill(first, last, val);
}

};   // namespace opt

namespace opt{
//
// iter_swap:
// イテレータが代替イテレータかどうかを調べ、
// それに応じて最適な形式を使う。
//
namespace detail{

template <bool b>
struct swapper
{
    template <typename I>
    static void do_swap(I one, I two)
    {
        typedef typename std::iterator_traits<I>::value_type v_t;
        v_t v = *one;
        *one = *two;
        *two = v;
    }
};

template <>
struct swapper<true>
{
    template <typename I>
    static void do_swap(I one, I two)
    {
        using std::swap;
        swap(*one, *two);
    }
};

}

template <typename I1, typename I2>
inline void iter_swap(I1 one, I2 two)
{
    typedef typename std::iterator_traits<I1>::reference r1_t;
    typedef typename std::iterator_traits<I2>::reference r2_t;
    detail::swapper<
        ::boost::type_traits::ice_and<
            ::boost::is_reference<r1_t>::value,
            ::boost::is_reference<r2_t>::value,
            ::boost::is_same<r1_t, r2_t>::value
        >::value>::do_swap(one, two);
}

};   // namespace opt

namespace opt{
//
// アルゴリズムdestroy_array:
// std::unitialized_copyの逆で、初期化済みのメモリブロックを受け取り、
// その中の全オブジェクトに対してデストラクタを呼び出す。
//

namespace detail{

template <bool>
struct array_destroyer
{
    template <class T>
    static void destroy_array(T* i, T* j){ do_destroy_array(i, j); }
};

template <>
struct array_destroyer<true>
{
    template <class T>
    static void destroy_array(T*, T*){}
};

template <class T>
void do_destroy_array(T* first, T* last)
{
    while(first != last)
    {
        first->~T();
        ++first;
    }
}

}; // namespace detail

template <class T>
inline void destroy_array(T* p1, T* p2)
{
    detail::array_destroyer<boost::has_trivial_destructor<T>::value>::destroy_array(p1, p2);
}
} // namespace opt