Значения constexpr C++ для типов

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

Ниже приводится (повторяю: просто для удовольствия) полный эксперимент.

#include <iostream>

template <int N>
struct flag
 { friend constexpr int adl_flag (flag<N>); };

template <int N>
struct writer
 {
   friend constexpr int adl_flag (flag<N>)
    { return N; }

   static constexpr int value { N };
 };

template <int N, int = adl_flag (flag<N> {})>
int constexpr reader (int, flag<N>)
 { return N; }

template <int N>
int constexpr reader (float, flag<N>, int R = reader (0, flag<N-1> {}))
 { return R; }

int constexpr reader (float, flag<0>)
 { return 0; }

template <int N = 1>
int constexpr next (int R = writer<reader (0, flag<32> {}) + N>::value)
 { return R; }

template <typename T>
struct type
 { 
   static constexpr int id { next() };

   constexpr static int type_id ()
    { return id; }
 };

void printType (int idT )
 {
   switch ( idT )
    {
      case type<int>::type_id():
         std::cout << "- int type" << std::endl;
         break;

      case type<long>::id:
         std::cout << "- long type" << std::endl;
         break;

      default:
         std::cout << "- another type" << std::endl;
         break;
    }
 }

int main ()
 {
   int ii { type<int>::id };
   int il { type<long>::type_id() };

   printType(ii);
   printType(il);
 }

constexpr функции не могут использовать reinterpret_cast ни в какой форме. Более формальное чтение можно найти по адресу http://en.cppreference.com/w/cpp/language/constant_expression

Это может решить вашу проблему:

#include <tuple>

//Index from http://stackoverflow.com/a/18063608/3484570
template <class T, class Tuple>
struct Index;

template <class T, class... Types>
struct Index<T, std::tuple<T, Types...>> {
    static const std::size_t value = 0;
};

template <class T, class U, class... Types>
struct Index<T, std::tuple<U, Types...>> {
    static const std::size_t value = 1 + Index<T, std::tuple<Types...>>::value;
};

template <class T>
constexpr std::size_t type_id() {
    //need to add every type in this tuple:
    return Index<T, std::tuple<int, double, char>>::value;
}

int main() {
    size_t a = type_id<int>();
    switch (a) {
        case type_id<int>():
            break;
    }
}

Хорошая новость заключается в том, что вы получаете type_id<T>(), который можно использовать в контексте constexpr, например, в case, как вы хотели.
Плохая новость заключается в том, что вам нужно перечислить все поддерживаемые типы.
На практике вы можете получить используется для сообщения об ошибке, которое возникает, когда вы запрашиваете type_id неподдерживаемого типа и просто добавляете его и, в конечном итоге, добавляете все соответствующие типы.

Я хотел бы предложить другой подход, который включает constexpr функции и макросы (eeeewww...):

// Some naive text hashing function
template <std::size_t SIZE>
constexpr std::size_t hash(const char (&type_name)[SIZE])
{
    std::size_t result{0xf};
    for (const auto &c : type_name)
    {
        result <<= 1;
        result |= c;
    }

    return result;
}

Сначала мы создаем функцию constexpr, способную преобразовать строковый литерал в число, это мой подход, но вы можете выбрать другую функцию, если она constexpr, затем мы создаем макрос, который преобразует данный параметр в строку, используя #:

#define TYPE_ID(X) hash(#X)

И теперь мы можем его использовать:

int main(void) {
    size_t a = TYPE_ID(int);
    switch (a) {
    case TYPE_ID(int):
        break;
    }
    return 0;
}

Плюсы:

• Довольно просто.
• Крошечный объем кода.

Минусы:

• Макросы.
• Принимает любое значение, включая ерунду: TYPE_ID(I LOVE BACON) действительно.
• Дает разные результаты для TYPE_ID(size_t) и TYPE_ID(unsigned long), даже если они могут быть одного типа.