C++中的函数式编程。实施 f(a)(b)(c)

Question

我一直在学习使用 C++ 进行函数式编程的基础知识。我正在尝试创建一个函数f(a)(b)(c)，它将返回a + b + c。我成功实现了函数f(a)(b)，它返回a + b。这是它的代码：

std::function<double(double)> plus2(double a){
    return[a](double b){return a + b; };
}

我只是不知道如何实现函数f(a)(b)(c)，正如我之前所说的应该返回a + b + c。

Answer 1

你可以通过让你的函数f返回一个functor来做到这一点，即一个实现operator()的对象。这是一种方法：

struct sum 
{
    double val;

    sum(double a) : val(a) {}

    sum operator()(double a) { return val + a; }

    operator double() const { return val; }
};

sum f(double a)
{
    return a;
}

示例

Link

int main()
{
    std::cout << f(1)(2)(3)(4) << std::endl;
}

---

模板版本

您甚至可以编写一个模板版本，让编译器推断类型。试试看here。

template <class T>
struct sum 
{
    T val;

    sum(T a) : val(a) {}

    template <class T2>
    auto operator()(T2 a) -> sum<decltype(val + a)> { return val + a; }

    operator T() const { return val; }
};

template <class T>
sum<T> f(T a)
{
    return a;
}

示例

在本例中，T 最终将解析为 double：

std::cout << f(1)(2.5)(3.1f)(4) << std::endl;

Answer 2

只需使用您的 2 元素解决方案并通过用另一个 lambda 包装它来扩展它。

由于您要返回一个 lambda，它得到一个 double 并返回一个 doubles 的附加 lambda，您需要做的就是用另一个函数包装您当前的返回类型，并将一个嵌套的 lambda 添加到您的当前一个（返回 lambda 的 lambda）：

std::function<std::function<double(double)>(double)> plus3 (double a){
    return [a] (double b) {
        return [a, b] (double c) {
            return a + b + c;
        };
    };
}

---

• 正如@Ðаn所说，你可以跳过std::function<std::function<double(double)>(double)>并与auto相处：

  auto plus3 (double a){
      return [a] (double b) {
          return [a, b] (double c) { return a + b + c; };
      };
  }
  

• 您可以使用更深层次的嵌套 lambda 为每个数量的元素扩展此结构。 4个元素的演示：

  auto plus4 (double a){
      return [a] (double b) {
          return [a, b] (double c) {
              return [a, b, c] (double d) {
                  return a + b + c + d;
              };
          };
      };
  }
  

Answer 3

这是一种稍微不同的方法，它从operator() 返回对*this 的引用，因此您不会有任何副本浮动。这是一个非常简单的仿函数实现，它在自身上递归地存储状态和左折叠：

#include <iostream>

template<typename T>
class Sum
{
    T x_{};
public:
    Sum& operator()(T x)
    {
        x_ += x;
        return *this;
    }
    operator T() const
    {
        return x_;
    }
};

int main()
{
    Sum<int> s;
    std::cout << s(1)(2)(3);
}

Live on Coliru

Answer 4

这不是f(a)(b)(c)，而是curry(f)(a)(b)(c)。我们包装f，这样每个额外的参数要么返回另一个curry，要么实际上急切地调用函数。这是 C++17，但可以通过大量额外工作在 C++11 中实现。

请注意，这是对函数进行柯里化的解决方案 - 这是我从问题中得到的印象 - 而不是折叠二元函数的解决方案。

template <class F>
auto curry(F f) {
    return [f](auto... args) -> decltype(auto) {
        if constexpr(std::is_invocable<F&, decltype(args)...>{}) {
            return std::invoke(f, args...);
        }
        else {
            return curry([=](auto... new_args)
                    -> decltype(std::invoke(f, args..., new_args...))
                {
                    return std::invoke(f, args..., new_args...);
                });
        }
    };  
}

为简洁起见，我跳过了转发参考。示例用法是：

int add(int a, int b, int c) { return a+b+c; }

curry(add)(1,2,2);       // 5
curry(add)(1)(2)(2);     // also 5
curry(add)(1, 2)(2);     // still the 5th
curry(add)()()(1,2,2);   // FIVE

auto f = curry(add)(1,2);
f(2);                    // i plead the 5th

Answer 5

我能想到的最简单的方法是用plus2() 定义plus3()。

std::function<double(double)> plus2(double a){
    return[a](double b){return a + b; };
}

auto plus3(double a) {
    return [a](double b){ return plus2(a + b); };
}

这将前两个参数列表组合成一个 arglist，用于调用 plus2()。这样做可以让我们以最少的重复重用我们预先存在的代码，并且可以在未来轻松扩展； plusN() 只需要返回一个调用plusN-1() 的lambda，它会将调用依次向下传递给前一个函数，直到到达plus2()。可以这样使用：

int main() {
    std::cout << plus2(1)(2)    << ' '
              << plus3(1)(2)(3) << '\n';
}
// Output: 3 6

---

考虑到我们只是在线调用，我们可以轻松地将其转换为函数模板，从而无需为其他参数创建版本。

template<int N>
auto plus(double a);

template<int N>
auto plus(double a) {
    return [a](double b){ return plus<N - 1>(a + b); };
}

template<>
auto plus<1>(double a) {
    return a;
}

int main() {
    std::cout << plus<2>(1)(2)          << ' '
              << plus<3>(1)(2)(3)       << ' '
              << plus<4>(1)(2)(3)(4)    << ' '
              << plus<5>(1)(2)(3)(4)(5) << '\n';
}
// Output: 3 6 10 15

查看两者的实际操作here。

Answer 6

我要去玩了。

你想做一个咖喱折叠加法。我们可以解决这个问题，或者我们可以解决包括这个问题的一类问题。

所以，首先，加法：

auto add = [](auto lhs, auto rhs){ return std::move(lhs)+std::move(rhs); };

这很好地表达了加法的概念。

现在，折叠：

template<class F, class T>
struct folder_t {
  F f;
  T t;
  folder_t( F fin, T tin ):
    f(std::move(fin)),
    t(std::move(tin))
  {}
  template<class Lhs, class Rhs>
  folder_t( F fin, Lhs&&lhs, Rhs&&rhs):
    f(std::move(fin)),
    t(
      f(std::forward<Lhs>(lhs), std::forward<Rhs>(rhs))
    )
  {}
  template<class U>
  folder_t<F, std::result_of_t<F&(T, U)>> operator()( U&& u )&&{
    return {std::move(f), std::move(t), std::forward<U>(u)};
  }
  template<class U>
  folder_t<F, std::result_of_t<F&(T const&, U)>> operator()( U&& u )const&{
    return {f, t, std::forward<U>(u)};
  }
  operator T()&&{
    return std::move(t);
  }
  operator T() const&{
    return t;
  }
};

它需要一个种子值和一个 T，然后允许链接。

template<class F, class T>
folder_t<F, T> folder( F fin, T tin ) {
  return {std::move(fin), std::move(tin)};
}

现在我们将它们连接起来。

auto adder = folder(add, 0);
std::cout << adder(2)(3)(4) << "\n";

我们也可以使用folder进行其他操作：

auto append = [](auto vec, auto element){
  vec.push_back(std::move(element));
  return vec;
};

用途：

auto appender = folder(append, std::vector<int>{});
for (int x : appender(1)(2)(3).get())
    std::cout << x << "\n";

Live example.

我们必须在这里调用.get()，因为for(:) 循环不理解我们文件夹的operator T()。我们可以通过一些工作来解决这个问题，但.get() 更容易。

Answer 7

如果你愿意使用库，这在Boost's Hana 中真的很容易：

double plus4_impl(double a, double b, double c, double d) {
    return a + b + c + d;
}

constexpr auto plus4 = boost::hana::curry<4>(plus4_impl);

然后随心所欲地使用它：

int main() {
    std::cout << plus4(1)(1.0)(3)(4.3f) << '\n';
    std::cout << plus4(1, 1.0)(3)(4.3f) << '\n'; // you can also do up to 4 args at a time
}

Answer 8

所有这些答案似乎都非常复杂。

auto f = [] (double a) {
    return [=] (double b) {
        return [=] (double c) {
            return a + b + c;
        };
    };
};

完全符合您的要求，并且可以在 C++11 中使用，这与此处的许多或大多数其他答案不同。

请注意，它不使用会导致性能损失的std::function，事实上，在许多情况下它可能会被内联。

Answer 9

这是一个使用operator() 来改变状态的状态模式单例方法。

编辑：将不必要的赋值换成初始化。

#include<iostream>
class adder{
private:
  adder(double a)val(a){}
  double val = 0.0;
  static adder* mInstance;
public:
  adder operator()(double a){
    val += a;
    return *this;}
  static adder add(double a){
    if(mInstance) delete mInstance;
    mInstance = new adder(a);
    return *mInstance;}
  double get(){return val;}
};
adder* adder::mInstance = 0;
int main(){
  adder a = adder::add(1.0)(2.0)(1.0);
  std::cout<<a.get()<<std::endl;
  std::cout<<adder::add(1.0)(2.0)(3.0).get()<<std::endl;
  return 0;
}