C++闭包，一样很简单

引用百度上对闭包的定义：闭包是指可以包含自由（未绑定到特定对象）变量的代码块；这些变量不是在这个代码块内或者任何全局上下文中定义的，而是在定义代码块的环境中定义（局部变量）。“闭包” 一词来源于以下两者的结合：要执行的代码块（由于自由变量被包含在代码块中，这些自由变量以及它们引用的对象没有被释放）和为自由变量提供绑定的计算环境（作用域）。在PHP、Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、 Python、Go、Lua、objective c、swift 以及Java（Java8及以上）等语言中都能找到对闭包不同程度的支持。 
那，C++难道不支持闭包吗？ 非也！

C++闭包

有了C++14的支持，实现闭包还是轻而易举的！

#include <functional>
#include <iostream>
#include <vector>
using namespace std;

auto foo(int bar)
{
    const char t = 'A' + bar;
    return [=](int b)->char {
        const char res = t + b;
        return res;     
    };
}

int main(int argc, char * argv[])
{
    const int tests = 8;
    //产生8个闭包
    vector<function<char(int)> > vec_closures;
    for (int i = 0; i < tests; ++i)
        vec_closures.push_back(foo(i));
    //多线程集中调用
#pragma omp parallel for
    for (int i = 0; i < tests; ++i)
    {
        const char res = vec_closures[i](i + 1);
        cout <<  res;
    }
    cout << endl;
    //单线程集中调用
    for (int i = 0; i < tests; ++i)
    {
        const char res = vec_closures[i](i + 1);
        cout << res;
    }
    cout << endl;
    return 0;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38

上面的代码中，在函数foo里创建了一个调用，使用值捕获局部变量。到主函数里，分别以多线程和单线程的模式调用10次。输出：

BFDJLNHP
BDFHJLNP
请按任意键继续. . .

• 1
• 2
• 3

不过注意了，这里的lambada表达式采用的是[=]值捕获。如果采用引用捕获，会如何呢？

auto foo(int bar)
{
    const char t = 'A' + bar;
    return [&](int b)->char {
        const char res = t + b;
        return res;     
    };
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

输出乱码。 
究其原因，应该是采用引用捕获时，由于函数foo并不在当前堆栈的 
执行链上，对局部变量t的引用也就非法了。我们看看堆栈：

>   cpp_closure.exe!foo::__l2::<lambda>(int b) 行 10 C++
    cpp_closure.exe!std::_Invoker_functor::_Call<char <lambda>(int) &,int>(foo::__l2::char <lambda>(int) & _Obj, int && <_Args_0>) 行 1534   C++
    cpp_closure.exe!std::invoke<char <lambda>(int) &,int>(foo::__l2::char <lambda>(int) & _Obj, int && <_Args_0>) 行 1534    C++
    cpp_closure.exe!std::_Invoker_ret<char,0>::_Call<char <lambda>(int) &,int>(foo::__l2::char <lambda>(int) & <_Vals_0>, int && <_Vals_1>) 行 1569  C++
    cpp_closure.exe!std::_Func_impl<char <lambda>(int),std::allocator<int>,char,int>::_Do_call(int && <_Args_0>) 行 211  C++
    cpp_closure.exe!std::_Func_class<char,int>::operator()(int <_Args_0>) 行 277 C++
    cpp_closure.exe!main$omp$1() 行 25   C++

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

里面就没有对函数 foo的压栈记录。

*编译器：Microsoft Visual Studio 2017

实现一个计数器

由于C++不支持命名函数的嵌套定义，使得实现类似JS计数器的闭包用法无法实现。但也不代表完全无法进行。比如下面的玩法：

#include <functional>
#include <iostream>
#include <vector>
#include <unordered_map>
#include <string>
#include <memory>
using namespace std;

auto gounter(int initial)
{
    shared_ptr<int> pct(new int{ initial });
    unordered_map<string, function<int()> > functions;
    functions["reset"] = [=]()->int {
        *pct = initial;
        return *pct;
    };
    functions["next"] = [=]()->int {
        return (*pct)++;
    };
    return functions;
}

int main(int argc, char * argv[])
{
    auto counter_a = gounter(10);
    auto counter_b = gounter(100);
    cout << counter_a["next"]()<<endl;
    cout << counter_a["next"]() << endl;
    cout << counter_b["next"]() << endl;
    cout << counter_b["next"]() << endl;
    counter_a["reset"]();
    cout << counter_a["next"]() << endl;
    cout << counter_b["next"]() << endl;
    return 0;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35

输出：

10
11
100
101
10
102

• 1
• 2
• 3
• 4
• 5
• 6

局限

C++为静态语言，使用任何手段模拟动态功能，都意味着性能损失。一味的追求语法方便，与性能上的折中是矛盾的。当然了，这也是城会玩的乐趣所在！

http://blog.csdn.net/goldenhawking/article/details/70589476