vector<int> vec;    // 空向量
　　　　auto it = back_inserter(vec);     // 通过它赋值会将元素添加到vec中
　　　　*it = 42;   // vec中现在有一个元素，值为42
　　　　// 我们常常使用back_inserter来创建一个迭代器，作为算法的目的位置来使用
　　　　fill_n(back_inserter(vec), 10, 0);   // 添加10个元素到vec

　　　　// 比较函数，用来按长度排序单词
　　　　bool isShorter(const string &s1, const string &s2)
　　　　{
 　　　　   return s1.size() < s2.size();
　　　　}
　　　　// 按长度由短至长排序words
　　　　sort(words.begin(), words.end(), isShorter);

　　　　　　auto f = [] { return 42; };   // 定义了一个可调用对象f，它不接受参数，返回42
　　　　　　// lambda调用方式与普通函数调用方式一样，都是使用调用运算符
　　　　　　cout << f() << endl;  // 打印42

　　　　　　// 按长度排序
　　　　　　stable_sort(words.begin(), words.end(),
                  　　　　          [](const string &s1, const string &s2)
                 　　　　               { return s1.size() < s2.size(); }
　　　　　　//  lambda不能有默认实参
　　　　　　// 空捕获列表表明此lambda不使用它所在函数中的任何局部变量

　　　　　　[sz](const string &a) { return a.size() >= sz; };

　　　　　　// 获取一个迭代器，指向第一个满足size() >= sz 的元素，sz是一个局部变量
　　　　　　auto wc = find_if(words.begin(), words.end(),
                　　　　　　      　　         [sz](const string &a)
     　　           　　                        { return a.size() >= sz; });

　　　　　　// 打印长度大于等于给定值的单词，每个单词后面接一个空格
　　　　　　for_each(wc, words.end(), [] (const string &s)
 　　　　　　                                          { cout << s << " ";} );
　　　　　　cout << endl;
　　　　　　// 一个lambda可以直接使用定义在当前函数之外的的名字。
　　　　　　// cout不是定义在此代码所在局部作用域的中的局部名字，而是定义在头文件iostream中。
　　　　　　// 因此，只要包含了头文件iostream，就可以使用cout

　　　　　　// 值捕获方式，采用捕获的前提是变量可以拷贝
　　　　　　void fcnl()
　　　　　　{
  　　　　　　  size_t v1 = 42;      // 局部变量
 　　　　　　   // 将v1拷贝到名为f的可调用对象
　　　　　　    auto f = [v1]  { return v1; };
　　　　　　    v1 = 0;
  　　　　　　  auto j = f();   // j为42,；f保存了我们创建它时v1的拷贝
　　　　　　}  //       与参数不同，被捕获的变量的值是在lamba创建时拷贝，而不是调用时拷贝


　　　　　　// 引用捕获， 定义lambda时可以采用引用方式捕获变量
　　　　　　void fcn2()
　　　　　　{
  　　　　　　  size_t v1 = 42;   //  局部变量
  　　　　　　  // 对象f2包含v1的引用
　　　　　　    auto f2 = [&v1] { return v1; };
 　　　　　　   v1 = 0;
 　　　　　　   auto j = f2();    // j为0； f2保存v1的引用，而非拷贝
　　　　　　}

　　　　　　// sz 为隐式捕获，值捕获方式
　　　　　　wc = find_if(words.begin(), words.end(),
        　　　　                                   [=](const string &s)
                                                    { return s.size() >= sz;  } );
　　　　　　//  如果我们系统对一部分变量采用值捕获，对其他变量采用引用捕获，可以混合使用隐式捕获
　　　　　　//  和显示捕获
　　　　　　// os隐式捕获，引用捕获方式；   c显式捕获，值捕获方式
　　　　　　for_each(words.begin(), words.end(),
          　　　　                      [&, c](const string &s) { os << s << c; } );

　　　　　　// os显式捕获，引用捕获方式；  c隐式捕获，值捕获方式
　　　　　　for_each(words.begin(), words.end(), 
          　　　　　　                      [=, &os](const string &s) { os << s << c; } );
　　　　　　// 注意！！ 当我们混合使用隐式捕获和显式捕获时，捕获列表中的第一个元素必须是一个
　　　　　　//               &或=。此符号指定了默认捕获方式为引用或值。并且所有显式捕获方式必须
　　　　　　//               与默认捕获方式不同，放在&或=后面。