在C ++中,是否可以在异构元组上映射重载函数?例如:
double f(dobule);
size_t f(std::string);
auto t = std::make_tuple(3.14, "a string");
// should be the same as std::make_tuple(f(std::get<0>(t)), f(std::get<1>(t)));
map(f, make_tuple(3.14, "a string")); // type std::tuple<double, size_t>
我可以编写一个map函数,将f
的相同重载实例映射到每个元组元素(下面的代码),但我不知道如何推迟f
的重载分辨率从map
的调用到f
内map
的调用。有没有人想出怎么做?
这是我的代码,用于在元组上映射重载函数的单个实例(其中seq和gens取自此答案https://stackoverflow.com/a/7858971/431282):
// basically C++14's integer sequence
template<int ...>
struct seq { };
template<int N, int ...S>
struct gens : gens<N-1, N-1, S...> { };
template<int ...S>
struct gens<0, S...> {
typedef seq<S...> type;
};
template<typename R, typename A, typename ...B, int ...S> auto
map_1(R (*f)(A), std::tuple<B...> &&t, seq<S...>)
-> decltype(std::make_tuple(f(std::get<S>(t))...))
{
return std::make_tuple(f(std::get<S>(t))...);
}
template<typename R, typename A, typename ...B> auto
map(R (*f)(A), std::tuple<B...> &&t)
-> decltype(map_1(f, std::forward<std::tuple<B...>>(t), typename gens<sizeof...(B)>::type()))
{
return map_1(f, std::forward<std::tuple<B...>>(t), typename gens<sizeof...(B)>::type());
}
答案 0 :(得分:2)
问题在于单独使用函数指针无法完成,因为您希望在绑定到参数时解析函数重载。如果不执行重载决策,则无法获得函数指针。关键是提供一个在调用时执行重载的函数对象,而不是试图在开始时获取函数指针。
为此,我将主要功能声明为
template<typename Func, typename ...B> auto
map(Func&& f, std::tuple<B...> &&t)
-> decltype(map_1(std::forward<Func>(f), std::forward<std::tuple<B...>>(t), typename gens<sizeof...(B)>::type()))
{
return map_1(std::forward<Func>(f), std::forward<std::tuple<B...>>(t), typename gens<sizeof...(B)>::type());
}
然后以类似的方式定义map_1
。
然后你可以创建一个函数对象包装器
struct Wrapper
{
template<typename T>
auto operator()(T&& t) const -> decltype( f(std::forward<T>(t)) )
{
return f(std::forward<T>(t));
}
};
并使用map(Wrapper(), make_tuple(3.14, "a string"))
编辑:如果您有C ++ 14,您可以执行以下操作(感谢@MooingDuck获取灵感)
#define BINDOVERLOADED(X) [](auto&& t) { return X(std::forward<decltype(t)>(t)); }
auto x = map(BINDOVERLOADED(f), make_tuple(3.14, "a string"));