lambda在C++中的运用(译stack overflow)

问题

c++中有类似std::for_each和std::transform的泛型函数(generic functions)使用起来非常方便.但仿函数运用在这种特殊的函数(即指上面的generic functions),却存在着问题,如下:

#include <algorithm>
#include <vector>

namespace {
  struct f {
    void operator()(int) {
      // do something
    }
  };
}

void func(std::vector<int>& v) {
  f f;
  std::for_each(v.begin(), v.end(), f);
}

如果在上例中,f作为一个函数只被使用一次,却定义了一个类来完成这个函数操作,是非常不合理的.(overkill)

在c++03中,你可能把仿函数写成一个局部变量.

void func2(std::vector<int>& v) {
  struct {
    void operator()(int) {
       // do something
    }
  } f;
  std::for_each(v.begin(), v.end(), f);
}

但是上面这样是不允许的,因为在c++03中f不能传给一个函数模板的.

新的解决方案:

c++11中引入lambda允许你把代码写入一个内联,匿名的仿函数中来替代上面提到的仿函数. 下面以一个例子来展开这种方式

void func3(std::vector<int>& v) {
  std::for_each(v.begin(), v.end(), [](int) { /* do something here*/ });
}

lambda函数是一种匿名函数的语法糖.

定义返回值类型

下面的例子引入一个简单的例子:

void func4(std::vector<double>& v) {
  std::transform(v.begin(), v.end(), v.begin(),
                 [](double d) { return d < 0.00001 ? 0 : d; }
                 );
}

当使用lambda函数会存在一个问题,就是返回值并不能被编译器所规约(deduced)"

void func4(std::vector<double>& v) {
    std::transform(v.begin(), v.end(), v.begin(),
        [](double d) {
            if (d < 0.0001) {
                return 0;
            } else {
                return d;
            }
        });
}

为了解决上面的问题允许我们通过在lambda函数中指定返回值,使用->T

"捕获"变量

还可以给lambda函数传递其他的变量.你可以使用捕获条款(capture clause)( [ ]表达式 ), 例如:

void func5(std::vector<double>& v, const double& epsilon) {
    std::transform(v.begin(), v.end(), v.begin(),
        [epsilon](double d) -> double {
            if (d < epsilon) {
                return 0;
            } else {
                return d;
            }
        });
}

你可以捕获引用和元素值, 它们可以使用&和 = 分别指定:

• [&epsilon] capture by reference
• [&] captures all variables used in the lambda by reference
• [=] captures all variables used in the lambda by value
• [&, epsilon] captures variables like with [&], but epsilon by value
• [=, &epsilon] captures variables like with [=], but epsilon by reference

接下来是自己程序代码

#include<iostream>
#include<algorithm>
#include<vector>
using namespace::std;

namespace n1{        
/*仿函数*/   
struct f
{
bool operator()(int a){
    if(a<20)
      cout<<a<<endl;
    }
};
//调用for_each
void functionc(vector<int>& vec){
    f f;   //定义仿函数对象
    for_each(vec.begin(), vec.end(), f); //调用仿函数
}
//lambda式子
void func1(vector<int>& vec){
    for_each(vec.begin(), vec.end(), [](int a){cout<<a<<endl;});
}

//返回值->int， 返回为int
void func2(vector<int>& vec)
{
   for_each(vec.begin(), vec.end(), [](int a)->int{   
   int count =0;
   if(a<10)
   {     
    cout<< a<<endl;
    count++;
    }
    else
     return -1;
    });
}
//通过[]传入变量
void func3(vector<int>& vec)
{
        int n = 20;
        for_each(vec.begin(), vec.end(), [ n](int a){
                        if(a<n)
                                cout<<a<<endl;
                        });
}
}

int main()
{
        vector<int> vec;
        vec.push_back(10);
        vec.push_back(20);
        vec.push_back(30);
        vec.push_back(3);
        vec.push_back(40);
        vec.push_back(14);
        //n1::func1(vec);
        //n1::functionc(vec);
        //n1::func2(vec);
        n1::func3(vec);
}

总结:lambda表达式为了弥补使用仿函数的复杂,功能上与仿函数一样,是泛型算法与容器之间的桥梁.

引用:https://stackoverflow.com/questions/7627098/what-is-a-lambda-expression-in-c11