第一步:扩展元组并将元素传递给函数:
我有一个带N个参数的函数
void func(int, double, char);
和一个具有匹配类型的元组
std::tuple<int, double, char> tuple;
As per this stackoverflow question ,我能够扩展元组并调用函数。
第二步:扩展一个元组,并将对每个元素调用成员函数的结果传递给一个函数:
更进一步,我的元组包含类模板的多个实例:
template<typename T>
struct Foo;
std::tuple<Foo<int>, Foo<double>, Foo<char>>
Foo
有一个成员函数,Foo<T>::get()
返回 T
类型的值.
As per this stackoverflow answer ,
我有下面的工作代码,它扩展元组并调用 element.get()
在每个元素上,最终将结果传递给 func
.
不幸的是我已经硬编码调用element.get()
.
第三步:制定对每个元组元素调用哪个成员函数的规范:
(这就是我正在寻求帮助的目的)
是否可以使它通用?即传递哪个成员函数调用给apply
,因此将其作为通用实用程序?
我想也许我可以使用 std::mem_fn
包装一个函数(std::mem_fn(&Foo::get)
)并将结果对象传递给apply
, 但这不起作用因为 Foo
是一个类模板:
error: ‘template<class T> struct Foo’ used without template parameters
有什么方法可以使它通用吗?
下面的工作示例:
#include <iostream>
#include <tuple>
#include <utility>
template<size_t...>
struct Seq
{ };
template<size_t N, size_t... Sq>
struct GenSeq : GenSeq<N - 1, N - 1, Sq...>
{ };
template<size_t... Sq>
struct GenSeq<0, Sq...>
{
using type = Seq<Sq...>;
};
/////////////////////////////////////
struct Invoker
{
template<typename Func, typename Tuple, size_t... Sq>
static auto invoke(Func func, const Tuple& tuple, Seq<Sq...>)
-> decltype(func(std::get<Sq>(tuple).get()...))
{
// calls the .get() member on each object in the tuple
// I would like to make this generic
return func(std::get<Sq>(tuple).get()...);
}
template<typename Func, typename... Args>
static auto apply(Func func, const std::tuple<Args...>& args)
-> decltype(invoke(func, args, typename GenSeq<sizeof...(Args)>::type()))
{
return invoke(func, args, typename GenSeq<sizeof...(Args)>::type());
}
};
template<typename Func, typename Tuple>
inline auto apply(Func func, const Tuple& tuple)
-> decltype(Invoker::apply(func, tuple))
{
return Invoker::apply(func, tuple);
}
///////////////////////////////////////
template<typename T>
struct Foo
{
T i;
auto get() const -> decltype(i) { return i; }
};
template<typename... Ts>
struct Bar
{
Bar(Ts... ts) : tuple(std::make_tuple(Foo<Ts> { ts }...)) {}
std::tuple<Foo<Ts>...> tuple;
};
void func(int i, double d, char c)
{
std::cout << i << ", " << d << ", " << c << std::endl;
}
int main()
{
Bar<int, double, char> bar { 4, 1.23, 'a' };
apply(func, bar.tuple);
}
最佳答案
您不能使用 mem_fn
创建一个包装器来调用异构类型对象的成员函数,因为 mem_fn
创建的包装器包装了一个指向特定对象的指针特定类型的成员。
诀窍是使用模板化函数调用运算符传递一些东西,它可以接受任何适当的类型并调用成员函数。
在 C++14 中,传递多态 lambda:
[](auto&& obj) -> decltype(auto) { return std::forward<decltype(obj)>(obj).get(); }
对于 C++11,您需要手动编写等效的仿函数:
struct call_get {
template<class T>
auto operator()(T&& obj) const -> decltype(std::forward<T>(obj).get()) {
return std::forward<T>(obj).get();
}
};
关于c++ - 在元组的每个元素上一般调用成员函数,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/28642087/