Ищет metafunction из BOOL в bool_type

Question

В принципе, я ищу библиотеку решения, которое делает это:

#include <boost/type_traits.hpp> 

template<bool> 
struct bool_to_bool_type; 

template<> 
struct bool_to_bool_type<false> 
{ 
    typedef boost::false_type type; 
}; 

template<> 
struct bool_to_bool_type<true> 
{ 
    typedef boost::true_type type; 
}; 

Есть ли такая metafunction?

Answer 1

Ой, подождите, true_type просто ЬурейеЕ для std::integral_constant<bool, true>? Тогда есть очевидное решение:

boost::integral_constant<bool, input_value> 

Answer 2

подталкивания already providesboost::mpl::bool_<>:

Boost.TypeTraits использует integral_constant:

BOOST_STATIC_ASSERT(( 
    is_same< integral_constant<bool, false>, 
      is_class<int>::type >::value)); 

Answer 3

Хотя integral_constant ответ, вы можете сделать тип или два только, чтобы сделать вещи немного яснее. Я использую это в своей библиотеке:

// utility/bool_type.hpp 
#include <boost/type_traits/integral_constant.hpp> 

namespace utility 
{ 
    template <bool B> 
    struct bool_type : boost::integral_constant<bool, B> 
    { 
     static const bool value = B; 
    }; 

    typedef const boost::true_type& true_tag; 
    typedef const boost::false_type& false_tag; 
} 

// main.cpp 
// just some predicate for example 
template <typename T> 
struct is_pointer 
{ 
    static const bool value = false; 
}; 

template <typename T> 
struct is_pointer<T*> 
{ 
    static const bool value = true; 
}; 

// some specialized function. 
// the true/false tag parameter is a 
// little easier to read, i think 
template <typename T> 
void foo(T, utility::true_tag) 
{ 
} 

/* versus: 
template <typename T> 
void foo(T, const boost::true_type&) 
*/ 

template <typename T> 
void foo(T, utility::false_tag) 
{ 
} 

// the actual function 
template <typename T> 
void foo(T pX) 
{ 
    // a bit shorter 
    foo(pX, utility::bool_type<is_pointer<T>::value>()); 

    /* versus: 
    foo(pX, boost::integral_type<bool, is_pointer<T>::value>()); 
    */ 
} 

int main(void) 
{ 
    int i = 0; 
    foo(i); 
    foo(&i); 
} 

Но это только мое мнение. :]

Answer 4

GMan есть гораздо лучший способ сделать то, что вы делаете, просто сделать предикат метафункции выводят от истинного/false_type (те являются псевдонимами типа для integral_constant), например:

#include <type_traits> 

template <typename T> 
struct is_pointer : std::false_type {}; 

template <typename T> 
struct is_pointer<T*> : std::true_type {}; 

//.... 
foo(px, is_pointer<T>()); 

Примечание. Я использую библиотеку C++ 0x.

Вся эта идея мета-функций bool -> bool_type избыточна, когда у вас есть обертки метаданных, такие как integ_type, просто посмотрите на ее определение, чтобы понять, о чем я говорю, и она была разработана для работы как мой пример.