C++ 使用可变模板创建哈希队列

我想使用可变模板构建一个哈希代码队列。 最简单的示例代码是

template<typename T>
void hash_queue(queue<size_t>& q){
  q.push( typeid(T).hash_code() );
}

template<typename T, typename... Ts>
void hash_queue(queue<size_t>& q){
  hash_queue<Ts...>(q);
  q.push( typeid(T).hash_code() );
}

int main(){
  queue<size_t> q;
  hash_queue<int, float, double>(q);
  return 0;
}

模板
无效哈希_队列（队列和q）{
q、 push（typeid（T）.hash_code（））；
}
模板
无效哈希_队列（队列和q）{
散列队列（q）；
q、 push（typeid（T）.hash_code（））；
}
int main（）{
队列q；
散列队列（q）；
返回0；
}

在编译时我得到

main.cpp: In instantiation of ‘void hash_queue(std::queue<long unsigned int>&) [with T = float; Ts = {double}]’:
main.cpp:19:22:   required from ‘void hash_queue(std::queue<long unsigned int>&) [with T = int; Ts = {float, double}]’
main.cpp:25:35:   required from here
main.cpp:19:22: error: call of overloaded ‘hash_queue(std::queue<long unsigned int>&)’ is ambiguous
   hash_queue<Ts...>(q);
                      ^
main.cpp:19:22: note: candidates are:
main.cpp:13:6: note: void hash_queue(std::queue<long unsigned int>&) [with T = double]
 void hash_queue(queue<size_t>& q){
      ^
main.cpp:18:6: note: void hash_queue(std::queue<long unsigned int>&) [with T = double; Ts = {}]
 void hash_queue(queue<size_t>& q){

main.cpp:void hash_queue（std:：queue&）[with T=float；Ts={double}]的实例化中：
main.cpp:19:22:void hash_queue（std:：queue&）[with T=int；Ts={float，double}]中必需的
main.cpp:25:35：从这里开始需要
main.cpp:19:22:错误：重载“hash_queue（std:：queue&）”的调用不明确
散列队列（q）；
^
main.cpp:19:22：注：候选人为：
main.cpp:13:6:注意：void hash_队列（std:：queue&）[带T=double]
无效哈希_队列（队列和q）{
^
main.cpp:18:6:注意：void hash_队列（std:：queue&）[带T=double；Ts={}]
无效哈希_队列（队列和q）{

我如何解决这个问题？

---

我不想创建类型的实例。这些类型将是具有构造函数类的对象类

使用第二个模板参数消除歧义：

template<typename T>
void hash_queue(queue<size_t>& q){
  q.push( typeid(T).hash_code() );
}

template<typename T, typename U, typename... Ts>
void hash_queue(queue<size_t>& q){
  hash_queue<U, Ts...>(q);
  hash_queue<T>(q);
}

模板
无效哈希_队列（队列和q）{
q、 push（typeid（T）.hash_code（））；
}
模板
无效哈希_队列（队列和q）{
散列队列（q）；
散列队列（q）；
}

您可以使用

std:：enable\u，前提是符合以下要求：

template<typename T, typename... Ts>
void hash_queue( queue<size_t>& q, 
                 typename std::enable_if<sizeof...(Ts)!=0 >::type* = 0 ){
  hash_queue<Ts...>(q);
  q.push( typeid(T).hash_code() );
}

模板
无效哈希_队列（队列和q，
typename std:：enable_如果：：type*=0）{
散列队列（q）；
q、 push（typeid（T）.hash_code（））；
}

请参见
也可以完全不使用递归，而是将expand打包到
std:：initializer\u列表中
，然后使用循环推入队列

template<typename... Ts>
void hash_queue(queue<size_t>& q){
  std::initializer_list<size_t> hash_codes = {typeid(Ts).hash_code()...};
  for(auto h : hash_codes)
    q.push( h );
}

或者在C++14中

template<typename... Ts>
void hash_queue(queue<size_t>& q){
  std::initializer_list<size_t> hash_codes = {typeid(Ts).hash_code()...};
  for(auto p = rbegin(hash_codes), end = rend(hash_codes); p != end; ++p)
      q.push( *p );
}

模板
无效哈希_队列（队列和q）{
std:：initializer_list hash_code={typeid（Ts）.hash_code（）…}；
对于（自动p=rbegin（散列代码），end=rend（散列代码）；p！=end；++p）
q、 推送（*p）；
}
谢谢！我怎样才能包括对
散列队列（q）；
的调用？太好了！我从来没有想过
std:：initializer\u list
，我喜欢较短的一个
template<typename... Ts>
void hash_queue(queue<size_t>& q){
  std::initializer_list<size_t> hash_codes = {typeid(Ts).hash_code()...};
  for(auto p = hash_codes.end(), end = hash_codes.begin(); p != end; --p)
      q.push( *(p-1) );
}

template<typename... Ts>
void hash_queue(queue<size_t>& q){
  std::initializer_list<size_t> hash_codes = {typeid(Ts).hash_code()...};
  for(auto p = rbegin(hash_codes), end = rend(hash_codes); p != end; ++p)
      q.push( *p );
}