传递对可变参数模板的引用使用 std::reference-wrapper

Question

我尝试将引用列表传递给可变参数模板函数并将其传递给另一个函数。我写的代码如下：

template <typename T>
void fun(cv::Point_<T> & pt) { pt.x++; pt.y++; }

template <class ... args>
void caller(args & ... list) {

    typedef typename std::tuple_element<0, std::tuple<args...> >::type T;

    std::array<std::reference_wrapper<T>, sizeof...(list)> values {list ...     };

    for(int i=0; i<values.size(); i++)
      fun(values[i]);

}

然后我这样调用函数调用者：

cv::Point2f a, b, c;

caller(a, b, c);

编译器给我以下错误：

No matching function for call to 'fun'
Candidate template ignored: could not match 'Point_' against 'reference_wrapper'

我错过了什么？

Answer 1

虽然std::reference_wrapper<T>隐式转换为T&，但不能同时使用隐式转换和模板实参推导，需要模板实参推导才能调用fun.

尝试

fun(values[i].get());

Answer 2

由于这样做的目标可能是遍历所有 args，这里有一个更通用的解决方案。我们将实施 for_pack:

template<typename... Args, typename F>
void for_pack(F function, Args&&... args) {
    using expand = int[];
    (void)expand{(function(std::forward<Args>(args)), void(), 0)..., 0};
}

这将为 Args 中的每个 args 执行 function。

现在，您的函数 caller 实现起来要简单得多：

template <typename... args>
void caller(args&... list) {
    for_pack([&](cv::Point_<T>& arg){
        fun(arg);
    }, list...);
}

Answer 3

更简单的是

template <typename...Args>
void caller(Args&...args)
{
    auto tmp = { (func(args),0)..., 0 };
}

这利用了参数包扩展可以发生在花括号初始化列表中的事实。由于func()returns无效，我们不能简单地使用{ func(args)... }，而是使用(func(args),0)得到一个int。最后，最后一个 0 是为了确保代码在参数包为空的情况下编译（并且不执行任何操作）。

您可以概括这一点并编写一个模板，为包的每个元素调用给定的通用函数：

template <typename Func, typename...Args>
void call_for_each(Func &&func, Args&&...args)
{
    auto unused = { (func(std::forward<Args>(args)),0)...,0 };
}

可以这样使用 (C++14)

int main()
{
    int    a=1;
    double b=2.4;
    auto func = [](auto&x) { std::cout<<' '<<x++; };
    call_for_each(func,a,b);
    std::cout<<'\n';
    call_for_each(func,a,b);
    std::cout<<'\n';
}

这使用 C++14 lambda（采用 auto 参数）。请注意，参数包必须在 call_for_each.

的模板参数中排在最后

Answer 4

由于 google 搜索 "c++ pass reference parameters to variadic template" 给出了第一个结果，我将把这个通用解决方案放在这里。

struct HH { /*...*/ void change_me() { /*...*/ } };

template<typename...T> void parms_r_refs() {}
template<typename H, typename...T> void parms_r_refs(H &h, T&...t) { h.change_me(); parms_r_refs(t...); }
template<typename...T> void parms_r_refs(T&...t) { parms_r_refs(t...); }

HH a, b, c;
..
    parms_r_refs(a, b, c);
..

传递对可变参数模板的引用使用 std::reference-wrapper

Passing references to a variadic-templates use the std::reference-wrapper

c++

variadic-templates

c++11

reference-wrapper