Question

我想了解一些关于如何正确思考C ++ 11闭包的信息，以及std::function关于它们如何实现以及如何处理内存的信息。

虽然我不相信过早优化，但我确实习惯在编写新代码时仔细考虑我的选择对性能的影响。我也做了大量的实时编程，例如在微控制器和音频系统中，要避免非确定性的内存分配/释放暂停。

因此，我想更好地了解何时使用或不使用C ++ lambdas。

我目前的理解是没有捕获闭包的lambda就像C回调一样。但是，当通过值或引用捕获环境时，将在堆栈上创建匿名对象。当必须从函数返回值闭包时，将其包装在std::function中。在这种情况下闭包内存会发生什么？它是从堆栈复制到堆？是否释放std::function时是否释放，即引用计数是否为std::shared_ptr？

我想在实时系统中我可以建立一个lambda函数链，将B作为一个连续参数传递给A，这样就创建了一个处理管道A->B。在这种情况下，A和B闭包将被分配一次。虽然我不确定这些是否会在堆栈或堆上分配。然而，一般来说，这在实时系统中使用似乎是安全的。另一方面，如果B构造一些它返回的lambda函数C，那么C的内存将被重复分配和释放，这对于实时使用是不可接受的。

在伪代码中，一个DSP循环，我认为这将是实时安全的。我想执行处理块A然后执行B，其中A调用它的参数。这两个函数都返回std::function个对象，因此f将是一个std::function对象，其环境存储在堆上：

auto f = A(B);  // A returns a function which calls B
                // Memory for the function returned by A is on the heap?
                // Note that A and B may maintain a state
                // via mutable value-closure!
for (t=0; t<1000; t++) {
    y = f(t)
}

我认为在实时代码中使用它可能不好：

for (t=0; t<1000; t++) {
    y = A(B)(t);
}

我认为堆栈内存很可能用于闭包：

freq = 220;
A = 2;
for (t=0; t<1000; t++) {
    y = [=](int t){ return sin(t*freq)*A; }
}

在后一种情况下，闭包是在循环的每次迭代中构造的，但与前面的例子不同，它很便宜，因为它就像一个函数调用，没有进行堆分配。此外，我想知道编译器是否可以“解除”关闭并进行内联优化。

这是对的吗？谢谢。

Answer 1

我目前的理解是没有捕获闭包的lambda就像C回调一样。但是，当通过值或引用捕获环境时，将在堆栈上创建匿名对象。

没有; 总是在堆栈上创建的具有未知类型的C ++对象。无捕获的lambda可以转换成一个函数指针（尽管它是否适合C调用约定依赖于实现），但这并不意味着它是 a函数指针。

当必须从函数返回值闭包时，将其包装在std :: function中。在这种情况下闭包内存会发生什么？

lambda在C ++ 11中并不特别。这是一个像任何其他对象一样的对象。 lambda表达式导致临时，可用于初始化堆栈上的变量：

auto lamb = []() {return 5;};

lamb是一个堆栈对象。它有一个构造函数和析构函数。它将遵循所有C ++规则。 lamb的类型将包含捕获的值/引用;它们将成为该对象的成员，就像任何其他类型的任何其他对象成员一样。

您可以将其提供给std::function：

auto func_lamb = std::function<int()>(lamb);

在这种情况下，它将获得值为lamb的副本。如果lamb按值获取了任何内容，则会有两个这些值的副本; lamb中的一个，func_lamb中的一个。

当前范围结束时，根据清理堆栈变量的规则，func_lamb将被销毁，然后是lamb。

您可以轻松地在堆上分配一个：

auto func_lamb_ptr = new std::function<int()>(lamb);

std::function内容的内存完全取决于实现，但std::function使用的类型擦除通常至少需要一次内存分配。这就是std::function的构造函数可以使用分配器的原因。

每当释放std :: function时它是否被释放，即它是否像std :: shared_ptr一样被引用计数？

std::function存储其内容的副本。与几乎所有标准库C ++类型一样，function使用值语义。因此，它是可复制的;复制时，新的function对象是完全独立的。它也是可移动的，因此任何内部分配都可以适当地传输，而无需更多的分配和复制。

因此不需要引用计数。

你声明的其他所有内容都是正确的，假设“内存分配”等同于“在实时代码中使用不好”。

Answer 2

C ++ lambda只是带有重载operator()的（匿名）Functor类的语法糖，而std::function只是可调用对象（即函子，lambda，c函数等）的包装。从当前堆栈作用域按值复制“固态Lambda对象”-堆。

为了测试实际构造函数/重定位的数量，我进行了测试（使用另一层包装到shared_ptr的包装，但情况并非如此）。亲自看看：

#include <memory>
#include <string>
#include <iostream>

class Functor {
    std::string greeting;
public:

    Functor(const Functor &rhs) {
        this->greeting = rhs.greeting;
        std::cout << "Copy-Ctor \n";
    }
    Functor(std::string _greeting="Hello!"): greeting { _greeting } {
        std::cout << "Ctor \n";
    }

    Functor & operator=(const Functor & rhs) {
        greeting = rhs.greeting;
        std::cout << "Copy-assigned\n";
        return *this;
    }

    virtual ~Functor() {
        std::cout << "Dtor\n";
    }

    void operator()()
    {
        std::cout << "hey" << "\n";
    }
};

auto getFpp() {
    std::shared_ptr<std::function<void()>> fp = std::make_shared<std::function<void()>>(Functor{}
    );
    (*fp)();
    return fp;
}

int main() {
    auto f = getFpp();
    (*f)();
}

它产生以下输出：

Ctor 
Copy-Ctor 
Copy-Ctor 
Dtor
Dtor
hey
hey
Dtor

将为堆栈分配的lambda对象调用完全相同的一组ctor / dtor！（现在，它调用Ctor进行堆栈分配，使用Copy-ctor（+堆分配）在std :: function中构造它，并调用另一个用于进行shared_ptr堆分配+函数的构造）

C ++ 11 lambda实现和内存模型

2 个答案: