Question

我有一个带有可变参数模板成员函数（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");
    }

现在这个有效，有2个问题。

强制跳过多少双打.Eg：跳过2个双打然后下一个参数应该是一个int。如果不是则抛出错误。
在此期间，使用＆＃39; int＆＃39;代替＆＃39; double＆＃39;。所以我们将跳过2个整数。下一个索引将是一个＆＃39;索引＆＃39;到阵列。

基本上我想传递不。 of int作为类模板参数跳过。

template <class T, int SKIP>
class Var {

并使用SKIP确定要跳过的总数。

是否可以做类似的事情？

Answer 1

对于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;
}

基本上，有方法可以计算目标并剥离参数直到达到目标。对目标值进行专门化。

此外，并非您可能希望forward保留引用的参数等。

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

Answer 2

所以这就是我从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;
    }
};

变量模板函数重载

2 个答案: