如何从嵌套的 lambda 表达式创建 Functor 类

Question

我开始学习lambda表达式和嵌套lambda表达式了：

    auto Suma=[](int x)->function<int(int)>
    {
        return [x](int y)
        {
            return x+y;
        };
    };
    auto Mult=[](function<int(int)>&f, int z)
    {
        return f(z)*2;
    };

我想创建 3 个 Functor classes（为了更好地理解它是如何工作的），它应该是 3 classes Sum、Inner 和 Mult。

.h:

    class Suma
    {
    public:
        int operator()(int x);
    };

    class Inner
    {
        Suma function;
    public:
        Inner(int x);
        int operator()(int k);
    };
    class Mult
    {
    public:
        int operator()(Suma function,int z);

    };

.cpp:

int Suma::operator()(int x)
{
return x;
}

Inner::Inner(int x)
{
    function.operator()(x);
}
int Inner::operator()(int k)
{
    return function.operator()+k;
}

int Mult::operator()(Suma function,int z)
{
    return (function.operator())*(2);
}

我面临的主要问题是尝试将一个相关 class 的功能包含到另一个。我不完全理解它是如何通过 classes 连接的主要思想。请告诉我它应该如何工作。

Answer 1

您的 classes 不反映 lambda 的结构。

内部 lambda return 是一个将其参数添加到捕获中的函数。所以你的Innerclass不依赖于Suma，定义如下：

// definition in .h
    class Inner
    {
        int myx; 
    public:
        Inner(int x);    // this represents the capture of the lambda
        int operator()(int k);  // this is the function of adding k to the catpture
    };

// implementation in .cpp
    Inner::Inner(int x) 
    {
        myx = x; 
    }
    int Inner::operator()(int k)
    {
        return myx + k;
    }

Suma 将 return 一个 Inner 和一个 x 集：

// definition in .h
    class Suma
    {
    public:
        Inner operator()(int x);
    };

// implementation in .cpp
    Inner Suma::operator()(int x) 
    {
        return Inner(x); 
    };

使用您的 lambda 表达式，当您计算 Suma(3) 时，您将获得一个接受整数并将其加 3 的函数。如果您计算 Suma(3)(2)，您将得到 5。

使用 classes 模拟 lambda 表达式，您将执行相同的操作：

Suma f;  // that is an object, like "auto suma"
cout << f(3)(2) <<endl;   // f(3) is in fact an object Inner(3) wich is then exectued with argument 2.

这里有一个 online demo。

通过让 Inner 成为 Suma 的嵌套 class，您甚至可以更接近 lambda 的结构。

现在查看 Mult class，第一个参数似乎不是 Suma 对象，而是调用 Suma 的结果（即return operator()) 的类型。所以这是一个 Inner。因此，您可以按如下方式完成代码：

// definition in .h 
    class Mult {
    public:
        int operator()(Inner& function, int z);
    };
// implementation in .cpp
    int Mult::operator()(Inner& function, int z)
    {
        return (function(z))*(2);  // funtion(z) means function.operator()(z)
    }

顺便说一下，正如您在上面看到的，您不需要显式调用 operator()：只需在括号之间提供参数即可。

如何从嵌套的 lambda 表达式创建 Functor 类

How to create from nested lambda expression Functor classes

c++

lambda

functor