变分模板与类模板的特殊化

Question

这是我在玩变量模板时遇到的一个问题。我有一些代码，使用专业化来计算参数包中的“有趣”类型，就像这样：

template<typename... _Pp>
struct count;

template<>
struct count<>
{
  static const int value = 0;
};

// ignore uninteresting types
template<typename _First, typename... _Rest>
struct count<_First, _Rest...>
{
  static const int value = count<_Rest...>::value;
};

// add 1 for a pointer
template<typename _First, typename... _Rest>
struct count<_First*, _Rest...>
{
  static const int value = 1 + count<_Rest...>::value;
};

// add 1 for a reference
template<typename _First, typename... _Rest>
struct count<_First&, _Rest...>
{
  static const int value = 1 + count<_Rest...>::value;
};

// add 1 for an int
template<typename... _Rest>
struct count<int, _Rest...>
{
  static const int value = 1 + count<_Rest...>::value;
};

这段代码工作正常，但是如果我想使用相同的方法来计算类模板，我会遇到问题：

// add 1 for a vector
template<typename... _Rest>
struct count<vector, _Rest...>
{
  static const int value = 1 + count<_Rest...>::value;
};

上面的代码编译失败，错误是"预期的类型，得到了'向量'"开始的行"结构计数"。我也无法更简单的东西，所有的类模板接受一个参数：

// add 1 for a class template with 1 type parameter
template<template<typename> class _First, typename... _Rest>
struct count<_First, _Rest...>
{
  static const int value = 1 + count<_Rest...>::value;
}

这段代码也无法编译，再次在以“结构计数”开头的行中抱怨“预期的类型，得到了‘_First’”。有人熟悉使用这种方法实现这一目标的方法吗（例如，我可以对一个或两个专业进行一些修改，使它们在编译时编译并执行所需的计算）？

编辑：我希望vector的参数包是未绑定的，类似于以下代码，用于一个简单的容器包装器，其中包含可变模板参数，该模板参数也专门用于std:：vector：

// pass a container as a parameter using variadic template-template 

parameter
template<typename _Tp, template<typename...> class _C>
struct success
{
  // not specialized for any container
  static const bool is_specialized = false;
  // data member of container type
  _C<_Tp> c_;
};

// partial specialization of above for std::vector
template<typename _Tp>
struct success<_Tp, std::vector>
{
  // specialized for vector
  static const bool is_specialized = true;
  // again, data member of container type
  std::vector<_Tp> c_;
};

编辑似乎最终的答案是，我想做的事情无法完成，但我找到了一种方法来重新设计问题，这样我就能解决它。非常感谢那些帮助过我的人。

Answer 1

应该是：

template<typename... _Rest, typename... T>
struct count<std::vector<T...>, _Rest...>
{
    static const int value = 1 + count<_Rest...>::value;
};

通用版本：

template<template<typename...> class C, typename... _Rest, typename... T>
struct count<C<T...>, _Rest...>
{
    static const int value = 1 + count<_Rest...>::value;
};

变量包很重要。

Answer 2

像这样的怎么样？

// add 1 for a vector
template<typename... _Rest, typename T>
struct count<vector<T>, _Rest...>
{
  static const int value = 1 + count<_Rest...>::value;
};

这个呢？

// add 1 for a class template with 1 type parameter
template<template<typename> class _First, typename T, typename... _Rest>
struct count<_First<T>, _Rest...>
{ 
  static const int value = 1 + count<_Rest...>::value;
};

Answer 3

如果我正确理解你想要什么...是的，你可以创建一个可以计算“类模板”的模板结构，这样你就可以写这样的东西

 count<std::vector, std::map, std::set, std::pair>::value

但是你不能混合类模板和简单的字体名，所以你不能写这样的东西

 count<std::vector, int &, float, std::set>::value

问题是如果你定义

 template <typename... _Pp>
    struct count;

您可以传递std:：vector

您可以编写类似以下内容的代码

template <template<typename...> class ...>
struct countC;

template <>
struct countC<>
 { static const int value = 0; };

// ignore uninteresting templates
template<template<typename...> class F, template<typename...> class ... R>
struct countC<F, R...>
 { static const int value = countC<R...>::value; };

template <template<typename...> class ... R>
struct countC<std::vector, R...>
 { static const int value = 1 + countC<R...>::value; };

下面是一个完整的工作示例，其中我将您的struct count重写为struct countT对于计数选定的类型，我添加了一个struct countC来计数选定的“类模板”，并添加了一个struct countV来计数固定类型名的选定值。

#include <map>
#include <set>
#include <vector>
#include <utility>
#include <iostream>

// countC for templates

template <template<typename...> class ...>
struct countC;

template <>
struct countC<>
 { static const int value = 0; };

// ignore uninteresting templates
template<template<typename...> class F, template<typename...> class ... R>
struct countC<F, R...>
 { static const int value = countC<R...>::value; };

template <template<typename...> class ... R>
struct countC<std::vector, R...>
 { static const int value = 1 + countC<R...>::value; };

template <template<typename...> class ... R>
struct countC<std::map, R...>
 { static const int value = 1 + countC<R...>::value; };

template <template<typename...> class ... R>
struct countC<std::pair, R...>
 { static const int value = 1 + countC<R...>::value; };


// countV for for values of a fixed type

template <typename T, T ... v>
struct countV;

template <typename T>
struct countV<T>
 { static const int value = 0; };

// ignore uninteresting values
template <typename T, T f, T ... r>
struct countV<T, f, r...>
 { static const int value = countV<T, r...>::value; };

// count only int odd values
template <int f, int ... r>
struct countV<int, f, r...>
 { static const int value = (f % 2) + countV<int, r...>::value; };


// countT for typenames

template <typename...>
struct countT;

template <>
struct countT<>
 { static const int value = 0; };

// ignore uninteresting types
template <typename F, typename ... R>
struct countT<F, R...>
 { static const int value = countT<R...>::value; };

template <typename F, typename ... R>
struct countT<F*, R...>
 { static const int value = 1 + countT<R...>::value; };

template<typename F, typename ... R>
struct countT<F&, R...>
 { static const int value = 1 + countT<R...>::value; };

template<typename ... R>
struct countT<int, R...>
 { static const int value = 1 + countT<R...>::value; };


int main()
 {
   std::cout << "countC vector + map + set + pair                   = " 
      << countC<std::vector, std::map, std::set, std::pair>::value
      << std::endl;

   std::cout << "countT int + float + bool* + double& + bool + int& = " 
      << countT<int, float, bool*, double&, bool, int&>::value
      << std::endl;

   std::cout << "countV int, 1 + 4 + 4 + 5 + 7 + 10 + 11 + 16 + 15  = " 
      << countV<int, 1, 4, 4, 5, 7, 10, 11, 16, 15>::value
      << std::endl;

   std::cout << "countV long, 1 + 4 + 4 + 5 + 7 + 10 + 11 + 16 + 15 = " 
      << countV<long, 1, 4, 4, 5, 7, 10, 11, 16, 15>::value
      << std::endl;

   return 0;
 }

p、 对不起，我的英语不好。