C++17:在编译时将类型映射到整数值

Question

我有以下几种:

struct A { }; 
struct B { }; 
struct C { }; 

template <typename Class, uint16_t i>     
struct def {                              
        using message_type = Class;       
        static constexpr uint16_t tag = i;
};                                        

还有这个元组:

constexpr auto types = std::make_tuple(def<A, 1>(), def<B, 2>(), def<C, 3>());

类型 A、B 和 C 应映射到相应的值(A -> 1 等)。我想创建一些东西(函数，结构)，这些类型之一的给定对象将返回正确的值。我尝试执行以下操作:

template <typename T>                                                                    
struct gettag {                                                                          
        static decltype(T::tag) value(typename T::message_type const&) { return T::tag; }
};                                                                                       

template <typename... Args>                                                              
struct tagdb : public gettag<Args>... {                                                  
        tagdb(std::tuple<Args...> const& t) { }                                          
};                                                                                       
int main() {                            
        tagdb t(types);                 
        A a;                            
        std::cout << t.value(a) << '\n';
}                                       

这不起作用，g++ 声称对成员 value 的请求不明确:

x.cc: In function ‘int main()’:
x.cc:29:17: error: request for member ‘value’ is ambiguous
   29 |  std::cout << t.value(a) << '\n';
      |                 ^~~~~
x.cc:16:26: note: candidates are: ‘static decltype (T::tag) gettag<T>::value(const typename T::message_type&) [with T = def<C, 3>; decltype (T::tag) = const short unsigned int; typename T::message_type = C]’
   16 |  static decltype(T::tag) value(typename T::message_type const&) { return T::tag; }
      |                          ^~~~~
x.cc:16:26: note:                 ‘static decltype (T::tag) gettag<T>::value(const typename T::message_type&) [with T = def<B, 2>; decltype (T::tag) = const short unsigned int; typename T::message_type = B]’
x.cc:16:26: note:                 ‘static decltype (T::tag) gettag<T>::value(const typename T::message_type&) [with T = def<A, 1>; decltype (T::tag) = const short unsigned int; typename T::message_type = A]’

我有点惊讶，特别是因为它清楚地表明每个方法都使用不同的类型进行参数化。

有没有办法让这个解决方案发挥作用，或者我应该完全改变我的方法？请注意，我最想避免的是为每种类型编写重载。

Answer 1

我建议一个没有 std::tuple 和 gettag 的解决方案:

struct A { }; 
struct B { }; 
struct C { }; 

template <typename Class, std::uint16_t i>     
struct def {                              
    static constexpr std::uint16_t value(Class) {
        return i;
    }
};  

template <typename... Tags>                                                              
struct tagdb : public Tags... {                                                  
    using Tags::value...;
};

template<class... Tags>
constexpr auto make_tagdb(Tags...) {
    return tagdb<Tags...>{};
}

// template<class... Tags>
// constexpr auto make_tagdb(std::tuple<Tags...>) {
//     return tagdb<Tags...>{};
// }

constexpr auto tags = make_tagdb(def<A, 1>(), def<B, 2>(), def<C, 3>());

int main() {                            
    A a;                            
    std::cout << tags.value(a) << '\n';   // Output: 1
}