C++11 可变模板函数重载

我有一个带有可变模板成员函数（foo）的类，如下所示。其思想是跳过参数中的所有双精度项，并使用用户提供的参数分配对象

    template <class T>
    class Var {
    public:

       template <typename U, typename ...Args>
       int foo(int index, Args... args)
       {
           T* p = new U(args...);
           // save in an array at index 'index'
       }

       template <typename U, typename ...Args>
       int foo (double index, Args... args)
       {
           // do something with index and skip it
           return foo<U>(args...);
       }
    };

    class A {
    public:
      A (int i, const char *p)
      {

      }
    };

    int main ()
    {
       Var<A> var;

       var.foo<A>(1.0, 2, 3, "Okay");
    }

模板
类变量{
公众：
模板
intfoo（intindex，Args…Args）
{
T*p=新U（参数…）；
//保存在索引“index”处的数组中
}
模板
intfoo（双索引，Args…Args）
{
//使用索引做一些事情并跳过它
返回foo（args…）；
}
};
甲级{
公众：
A（整数i，常量字符*p）
{
}
};
int main（）
{
Var；
变量foo（1.0,2,3，“好”）；
}

现在这项工作，有两个问题

• 强制跳过多少个double。例如：跳过2个double，然后下一个参数应该是int。如果不是，则抛出错误

• 使用时，请使用“int”代替“double”。所以我们将跳过2个整数。下一个索引将是数组的“索引”

基本上，我想将要跳过的int数作为类模板参数传递

template <class T, int SKIP>
class Var {

模板
类变量{

并使用SKIP确定要跳过的整数数

---

可以这样做吗？

对于您的

SKIP

目标，您可以这样做：

template <typename U, typename ...Args>
int foo(Args ...args) {
  return foo_helper<U, 0>(std::forward(args));
}

template <typename U, int I, typename ...Args>
int foo_helper(int index, Args ...args) {
  return foo_helper<U, I+1>(std::forward(args));
}

template <typename U, typename ...Args>
int foo_helper<U, SKIP, Args...>(int index, Args ...args) {
  blah = new U(std::forward(args));
  return foobar;
}

模板
int foo（Args…Args）{
返回foo_helper（std:：forward（args））；
}
模板
int foo_helper（int索引、Args…Args）{
返回foo_helper（std:：forward（args））；
}
模板
int foo_helper（int索引、Args…Args）{
blah=新U（标准：：转发（args））；
返回foobar；
}

基本上，要有计算到目标值的方法，并在达到目标值之前去掉参数。对目标值进行专门化

另外，您可能不想

转发

参数以保留引用，等等

---

我相信C++14可能会使其中一些变得更容易，但我对新的模板元编程技术还不太熟悉，无法解决这个问题。

所以这就是我从Novelocrat那里得到的提示。只是粘贴它以备记录

template <class T, int SKIP>
class FooHelper {
public:

    template <typename U, typename ...Args>
    static int foo_helper(int index, Args... args)
    {
        FooHelper<T, SKIP-1>::foo_helper<U>(args...);
        return 0;
    }
};

template <class T>
class FooHelper<T, 0> {
public:

    template <typename U, typename ...Args>
    static int foo_helper (Args... args)
    {
        auto p = new U(args...);
        return 0;
    }
};

template <class T, int SKIP>
class Var {
public:

    template <typename U, typename ...Args>
    int foo(Args ...args)
    {
        FooHelper<T, SKIP>::foo_helper<U>(args...);
        return 0;
    }
};

模板
类FooHelper{
公众：
模板
静态int foo_助手（int索引、Args…Args）
{
fooohelper:：foo_helper（args…）；
返回0；
}
};
模板
类FooHelper{
公众：
模板
静态int-foo\u辅助程序（Args…Args）
{
自动p=新U（参数…）；
返回0；
}
};
模板
类变量{
公众：
模板
int foo（Args…Args）
{
fooohelper:：foo_helper（args…）；
返回0；
}
};

我认为这样做是可能的，但在我看来，生成的代码可能非常难看和复杂。这只是一个学术问题，还是你正在试图解决的一个实际问题？如果你陈述一个精确的问题，比如，你想得到什么样的准确行为，这可能会有所帮助。这更学术化。我有一个解决方案CHI根据Novelocrat建议的方案添加了以下内容。在我的代码库中有一个实际的用例，我们需要根据类型或类型和子类型存储对象。因此查找函数是（int-type）或（int-type，int-subtype）。但我没有在那里使用此方案。我选择了更简单的解决方案，即使用2个专用类，在其中我重新定义了相同的函数（函数名）使用不同的参数集。谢谢你的回答。但是我们不是在做函数模板的部分专门化吗？它不是编译。但是模板类专门化的相同技术可以工作。你是对的，它是函数模板的部分专门化。我不认为上面的代码可以通过或直接测试它。但是，是的，它可以可以始终包装在类模板中以使其正常工作。