[英]Achieve functor overloading through composition
Given some existing functors: 鉴于一些现有的仿函数:
struct incr {
int operator()(int x) const { return x + 1; }
};
struct rep_str {
std::string operator()(const std::string& s) const { return s + s; }
};
I'm wondering if it's possible to achieve something like this: 我想知道是否有可能实现这样的目标:
auto f = overload<incr, rep_str>();
f(1); // returns 2
f("hello"); // returns "hellohello"
Multiple overloads may look like: 多次重载可能如下所示:
auto f = overload<fa, fb, fc, ...>();
// or...
auto g = overload<fa, overload<fb, overload<fc, ...>>>();
I'm thinking maybe use SFINAE with std::result_of_t
or something like that, but haven't figured out how. 我想也许可以使用SFINAE与
std::result_of_t
或类似的东西,但还没弄明白怎么做。
You don't need anything too fancy: just inherit from all the arguments and use using-declarations to bring in operator()
from the base classes. 你不需要任何太花哨的东西:只需从所有参数继承并使用using-declarations从基类中引入
operator()
。 However, in the variadic case, you can't have a pack expansion in a using-declaration , so you have to use a recursive approach, like so: 但是,在可变参数的情况下,你不能在using声明中使用包扩展,所以你必须使用递归方法,如下所示:
template <class... Ts>
struct overload {}; // only used for empty pack
template <class T>
struct overload<T> : private T {
using T::operator();
};
template <class T1, class T2, class... Ts>
struct overload<T1, T2, Ts...> : private T1, overload<T2, Ts...> {
using T1::operator();
using overload<T2, Ts...>::operator();
};
Brian's answer is better, IMHO, but since I worked on it, here's mine: 布莱恩的答案更好,恕我直言,但自从我开始研究,这是我的:
#include <type_traits>
#include <utility>
template <typename... Fns>
struct overload;
template <typename Fn, typename... Fns>
struct overload<Fn, Fns...>
{
template <typename... T>
std::result_of_t<Fn(T...)> operator()(T && ... args) const {
return Fn()(std::forward<T>(args)...);
}
using next = overload<Fns...>;
template <typename... T>
std::result_of_t<next(T...)> operator()(T && ... args) const {
return next()(std::forward<T>(args)...);
}
};
this can be done using template specialization: 这可以使用模板专业化来完成:
#include <string>
#include <iostream>
template <typename...Args>
struct overload{
};
template <> struct overload<int>{
int operator()(int x) const { return x + 1; }
};
template <> struct overload< std::string>{
std::string operator()(const std::string& s) const { return s + s; }
};
template <typename...Args >
auto f(Args...arg){
overload<Args...> func;
return func(arg...);
}
int main()
{
std::cout << f(3) << std::endl << f(std::string("Hello"));
}
Note: two answers by @Brian and @md5i more general and elegant and perfect and better than this. 注意:@Brian和@ md5i的两个答案更加通用,优雅,完美,比这更好。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.