（转载）C++lambda表达式

（转载） http://www.cnblogs.com/L-hq815/archive/2012/08/23/2653002.html

lambda表达式

C++ 语言中的lambda表达式在不少状况下提供了函数对象的另外一种实现机制。Lambda表达式并非STL所特有的，但它普遍应用于这一环境中。Lambda是表达式是定义一个没有名称、也不须要显示类定义的函数对象。Lambda表达式通常做为一种手段，用来将函数做为实参传递到另外一个函数。相比于定义和建立一个常规的函数对象而言，lambda表达式很是容易使用和理解，并且须要的代码也较少。固然，通常而言，lambda表达式并不会取代函数对象。

举个例子，假设有个包含数值的矢量，咱们计算此矢量的立方值。能够用transform()函数操做，简单的用lambda表达式完成。

double  values[] = {1,2,3,4,5,6};
vector<double> data(values,values+6);
vector<double> cubes(data.size());
transform(values.begin(),values.end(),cubes.begin(),[](double x){ return x*x*x;});

最后这条语句用来计算data中的立方值，并存储在cubes。这里简单提一下transform()函数。它是algorithm头文件中的函数，它有两个版本。

第一个版本是将一个一元函数对象指定的操做应用到由一对迭代器指定的一个元素集合上，格式以下：

transform(InputIterator begin, InputIterator end, OutputIterator result,UnaryFuncton f);

transform()的这个版本将一元函数f应用到迭代器begin 和end指定的范围中的全部元素，并从迭代器result指定的位置开始存储结果。Result迭代器能够与begin迭代器相同，只是在这种状况下将会替换原有的内容。这个函数返回一个迭代器，指向存储的最后一个结果的下一个位置。

举例以下：

double  values[] = {1,2,3,4,5,6};
vector<double> data(values,values+6);
transform(values.begin(),values.end(),values.begin(),negate<double>);

transform()函数调用negate<double>函数对象应用到矢量data中的全部元素，结果存储在data中，并重写了原始值，执行完后data将包含 -1，-2，-3，-4，-5，-6。函数返回迭代器data.end()。

transform()第二个版本经过来自迭代器指定的两个范围内的操做数应用一个二元函数。格式为：

transform(InputIterator1 begin1, InputIterator 1end1, InputIterator2 begin2, OutputIterator result,BinaryFunction f);

由begin1和end1指定的范围表示最后一个实参指定的二元函数f的左操做数集合。表示右操做的范围从begin2迭代器指定的位置开始，这个范围不须要提供end迭代器，由于这个范围的元素数量必须与begin1和end1指定的范围元素个数相同，结果从result迭代器位置开始存储在这个范围内。若是但愿存回原范围中，result迭代器能够与begin1相同。

举例以下：

double values[]={2.5,-3.5,4.5,-5.5,6.5,-7.5};
vector<double> data(values, values + sizeof values / sizeof values[0]);
vector<double> squares(data.size());
transform(data.begin(),data.end(),data.begin(),squares.begin(),multiplies<double>());
ostream_iterator<double> out(cout,” “);
copy(squares.begin(),squares.end(),out);

Transform()函数经过multiplies<double>函数对象将自身相乘，结果存储到squares中。最后两句用一个输出迭代器输出内容。

如今回到上文：

transform(values.begin(),values.end(),cubes.begin(),[](double x){ return x*x*x;});

开始的方括号称为lambda引导，它标志着lambda表达式的开始。后面的圆括号中的是lambda的参数列表，这与普通函数相同。此例中只有一个形参x。注意，lambda的参数列表不容许指定形参的默认值，而且参数列表的长度是不可变的。大括号中的是lambda的主体，此例只有一条return语句，固然能够包含多条语句。你们可能注意到这里没有返回类型说明。当lambda表达式的主体是一条单一返回语句，而该语句在lambda表达式主体中返回一个值时，返回类型默认为返回值的类型。不然，返回void。固然能够指定返回类型，以下：

[](double x) ->double{ return x*x*x;} //指定返回double

Capture子句

lambda表达式引导能够包含一个捕获子句，用来肯定lambda主体如何访问封闭做用域中的变量。前面lambda表达式方括号之间没有内容，表面封闭做用域没有能够再lambda表达式中访问的变量。若要访问，第一种是方括号之间是 = ，则lambda主体能够按值访问封闭做用域的全部自动变量，但不会修改原始变量。另外一中是方括号之间是 & ，则封闭做用域的全部自动变量按应用访问，所以lambda表达式能够修改变量值。例如：

double index = 3.0;
double  values[] = {1,2,3,4,5,6};
vector<double> data(values,values+6);
vector<double> cubes(data.size());
transform(values.begin(),values.end(),cubes.begin(),
[=](double x){ return index*x*x*x;});

须要主要的是，这与按值传递实参根本不一样，变量index的值可用在lambda中，但不能更新index的副本。如：

transform(values.begin(),values.end(),cubes.begin(),
[=](double x) ->double{ 
index += 10; // error 
return index*x*x*x;});

以上是错误的，若要修改变量的临时副本，则经过添加mutable关键字实现。如：

transform(values.begin(),values.end(),cubes.begin(),
[=](double x)mutable ->double{ 
index += 10; // ok
return index*x*x*x;});

如今能够修改做用域中的任意变量副本，而不会修改原始值。

transform(values.begin(),values.end(),cubes.begin(),
[&](double x)mutable ->double{ 
index += 10; // change original value
return index*x*x*x;});

如今采用按引用使用，则会改变index的原始值。

若要捕获一个特定的变量，则：

transform(values.begin(),values.end(),cubes.begin(),
[&index](double x)mutable ->double{ 
index += 10; // change original value
return index*x*x*x;});

这样，只捕获index，如要捕获多个变量，中间用逗号隔开便可。

Lambda也能够包含throw()异常说明，如：

transform(values.begin(),values.end(),cubes.begin(),
[&index](double x)mutable throw()->double{ 
index += 10; // change original value
return index*x*x*x;});

若是想要包含mutable说明和throw()说明，则中间必须用一个或多个空格隔开。

如今综合看个实例，用之前说过的函数模板实现。

// Using lambda expressions
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <vector>
#include <ctime>
#include <cstdlib>
using namespace std; // Just to avoid a lot of using directives in the example...

// Template function to return the average of the elements in a vector
template <class T> T average(const vector<T>& vec)
{
    T sum(0);
    for_each(vec.begin(), vec.end(),
        [&sum](const T& value){ sum += value; });
    return sum/vec.size();
}

// Template function to set a vector to values beginning with start and incremented by increment
template <class T> void setValues(vector<T>& vec, T start, T increment)
{
    T current(start);
    generate(vec.begin(), vec.end(), 
        [increment, &current]()->T{T result(current);
    current += increment;
    return result;});
}

// Template function to set a vector to random values between min and max
template<class T> void randomValues(vector<T>& vec, T min, T max)
{
    srand(static_cast<unsigned int>(time(0)));   // Initialize random number generator
    generate(vec.begin(), vec.end(),
        [=](){ return static_cast<T>(static_cast<double>(rand())/RAND_MAX*(max-min)+min); });
}

// Template function to list the values in a vector
template<class T> void listVector(const vector<T>& vec)
{
    int count = 0;      // Used to control outputs per line
    for_each(vec.begin(), vec.end(),
        [&count](const T& n)->void{  cout << setw(10) << n;
    if(++count % 5)
        cout << "  ";
    else
        cout << endl;});
}

int main()
{
    vector<int> integerData(50);
    randomValues(integerData, 10, 100);    // Set random integer values
    cout << "Vector contains:" << endl;
    listVector(integerData);
    cout << "Average value is "<< average(integerData) << endl;

    vector<double> realData(20);
    setValues(realData, 5.0, 2.5);   // Set real values starting at 5.0 ,increment by 2.5
    cout << "Vector contains:" << endl;
    listVector(realData);
    cout << "Average value is "<< average(realData) << endl;

    return 0;
}

 

Lambda表达式的包装

Lambda表达式的包装其实是使用function< >模板赋予lambda表达式一个名字，这不只提供了在Lambda表达式内递归的可能，并且能够再多条语句使用一样的lambda表达式。如：

Function< int (double)> f = [](double x){ return static_cast<int>(x*x)};

这里具备一个double类型的形参，并返回一个为int类型的值，固然，此处只是举例而已，由于该语句存在问题，将double赋给int时可能会丢失数据。

举例：

#include <iostream>
#include <functional>
using std::function;
using std::cout;
using std::endl;
                        
int main()
{
  // Wrap the lambda expression to compute the HCF
  function<int(int,int)> hcf = [&](int m, int n) mutable ->int{ if(m < n) return hcf(n,m);
                                     int remainder(m%n);
                                     if(0 == remainder) return n;
                                     return hcf(n, remainder);};
  int a(17719), b(18879);
  cout << "For numbers " << a << " and " << b << " the HCF is " << hcf(a, b) << endl;
  a = 103*53*17*97;
  b = 3*29*103;
  cout << "For numbers " << a << " and " << b << " the HCF is " << hcf(a, b) << endl;

   return 0;
}

该实例用欧几里得法求两个数的最大公约数，即所谓展转相除法，采用递归形式实现。