如何在保留单个参数的同时传递可变参数列表

Question

假设我有一个基类，以后可能会通过派生它来“扩展”，让我们称这个类为Base，扩展名为Derived。 类的模板签名是固定的，不能更改（即，我们不能更改类的模板参数）。 Derived 类的编写者对 Base 一无所知，只是它可能为其构造函数接受一些参数。

但是，最终派生类的调用者知道应该传递多少个参数。我该如何写这个Derived 扩展？这是我所拥有的：

struct Base
{
    Base(int baseArg) {}
};

struct Derived : public Base
{
    template <typename... Args>
    Derived(Args&&... args, int derivedArg)
    :
        Base(std::forward<Args>(args)...)
    {
    }
};

当我尝试使用Derived d(1, 1); run this 时，我收到以下错误消息：

prog.cpp: In function 'int main()':
prog.cpp:19:16: error: no matching function for call to 'Derived::Derived(int, int)'
  Derived d(1, 1);
                ^
prog.cpp:19:16: note: candidates are:
prog.cpp:11:2: note: template<class ... Args> Derived::Derived(Args&& ..., int)
  Derived(Args&&... args, int myArg)
  ^
prog.cpp:11:2: note:   template argument deduction/substitution failed:
prog.cpp:19:16: note:   candidate expects 1 argument, 2 provided
  Derived d(1, 1);
                ^
prog.cpp:8:8: note: constexpr Derived::Derived(const Derived&)
 struct Derived : public Base
        ^
prog.cpp:8:8: note:   candidate expects 1 argument, 2 provided
prog.cpp:8:8: note: constexpr Derived::Derived(Derived&&)
prog.cpp:8:8: note:   candidate expects 1 argument, 2 provided

Derived 的构造函数应该有 2 个参数，使用第一个参数来构造自身并将第二个参数传递给基类。为什么这不起作用？

Answer 1

nth获取部分参数的第n个元素：

template<size_t n, class...Args>
auto nth( Args&&... args )
->typename std::tuple_element<n,std::tuple<Args&&...>>::type
{
  return std::get<n>( std::forward_as_tuple(std::forward<Args>(args)...) );
}

这使用上面的内容来提取最后一个也是最后一个参数并将它们发送到适当的位置：

struct Derived : public Base {
  struct tag{};
  template <typename... Args>
  Derived(Args&&... args) : Derived(
    tag{},
    std::make_index_sequence<sizeof...(Args)-1>{},
    std::forward<Args>(args)...
  ){}
  template<size_t...Is, class...Args>
  Derived(tag, std::index_sequence<Is...>, Args&&...args ):
    Base(nth<Is>(std::forward<Args>(args)...)...)
  {
    int derivedArg = nth<sizeof...(Args)-1>(std::forward<Args>(args)...);
  }
};

我们为前 n-1 个元素构建一个序列，将它们传递给 base，并为我们自己存储最后一个元素。

不过，如果你把额外的参数放在前面，那就容易多了。

Answer 2

Derived 构造函数是非推导上下文。来自 [temp.deduct.type]，§14.8.2.5/5：

未推断的上下文是：

——[..]

——一个函数参数包，不出现在parameter-declaration-list的末尾。

在您的情况下，参数包不在末尾 - 在它之后还有一个参数，因此它是一个非推导上下文，这会使您的程序格式错误。简单的解决方案是颠倒排序：

template <typename... Args>
Derived(int derivedArg, Args&&... args) // totally OK
:
    Base(std::forward<Args>(args)...)
{
}