Question

是否有可能有一个泛型方法，它接受两个函数f和g（都返回void并接受相同类型的参数）并返回一个新函数接受与f和g相同类型的参数，首先将f应用于传递的参数，然后g？

具体来说，我想定义类似这样的内容：

template <typename FunctionType>
// FunctionType is void(ArgType1 arg1, ArgType2 arg2, ..)
FunctionType CombineTwoFunctions(FunctionType f, FunctionType g) {
  // Using the lambda syntax just for illustration:
  return [f, g](ArgsOf(FunctionType) args) {
     f(args);
     g(args);
  };
}

Answer 1

不是最优化的代码，但它可以工作。

在this answer

的

template <typename ...Args>
std::function<void(Args...)> CombineTwoFunctionsHelper(std::function<void(Args...)> f, std::function<void(Args...)> g) {

  return [f, g](Args ...args) {
     f(args...);
     g(args...);
  };
}

template <typename F1, typename F2>
auto CombineTwoFunctions(F1 f1, F2 f2) -> decltype(make_function(f1)) {
  return CombineTwoFunctionsHelper(make_function(f1), make_function(f2));
}

void print1(int i, std::string s) {
    std::cout << "print1 " << i << s << std::endl;   
}

void print2(int i, std::string s) {
    std::cout << "print2 " << i << s << std::endl;   
}

int main() {
    auto fg = CombineTwoFunctions(print1, print2);
    fg(1, "test");
}

的帮助下

template <typename F1, typename F2>
auto CombineTwoFunctions(F1 f, F2 g) {
  return [f, g](auto&& ...args) {
     f(args...);
     g(args...);
  };
}

void print1(int i, std::string s) {
    std::cout << "print1 " << i << s << std::endl;   
}

void print2(int i, std::string s) {
    std::cout << "print2 " << i << s << std::endl;   
}

int main() {
    auto fg = CombineTwoFunctions(print1, print2);
    fg(1, "test");
}

Full code at Coliru

您应该能够通过向参数添加（通用）引用来改进它，并转发它们以避免复制。但请注意，无法两次移动参数。

正如@ 0x499602D2在评论中所说的那样，C ++ 14让它变得更加轻松

private static IDictionary<Items,int> AssociatedValue = new Dictionary<Items,int> {
    {Items.pen, 5}, {Items.watch, 4}, {Items.rubber, 1}, {Items.ruler, 8}
};

Full code at Coliru

C ++：通用的“call-functions-f-follow-by-g”方法？

1 个答案: