c++ - what - que son los closures en programacion

¿Tenemos cierres en C++?

Question

Estaba leyendo sobre cierres en la red. Me preguntaba si C ++ tiene una función integrada para cierres o si hay alguna manera de implementar cierres en C ++.

Answer 1

El último estándar de C ++, C++11 , tiene cierres.

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

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

Answer 2

Sí, C ++ 11 tiene cierres llamados en.cppreference.com/w/cpp/language/lambda .

En C ++ 03 no hay soporte incorporado para lambdas, pero hay implementación de Boost.Lambda .

Answer 3

Sí, esto muestra cómo podría implementar una función con un estado sin usar un funtor.

#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
}

Olvidé la palabra clave mutable que introdujo un comportamiento indefinido (la versión de clang devolvía un valor de basura). Según se implementó, el cierre funciona bien (en GCC y clang)

Answer 4

Si entiende el cierre como una referencia a una función que tiene un contexto incrustado, persistente, oculto e inseparable (memoria, estado), entonces sí:

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;

el siguiente modifica su estado:

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;

El estado interno no se puede referenciar (acceder) desde afuera.

Dependiendo de cómo lo defina, un cierre puede contener una referencia a más de una función o dos cierres pueden compartir el mismo contexto, es decir, dos funciones pueden compartir el mismo estado persistente, ...,.

Cierre significa que no contiene variables libres: es comparable a una clase con atributos privados y solo métodos públicos.

Answer 5

Sospecho que depende de lo que quiere decir con el cierre. El significado que siempre he utilizado implica la recolección de basura de algún tipo (aunque creo que podría implementarse usando el recuento de referencias); a diferencia de lambdas en otros idiomas, que capturan referencias y mantienen vivo el objeto al que se hace referencia, C ++ lambdas captura un valor, o el objeto al que se hace referencia no se mantiene vivo (y la referencia puede colgarse fácilmente).