¿Tenemos cierres en C++?

Question

Estaba leyendo sobre cierres en la red. Me preguntaba si C++ tiene una instalación in-build para cierres o 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 nombrados lambdas.

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

Answer 3

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

Answer 4

Si usted entiende el cierre como una referencia a una función que tiene un contexto integrado, persistente, oculto y unseparable (memoria, estado), que 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; 

la próxima uno 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; 

No se puede hacer referencia (acceso) al estado interno 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, ...,.

El cierre significa que no contiene variables libres: es comparable a una clase con solo atributos privados y solo método (s) público (s).

Answer 5

Sí, muestra cómo podría implementar una función con un estado sin utilizar 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 
} 

me olvidó la palabra clave mutable que introdujo un comportamiento indefinido (versión ruido metálico regresaba un valor de basura). Tal como está implementado, el cierre funciona bien (en GCC y clang)