使用 C++17，我如何创建编译时 map 类型的值？

Question

I'm writing a wrapper library that maps real C++ types to Java types for the purposes of JNI. To map to the right library calls in JNI, I have a series of class specializations:

        template<typename R>
        struct call_method_traits;

        template<>
        struct call_method_traits<void>
        {
            static constexpr auto value = &JNIEnv::CallVoidMethod;
        };

        template<>
        struct call_method_traits<bool>
        {
            static constexpr auto value = &JNIEnv::CallBooleanMethod;
        };

        // etc.....

This is the old-school way to map types to some values, but I'm wondering in C++17 if there is a better way. At first, std::tuple seems promising but it's not an associative type, so I don't see how I can use it for this.

Is the mechanism I'm using still the only way?

Answer 1

A variable template would be simpler. But you'd need to introduce some default value for non-specialisation:

template <class>
static constexpr auto call_method_traits
    = nullptr;

template <>
static constexpr auto call_method_traits<void>
    = &JNIEnv::CallVoidMethod;

Alternatively, you could keep your trait, and only use the variable template as an alias:

template <class R>
static constexpr auto call_method_traits_v
    = call_method_traits<std::decay_t<R>>::value;

This would allow you to keep the existing API for compatibility, but give users the simpler interface.

---

A constexpr template function would be more flexible, and would allow you to for example static_assert a neat message for the case that has no specialisation. But it involves a bit more boilerplate.

Answer 2

At first, std::tuple seems promising but it's not an associative type, so I don't see how I can use it for this.

Variables template seems more appropriate, but below code shows possible way with std::tuple :

template <typename T, auto Value>
struct Pair
{
    using type = T;
    static constexpr auto value = Value;
};

template <typename T, typename Tuple>
struct getter;

template <typename T, auto Value, typename ...Ts>
struct getter<T, std::tuple<Pair<T, Value>, Ts...>>
{
    static constexpr auto value = Value;
};

template <typename T, typename T2, auto Value, typename ...Ts>
struct getter<T, std::tuple<Pair<T2, Value>, Ts...>> : getter<T, std::tuple<Ts...>>
{
};

// You might also provide specialization for getter<T, std::tuple<>>
// to handle case "not present".

And then, possible usage:

using Pairs = std::tuple<Pair<void, &JNIEnv::CallVoidMethod>,
                         Pair<bool, &JNIEnv::CallBooleanMethod>
                         /*..*/
                        >;

static_assert(getter<void, Pairs>::value == &JNIEnv::CallVoidMethod);
static_assert(getter<bool, Pairs>::value == &JNIEnv::CallBooleanMethod);

Demo