1

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

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'

我错过了什么？

4

4 回答 4

2

虽然std::reference_wrapper<T>有隐式转换T&，但不能同时使用隐式转换和模板实参推导，调用模板实参推导是必须的fun。

尝试

fun(values[i].get());
于 2017-05-06T16:12:50.590 回答
2

更简单的是

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

这利用了参数包扩展可以发生在花括号初始化列表中的事实。由于func()返回 void，我们不能简单地使用{ 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。

于 2017-05-06T16:27:48.333 回答
1

由于这样做的目标可能是遍历 all 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};
}

这将为function每个argsin执行Args。

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

template <typename... args>
void caller(args&... list) {
    for_pack([&](cv::Point_<T>& arg){
        fun(arg);
    }, list...);
}
于 2017-05-06T16:21:37.283 回答
1

由于谷歌搜索“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);
..
于 2019-04-05T07:37:35.170 回答