c++中有闭包吗?

I was reading about closures on the net. I was wondering if C++ has a built-in facility for closures or if there is any way we can implement closures in C++?

我在网上看到了关于闭包的消息。我想知道c++是否有一个内置的闭包功能，或者我们是否有办法在c++中实现闭包?

5 个解决方案

#1

The latest C++ standard, C++11, has closures.

最新的c++标准c++ 11有闭包。

http://en.wikipedia.org/wiki/C%2B%2B11#Lambda_functions_and_expressions

http://en.wikipedia.org/wiki/C%2B%2B11 Lambda_functions_and_expressions

http://www.cprogramming.com/c++11/c++11-lambda-closures.html

11 / c++ 11-lambda-closures.html http://www.cprogramming.com/c + +

#2

If you understand closure as a reference to a function that has an embedded, persistent, hidden and unseparable context (memory, state), than yes:

如果您将闭包理解为对具有嵌入式、持久、隐藏和不可分离上下文(内存、状态)的函数的引用，则可以:

class add_offset {
private:
    int offset;
public:
    add_offset(int _offset) : offset(_offset) {}
    int operator () (int x) { return x + offset; }
}

// make a closure
add_offset my_add_3_closure(3);

// use cloure
int x = 4;
int y = my_add_3_closure(x);
std::cout << y << std::endl;

the next one modifies its state:

下一个修改它的状态:

class summer
{
private:
    int sum;
public:
    summer() : sum(0) {}
    int operator () (int x) { return sum += x; }
}

// make a closure
summer adder;
// use closure
adder(3);
adder(4);
std::cout << adder(0) << std::endl;

The inner state can not be referenced (accessed) from outside.

内部状态不能从外部引用(访问)。

Depending on how you define it, a closure can contain a reference to more than one function or, two closures can share the same context, i.e. two functions can share the same persistent, ..., state.

取决于您如何定义它，闭包可以包含对多个函数的引用，或者两个闭包可以共享相同的上下文，例如两个函数可以共享相同的持久性，……,状态。

Closure means not containing free variables - it is comparable to a class with only private attributes and only public method(s).

闭包意味着不包含*变量——它与只具有私有属性和公共方法的类相当。

#3

Yes, This shows how you could implement a function with a state without using a functor.

是的，这展示了如何在不使用函数器的情况下实现具有状态的函数。

#include <iostream>
#include <functional>


std::function<int()> make_my_closure(int x){
    return [x]() mutable {   
        ++x;
        return x;   
    };
}

int main()
{
    auto my_f = make_my_closure(10);

    std::cout << my_f() << std::endl; // 11
    std::cout << my_f() << std::endl; // 12
    std::cout << my_f() << std::endl; // 13

     auto my_f1 = make_my_closure(1);

    std::cout << my_f1() << std::endl; // 2
    std::cout << my_f1() << std::endl; // 3
    std::cout << my_f1() << std::endl; // 4

    std::cout << my_f() << std::endl; // 14
}

I forgot the mutable keyword which introduced an undefined behaviour (clang version was returning a garbage value). As implemented, the closure works fine (on GCC and clang)

我忘记了可变关键字，它引入了一个未定义的行为(clang版本返回的是一个垃圾值)。按照实施，关闭工作正常(在GCC和clang上)

#4

Yes, C++11 has closures named lambdas.

是的，c++ 11有名为lambdas的闭包。

In C++03 there is no built-in support for lambdas, but there is Boost.Lambda implementation.

在c++ 03中，没有对lambdas的内置支持，但是有Boost。λ的实现。

#5

I suspect that it depends on what you mean by closure. The meaning I've always used implies garbage collection of some sort (although I think it could be implemented using reference counting); unlike lambdas in other languages, which capture references and keep the referenced object alive, C++ lambdas either capture a value, or the object refered to is not kept alive (and the reference can easily dangle).

我怀疑这取决于你所说的封闭。我一直使用的含义意味着某种垃圾收集(尽管我认为可以使用引用计数实现);与其他语言中的lambdas不同，lambdas可以捕获引用并保持引用对象处于活动状态，c++ lambdas可以捕获一个值，或者引用的对象没有保持活动状态(引用很容易被悬挂)。

#1