如何在 C++ 中编写“meta if else if..”？

Question

我只是在学习 C++ 元编程的基础知识，我想看看其他人如何解决以下问题会很好。此外，很高兴看到使用 Boost 元编程库的解决方案，因为我认为它们是我的黑暗角落。那么问题来了，能不能更优雅地重写一下呢？

假设我们有以下结构：

template <std::size_t size>
struct type_factory
{
  typedef typename type_factory_impl<size>::type type;
};

这个结构应该是typedeftype，取决于size的值。 type_factory_impl 是type_factory 的实现。用于判断type的算法是：

if(size % bits<unsigned long long>::value == 0)
  typedef unsigned long long type;
else if(size % bits<unsigned long>::value == 0)
  typedef unsigned long type;
else if(size % bits<unsigned int>::value == 0)
  typedef unsigned int type;
else if(size % bits<unsigned short int>::value == 0)
  typedef unsigned short int type;
else if(size % bits<unsigned char>::value == 0)
  typedef unsigned char type;
else
  static_assert(false, "The type should be multiple of 'unsigned char' size");

我已经通过两种方式解决了这个元程序。第一个直接使用模式匹配，第二个使用meta if-else。将以下代码视为两种解决方案之间的通用代码：

#include <cstddef>
#include <climits>

typedef unsigned char      uchar;
typedef unsigned short int usint;
typedef unsigned int       uint;
typedef unsigned long      ulong;
typedef unsigned long long ulonglong;

// Returns how many bits in Unsigned_Type
template <typename Unsigned_Type>
struct bits
{ enum { value = sizeof(Unsigned_Type)*CHAR_BIT }; };

// struct type_factory_impl ...

template <std::size_t size>
struct type_factory
{
  typedef typename type_factory_impl<size>::type type;
};

int main()
{
  auto a = type_factory<8>::type(0);  // unsigned char
  auto b = type_factory<16>::type(0); // unsigned short int
  auto c = type_factory<24>::type(0); // unsigned char
  auto d = type_factory<32>::type(0); // unsigned long
  auto e = type_factory<40>::type(0); // unsigned char
  auto f = type_factory<48>::type(0); // unsigned short int
  auto g = type_factory<56>::type(0); // unsigned char
  auto h = type_factory<64>::type(0); // unsigned long long
}

第一种解决方案：

template <bool is_uchar>
struct unsigned_char
{
  typedef unsigned char type;
  static_assert(is_uchar,
     "error: size must be multiple of 'unsigned char' size"); 
};
template <>
struct unsigned_char <true>
{ typedef uchar type; };

template <bool is_usint, std::size_t size>
struct unsigned_short_int
{ typedef typename
   unsigned_char<size % bits<uchar>::value == 0>::type type; };
template <std::size_t size>
struct unsigned_short_int <true, size>
{ typedef usint type; };

template <bool is_uint, std::size_t size>
struct unsigned_int
{ typedef typename
   unsigned_short_int<size % bits<usint>::value == 0, size>::type type; };
template <std::size_t size>
struct unsigned_int <true, size>
{ typedef uint type; };

template <bool is_ulong, std::size_t size>
struct unsigned_long
{ typedef typename
   unsigned_int<size % bits<uint>::value == 0, size>::type type; };
template <std::size_t size>
struct unsigned_long <true, size>
{ typedef ulong type; };

template <bool is_ulonglong, std::size_t size>
struct unsigned_long_long
{ typedef typename 
   unsigned_long<size % bits<ulong>::value == 0, size>::type type; };
template <std::size_t size>
struct unsigned_long_long <true, size>
{ typedef ulonglong type; };

template <std::size_t size>
struct type_factory_impl
{ typedef typename 
   unsigned_long_long<size % bits<ulonglong>::value == 0, size>::type type; };

第二种解决方案：

template <bool condition, typename Then, typename Else>
struct IF
{ typedef Else type; };
template <typename Then, typename Else>
struct IF <true, Then, Else>
{ typedef Then type; };

template <std::size_t size>
struct type_factory_impl
{
  typedef typename
    IF<size % bits<ulonglong>::value == 0, ulonglong,
      typename IF<size % bits<ulong>::value == 0, ulong,
        typename IF<size % bits<uint>::value == 0, uint,
          typename IF<size % bits<usint>::value == 0, usint,
            typename IF<size % bits<uchar>::value == 0, uchar, uchar>::type
          >::type
        >::type
      >::type
    >::type type;
};

Answer 1

和你一样，我认为 Boost.MPL 是黑魔法，所以我认为这可能是尝试使用它来回答你的问题的机会。请记住，这是我对这个库的第一次尝试，那里的一些专家可能会提供更好的解决方案。

这个想法是使用boost::mpl::find_if 来查找类型序列中的第一个匹配项。

typedef boost::mpl::vector
    <
        unsigned long long,
        unsigned long,
        unsigned int,
        unsigned short,
        unsigned char
    > type_sequence;

template<std::size_t size>
struct predicate
{
    template<class T>
    struct apply {
        static const bool value = (size % bits<T>::value == 0);
    };
};

template<std::size_t size>
struct type_factory_impl
{
    typedef typename boost::mpl::find_if
        <
            type_sequence,
            typename predicate<size>::apply<boost::mpl::_1>
        >::type iterator_type;

    typedef typename boost::mpl::deref<iterator_type>::type type;
};

这似乎给了我很好的结果：

我没有处理“默认”情况，但我的大脑刚刚开始流鼻血，我稍后会尝试完成我的答案，希望这会有所帮助。

Answer 2

专业化有什么问题吗？

template<size_t N>
struct lowest_bit
{
    enum
    {
        lowest_bit_removed = N & (N-1),
        value = N ^ lowest_bit_removed
    };
};

template<size_t size> struct type_factory_impl                  { typedef uchar     type; };
template<> struct type_factory_impl<sizeof(ushort)   *CHAR_BIT> { typedef ushort    type; };
template<> struct type_factory_impl<sizeof(uint)     *CHAR_BIT> { typedef uint      type; };
template<> struct type_factory_impl<sizeof(ulong)    *CHAR_BIT> { typedef ulong     type; };
template<> struct type_factory_impl<sizeof(ulonglong)*CHAR_BIT> { typedef ulonglong type; };

template<size_t size>
struct type_factory
{
    typedef typename type_factory_impl<lowest_bit<size>::value>::type type;
};