C++11 lambda表达式在for_each和transform算法下的使用

时间：2019-09-03 11:07:01

关键字： c++ c++11

手机看文章

扫描二维码
随时随地手机看文章

[导读]以前，在lambda表达式没有进入标准的时候，对容器的遍历等涉及到使用函数指针的情况，一般人会懒得使用std::for_each，或std::transform，也许只是一个短短的几句话，却要单独写个

以前，在lambda表达式没有进入标准的时候，对容器的遍历等涉及到使用函数指针的情况，一般人会懒得使用std::for_each，或std::transform，也许只是一个短短的几句话，却要单独写个函数，或函数对象，写的代码反而不如自己用for循环来的快。
但是，C++11引入了lambda表达式后，一切都变的简单了！

1.lambda表达式 lambda表达式是一个匿名函数，用它可以非常方便的表示一个函数对象，先简单说一下lambda表达式，下面这张图表示了C++11中lambda表达式的写法

Lambda表达式的引入标志，在‘[]’里面可以填入‘=’或‘&’表示该lambda表达式“捕获”（lambda表达式在一定的scope可以访问的数据）的数据时以什么方式捕获的，‘&’表示一引用的方式；‘=’表明以值传递的方式捕获，除非专门指出。

Lambda表达式的参数列表

Mutable 标识（可以没有）

异常标识（可以没有）

返回值，如果没有，可以不写

“函数”体，也就是lambda表达式需要进行的实际操作

下面看看几个lambda表达式的例子

void print(int a){……}

上面函数lambda表达式为:

[](int a){……}

上面这个是无返回值的例子，下面这个是有返回值的例子

int add(int a,int b){……}

上面函数lambda表达式为：

[](int a,int b)->int{……}

当需要引入其他变量的时候，如有个类的成员变量需要引用或者函数局部变量这种情况下可以显示声明需要引入的变量
如成员变量:
double m_result;
函数：

void foo(int a,double b)
{
    ……
    use(m_result);
}

其lambda表达式可以表示为

[m_result](int a,int b){……use(m_result);}

如果lambda表达式需要修改m_result的值，可以以引用方式传递进去

[&m_result](int a,int b){……m_result = 12.1;……}

如果要传入的参数很多，或者干脆在这个作用域里的所有参数都想用到，可以直接在中括号里使用”=“或”&“ 如下例子，g_bb为一个全局变量，fun3的lambda表达式把所有内容以引用方式传入：

double g_bb = 11.2;
void foo1()
{
    auto f_add = [&](int a,int b)->int{return a+b;};
    std::cout<double{return aa+3;};//此时aa不能进行赋值操作如：aa=7;
    std::cout<double{aa = 7.0;return aa+3;};//此时aa以引用方式传入，可以进行赋值操作如：aa=7,同时修改aa的值;
    std::cout<double{aa = 8.0;g_bb = 15;return aa+3;};//此时aa可以进行赋值操作如：aa=7;,其他在作用域范围的变量都可以以引用方式调用
    std::cout<

输出：


3
8  aa:5
10  aa:7
11  aa:8 g_bb:15

一般也是以这种方式来写[&]，简单明了。

lambda表达式先说到这后面在讲std::for_each和std::transform时会有更多例子。
2.std::foreach
std::foreach是很经典的算法，但是由于需要用到函数对象，有时候还不如直接for循环方便（暂且不讨论for循环的新表达式写法，目前没多少个编译器支持），例如我有个vector,我要打印出来看看里面有什么内容，经常下意识的就直接成:

std ::vector v ;
v . push_back ( 3);
v . push_back ( 1. 666);
v . push_back ( 4. 5);
v . push_back ( 6. 7);
for( std ::vector ::iterator i =v . begin (); i !=v . end (); ++i )
{
    std ::cout <<*i <<",";
}

std :: vector < double >:: iterator是多么的碍眼的。
还好，C++11把auto升了级，上面那个代码会变成

for( autoi =v . begin (); i !=v . end (); ++i )

用std::foreach(),上面这个就变成


std ::for_each ( v . begin (), v . end (),[ &]( double d ){ std ::cout <

于是，以后凡是要遍历容器，且代码不太长，都可以使用std::foreach加lambda表达式方便实现


为了方便下面的演示，编写一个打印容器内容的函数printElement
template
void printElement(Container& v)
{
    std::cout<<"(";
    for(auto i = v.begin();i != v.end();++i)
    {
        std::cout<<*i;
        if(i != v.end() - 1)
            std::cout<<",";
    }
    std::cout<<")";
    std::cout<

可以输出序列的内容，如vector内容为（1,2,3,4,5），输出：（1,2,3,4,5）
3.std::transform


当涉及到两个或三个容器的操作，就需要使用std::transform操作
transform有两个重载版本
template 
  OutputIterator transform (InputIterator first1, InputIterator last1,
                            OutputIterator result, UnaryOperation op);

原理如下图所示：





template ;
OutputIterator transform (InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, OutputIterator result,
                            BinaryOperation binary_op);
原理如下图所示：





如需要求序列a的log，结果存入c

//求a的log存入c
    a.clear();b.clear();c.clear();
    for(auto i(1);i<10;++i){
        a.push_back(i);
    }

    std::transform(a.begin(),a.end(),std::back_inserter(c),[](double d)->double{return log(d);});
    std::cout<<"a:";
    printElement(a);//
    std::cout<<"c:";
    printElement(c);//(0,0.693147,1.09861,1.38629,1.60944,1.79176,1.94591,2.07944,2.19722)



如果对a序列求log并直接把结果存入a中的话有两种方法
方法1：使用（transform）
 std::cout<<"a=log(a):"<double{return log(d);});
    std::cout<<"after a:";
    printElement(a);//(0,0.693147,1.09861,1.38629,1.60944,1.79176,1.94591,2.07944,2.19722)
输出：

a=log(a):
a:(1,2,3,4,5,6,7,8,9)
after a:(0,0.693147,1.09861,1.38629,1.60944,1.79176,1.94591,2.07944,2.19722)

方法2：使用（for_each）


std::cout<<"a=log(a):"<

输出：


a=log(a):
a:(1,2,3,4,5,6,7,8,9)
after a:(0,0.693147,1.09861,1.38629,1.60944,1.79176,1.94591,2.07944,2.19722)
这里，for_each的操作函数以引用方式传入，因此可以实现对自身元素的修改。
从这里可以看出，std::transform是可以实现std::for_each的功能的，也就是说std::transform是std::for_each的扩展


如两个vectorV,W要进行某个运算，如计算U = sin（V） + W，结果存入U；
 
std ::vector v , w , u ;
v . push_back ( 3);
v . push_back ( 1.666);
v . push_back ( 4.5);
v . push_back ( 6.7);
w . push_back ( 3);
w . push_back ( 1.666);
w . push_back ( 4.5);
w . push_back ( 6.7);
for( autoi =v . begin (), j =w . begin (), k =u . begin (); i !=v . end (), j !=w . end (), k !=u . end ();++i ,++j ,++k )
{
    *k =sin (*i )+*j ;
}

幸好还有auto，要不然，呵呵……
transform的表达形式如下
std ::transform ( v . begin (), v . end (), w . begin (), u . begin () ,[&]( double a , double b )->double{
return sin ( a )+b ;
} );


使用std::transform可以比较方便的实现序列容器的四则运算

stl提供了plus，multiplies，divides，modulus，negate等函数对象，方便实现加减乘除等运算，具体见：http://www.cplusplus.com/reference/functional/plus/

如实现两序列的加法运算，不必写lambda表达式，直接使用stl的std::plus即可，如：

实现vector A,B,计算C = A+B
    a.clear();
    b.clear();
    c.clear();
    for(int i(1);i<10;++i)
    {
       a.push_back(i);
       b.push_back(i*10);
    }
    std::cout<<"calc c=a+b:"<());
    std::cout<<"calc c=a+b -> c:";
    printElement(c);


输出：


calc c=a+b:
a:(1,2,3,4,5,6,7,8,9)
b:(10,20,30,40,50,60,70,80,90)
calc c=a+b -> c:(11,22,33,44,55,66,77,88,99)
代码：

#include 
#include 
#include 
#include 
#include 
#include "math.h"
double g_bb = 11.2;
void foo1()
{
    auto f_add = [&](int a,int b)->int{return a+b;};
    std::cout<double{return aa+3;};//此时aa不能进行赋值操作如：aa=7;
    std::cout<double{aa = 7.0;return aa+3;};//此时aa以引用方式传入，可以进行赋值操作如：aa=7,同时修改aa的值;
    std::cout<double{aa = 8.0;g_bb = 15;return aa+3;};//此时aa可以进行赋值操作如：aa=7;,其他在作用域范围的变量都可以以引用方式调用
    std::cout<
void printElement(Container& v)
{
    std::cout<<"(";
    for(auto i = v.begin();i != v.end();++i)
    {
        std::cout<<*i;
        if(i != v.end() - 1)
            std::cout<<",";
    }
    std::cout<<")";
    std::cout< a,b,c;
    a.push_back(3);
    a.push_back(1.666);
    a.push_back(4.5);
    a.push_back(6.7);
    b.push_back(3);
    b.push_back(1.666);
    b.push_back(4.5);
    b.push_back(6.7);
    for ( std :: vector < double >:: iterator i = a . begin (); i != a . end ();++ i )
    {
        std::cout<<*i<<",";//3,1.666,4.5,6.7,
    }
    std::cout<double{return sin(i)+j;});
    printElement(c);//(3.14112,2.66147,3.52247,7.10485)

    a.clear();b.clear();c.clear();
    for(auto i(1);i<10;++i){
        a.push_back(i);
    }
    //求a的log存入c
    std::cout<<"c=log(a):"<double{return log(d);});
    std::cout<<"c:";
    printElement(c);//(0,0.693147,1.09861,1.38629,1.60944,1.79176,1.94591,2.07944,2.19722)

    b = a;
    std::cout<<"a=log(a):"<double{return log(d);});
    std::cout<<"after a:";
    printElement(a);//(0,0.693147,1.09861,1.38629,1.60944,1.79176,1.94591,2.07944,2.19722)

    a = b;
    std::cout<<"a=log(a):"<());
    std::cout<<"calc c=a+b -> c:";
    printElement(c);

    return 0;
}


写上面这篇文章，主要是因为最近经常使用序列的四则运算，如vector a + vector b,或者进行一些稍微复杂的数学运算，自己封装了一些简化的用法，截取如下：

#define INPUT
#define OUTPUT
namespace Array {
///
/// brief 加一个常数的函数对象，类似于std::plus()，不过此函数对象是用于对一个常数进行加法运算
///
template  struct plus_const : std::binary_function  {
    plus_const(const T& data){m_data = data;}
  T operator() (const T& x) const {return x+m_data;}
  T m_data;
};

///
/// brief 序列加法运算，用于序列加上单一一个值
/// param begin 序列迭代器的起始
/// param end 序列迭代器的结尾
/// param beAddData 需要进行加法运算的值
/// note 此操作会直接修改原有序列值
///
template
void add(INPUT IT begin,INPUT IT end,T beAddData)
{
    std::transform(begin,end,begin,plus_const(beAddData));
}
///
/// brief 序列加法运算，两个等长序列相加
/// param begin_addfont “加数”序列迭代器的起始
/// param end_addfont “加数”序列迭代器的结尾
/// param begin_addend “被加数”序列迭代器的起始
/// param begin_res 用于存放结果的序列的起始地址
///
template
void add(INPUT IT begin_addfont,INPUT IT end_addfont,IT begin_addend,IT begin_res)
{
    std::transform(begin_addfont,end_addfont,begin_addend,begin_res
                   ,std::plus());
}
///
/// brief 序列减法运算，两个等长序列相减
/// param begin_addfont “加数”序列迭代器的起始
/// param end_addfont “加数”序列迭代器的结尾
/// param begin_addend “被加数”序列迭代器的起始
/// param begin_res 用于存放结果的序列的起始地址
///
template
void minus(INPUT IT begin_minusfont,INPUT IT end_minusfont,IT begin_minusend,IT begin_res)
{
    std::transform(begin_minusfont,end_minusfont,begin_minusend,begin_res
                   ,std::minus());
}
///
/// brief 序列减法运算，用于序列减去单一一个值
/// param begin 序列迭代器的起始
/// param end 序列迭代器的结尾
/// param beAddData 需要进行减法运算的值
/// note 此操作会直接修改原有序列值
///
template
void minus(INPUT IT begin,INPUT IT end,T beMinusData)
{
    std::transform(begin,end,begin,plus_const(-beMinusData));
}
……
}


                                
                    欲知详情，请下载word文档 下载文档

C++11 lambda表达式在for_each和transform算法下的使用

与传统的驱动方式相比，共阴恒流驱动在能效有哪些优势

工业电机驱动电源设计：反电动势抑制与过流保护的集成方案

如何解决 LED 驱动电源的易损坏问题

LED设计中LED驱动电源的公式

EV主驱IGBT隔离驱动电源方案选择问题探讨

合理的驱动电源方案成为大功率区域照明的主流选择

AC-DC电源转换拓扑结构设计

针对于LED照明驱动电源技术中的电磁干扰其中的三大硬件问题措施

LED驱动电源的核心部分“开关管”和“变换器”设计技巧

最全LED驱动电源及散热设计方案介绍

常用的LED驱动电源有哪些？工作原理是什么？

LED驱动电源的类型可分为有哪些？

解散全部员工！深圳又一电子大厂宣布停产结业

崧盛股份：大功率LED驱动电源行业门槛高，新进入者面临三大壁垒

关于LED驱动电源的分类以及特点解析，你了解吗？

你知道常见的LED驱动电源种类以及它们有哪些特点吗？

关于LED驱动电源特点以及在设计时需要注意的关键点

多路 LED 驱动电源技术的开发与可靠性研究分析

值得大家学习的LED驱动电源的特点以及工作原理概述

Cree宣布彻底告别LED和照明行业