Как можно написать «мета, если еще, если ..» в C ++? - PullRequest
Новая
       32

Как можно написать «мета, если еще, если ..» в C ++?

6 голосов
/ 21 ноября 2010

Я только изучаю основы метапрограммирования в C ++, и я подумал, что было бы неплохо увидеть, как другие вопросы решат следующий вопрос.Также было бы очень приятно увидеть решение, использующее библиотеки метапрограммирования Boost, потому что я считаю их темным углом для себя.Итак, вопрос в том, может ли это быть переписано более элегантно?

Предположим, что у нас есть следующая структура: 

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

Эта структура должна typedef type, в зависимости отзначение 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;
};

Ответы [ 2 ]

4 голосов
/ 21 ноября 2010

Что-то не так со специализацией? 

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;
};
4 голосов
/ 21 ноября 2010

Как и вы, я считаю 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;
};

Мне кажется, это хороший результат:

alt text

Я не рассматриваю случай «по умолчанию», но мой мозг только что начал кровоточить через нос, я постараюсь завершить ответ позже и надеюсь, что это поможет.

...