Czy mamy zamknięcia w C++?

Question

Czytałem o zamknięciach w sieci. Zastanawiam się, czy C++ ma wbudowaną możliwość zamykania lub czy istnieje sposób, w jaki możemy zaimplementować zamknięcia w C++?

Answer 1

Najnowszy standard C++, C++11, ma zamknięcia.

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

Tak, C++ 11 ma zamknięcia nazwie lambdas.

W C++ 03 nie ma wbudowanej obsługi lambd, ale istnieje implementacja Boost.Lambda.

Answer 3

Podejrzewam, że to zależy od tego, co rozumiesz przez zamknięcie. Znaczenie, jakie mam zawsze używane, oznacza, że ​​jakiś rodzaj zbierania śmieci (chociaż myślę, że można go zaimplementować za pomocą liczenia odwołań); w przeciwieństwie do lambdów w innych językach , które przechwytują referencje i utrzymują przy życiu obiekt odniesienia, którym jest obiekt odniesienia, lub przechwytują wartość, lub obiekt, którego dotyczy, jest utrzymywany przy życiu (i odniesienie może łatwo zwisać).

Answer 4

Jeśli rozumiesz zamknięcie jako odniesienie do funkcji, która ma wbudowany, trwały, ukryte i nierozerwalna kontekst (pamięć, państwa), wtedy tak:

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; 

następny zmienia swój stan:

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; 

Stan wewnętrzny nie może być odwoływany (dostęp) z zewnątrz.

W zależności od tego, jak to zdefiniujesz, zamknięcie może zawierać odwołanie do więcej niż jednej funkcji lub dwie zamknięcia mogą współdzielić ten sam kontekst, tj. Dwie funkcje mogą współdzielić ten sam stały, ..., stan.

Zamknięcie oznacza niezawierające zmiennych wolnych - jest porównywalne z klasą zawierającą tylko prywatne atrybuty i tylko publiczne metody (metody).

Answer 5

Tak, to pokazuje, jak można zaimplementować funkcję ze stanem bez użycia funktora.

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

Zapomniałem zmiennego słowa kluczowego, które wprowadziło niezdefiniowane zachowanie (wersja klangowa zwróciła wartość śmieci). Zgodnie z wdrożeniem, zamknięcie działa poprawnie (na GCC i klang)