Подтвердить что ты не робот

Как создать хранилище ключей/значений для компиляции?

У меня проблема, когда мне нужно сопоставить целое число во время компиляции с другим целым числом. В принципе, мне нужен эквивалент времени компиляции std::map<int,int>. Если ключ не найден на карте, я хотел бы вернуть значение по умолчанию.

Интерфейс, который я хотел бы использовать:

template<unsigned int default_value,
         unsigned int key0, unsigned int value0,
         unsigned int key1, unsigned int value1,
         ...>
struct static_map
{
  ...
};

template<unsigned int key, typename StaticMap>
struct lookup
{
  static unsigned int value = ...
};

lookup возвращает значение, связанное с key в StaticMap. Если key не найден, возвращается default_value.

В общем случае количество пар ключ/значение будет ограничено некоторым пределом > 2. Каков наилучший способ построения static_map и lookup?

Я также должен упомянуть, что я ограничен использованием языковых конструкций С++ 03, поэтому нет С++ 11 и внешних зависимостей между библиотеками.

Здесь решение, к которому я пришел, вдохновлено н.м. и DyP ниже:

#include <iostream>

template<unsigned int k, unsigned int v>
struct key_value
{
  static const unsigned int key = k;
  static const unsigned int value = v;
};


template<typename Head, typename Tail = void>
struct cons
{
  template<unsigned int key, unsigned int default_value>
  struct get
  {
    static const unsigned int value = (key == Head::key) ? (Head::value) : Tail::template get<key,default_value>::value;
  };
};


template<typename Head>
struct cons<Head,void>
{
  template<unsigned int key, unsigned int default_value>
  struct get
  {
    static const unsigned int value = (key == Head::key) ? (Head::value) : default_value;
  };
};


template<unsigned int default_value,
         unsigned int key0, unsigned int value0,
         unsigned int key1, unsigned int value1,
         unsigned int key2, unsigned int value2,
         unsigned int key3, unsigned int value3,
         unsigned int key4, unsigned int value4,
         unsigned int key5, unsigned int value5,
         unsigned int key6, unsigned int value6,
         unsigned int key7, unsigned int value7>
struct static_map
{
  template<unsigned int key>
  struct get
  {
    typedef cons<
      key_value<key0,value0>,
      cons<
        key_value<key1,value1>,
        cons<
          key_value<key2,value2>,
          cons<
            key_value<key3,value3>,
            cons<
              key_value<key4,value4>,
              cons<
                key_value<key5,value5>,
                cons<
                  key_value<key6,value6>,
                  cons<
                    key_value<key7,value7>
                  >
                >
              >
            >
          >
        >
      >
    > impl;

    static const unsigned int value = impl::template get<key,default_value>::value;
  };
};


template<unsigned int key, typename StaticMap>
struct lookup
{
  static const unsigned int value = StaticMap::template get<key>::value;
};


int main()
{
  typedef static_map<13, 
                     0, 0,
                     1, 10,
                     2, 20,
                     3, 30,
                     4, 40,
                     5, 50,
                     6, 60,
                     7, 70
  > my_static_map;

  std::cout << "0 maps to " << lookup<0, my_static_map>::value << std::endl;
  std::cout << "1 maps to " << lookup<1, my_static_map>::value << std::endl;
  std::cout << "2 maps to " << lookup<2, my_static_map>::value << std::endl;
  std::cout << "3 maps to " << lookup<3, my_static_map>::value << std::endl;
  std::cout << "4 maps to " << lookup<4, my_static_map>::value << std::endl;
  std::cout << "5 maps to " << lookup<5, my_static_map>::value << std::endl;
  std::cout << "6 maps to " << lookup<6, my_static_map>::value << std::endl;
  std::cout << "7 maps to " << lookup<7, my_static_map>::value << std::endl;
  std::cout << "100 maps to " << lookup<100, my_static_map>::value << std::endl;

  return 0;
}
4b9b3361

ОТВЕТЫ

Ответ 1

В С++ 11:

template <int kk, int vv>
struct kv
{
    static const int k = kk, v = vv;
};

template <int dflt, typename...>
struct ct_map;

template <int dflt>
struct ct_map<dflt>
{
    template<int>
    struct get
    {
        static const int val = dflt;
    };
};

template<int dflt, int k, int v, typename... rest>
struct ct_map<dflt, kv<k, v>, rest...>
{
    template<int kk>
    struct get
    {
        static const int val =
            (kk == k) ?
            v :
            ct_map<dflt, rest...>::template get<kk>::val;
    };
};

typedef ct_map<42, kv<10, 20>, kv<11, 21>, kv<23, 7>> mymap;

#include <iostream>
int main()
{
    std::cout << mymap::get<10>::val << std::endl;
    std::cout << mymap::get<11>::val << std::endl;
    std::cout << mymap::get<23>::val << std::endl;
    std::cout << mymap::get<33>::val << std::endl;
}

Ответ 2

Что-то вроде этого будет работать:

template<int Key>
struct StaticMap {
  static const int Value = 0;
};

template<>
struct StaticMap<1> {
  static const int Value = 3;
};

int main()
{
  cout << StaticMap<0>::Value << ", " 
       << StaticMap<1>::Value << ", "
       << StaticMap<2>::Value << endl;
}

0 - значение по умолчанию, а ключ 1 - значение 3. При необходимости добавьте дополнительные специализации.

Это общая идея того, что вы ищете? Это не тот интерфейс, который вы запросили, хотя макросы препроцессора (такие как Boost.Preprocessor) могли бы упростить и упростить настройку.

Ответ 3

Основываясь на наследовании: каждый экземпляр карты наследует типы поиска его базового класса (- > проблема уменьшения) и определяет поиск ключа.

Изменить: улучшенная версия базы на n.m. идеи.

#include <iostream>
#include <cstddef>

template < int t_key, int t_value >
struct ct_int_pair
{
    enum { key = t_key, value = t_value };
};

struct dummy;

template < int default_value,
           typename key_value_pair0,
           typename key_value_pair1 = dummy,
           typename key_value_pair2 = dummy >
struct ct_map
    : ct_map < default_value, key_value_pair1, key_value_pair2, dummy >
{
    typedef ct_map < default_value, key_value_pair1, key_value_pair2, dummy > base;

    // DUMMY required for partial specialization
    template < int key, class DUMMY = dummy >
    struct lookup
    {
        enum { value = base::template lookup < key > :: value };
    };
      template < class DUMMY >
      struct lookup < key_value_pair0::key, DUMMY >
      {
          enum { value = key_value_pair0::value };
      };
};

  template < int default_value >
  struct ct_map < default_value, dummy, dummy, dummy >
  {
      template < int key >
      struct lookup
      {
          enum { value = default_value };
      };
  };


template < int key, typename StaticMap >
struct lookup
{
    enum { value = StaticMap :: template lookup < key > :: value };
};


// example

typedef ct_map < -1,
                 ct_int_pair<21, 42>,
                 ct_int_pair<10, 15> > my_map;

enum
{
     value0 = lookup<21, my_map>::value
   , value1 = lookup<10, my_map>::value
   , value2 = lookup<100, my_map>::value
};

int main()
{
    std::cout << value0 << " : " << value1 << " : " << value2 << std::endl;
}

Ответ 4

Вы можете использовать специализированную специализацию

template <char key>
struct Map;

template <char key>
struct Map { static const int value = -1; }; // not exists node

template <> struct Map< 'A' > { static const int value = 1; }; // 'A' -> 1
template <> struct Map< 'B' > { static const int value = 2; }; // 'B' -> 2
// ....

int lookup = Map<'B'>::value; // = 2

Вы можете использовать некоторые макросы, чтобы упростить определение содержимого.