[C/C++11語法]_[0基礎]_[lamba 表達式介紹]

時間  2019-12-06
標籤 c++11 語法 基礎 lamba 表達式 介紹 欄目 C&C++ 简体版
原文   原文鏈接

場景

  1. lambda 表達式在很是多語言裏都有一席之地,因爲它的緣由,可以在函數裏高速定義一個便攜的函數,或者在函數參數裏直接高速構造和傳遞.
  2. 它可以說是匿名函數對象,通常僅僅適用於某個函數內,僅僅作暫時使用.
  3. 一般是需要在對某個數據暫時特殊處理時使用,比方對某種參數類型進行限定的再次封裝和行爲約束.

參考

1. C# Lambda表達式及其優點
2. Lambda Expressions in C++
3. Exception Specifications (throw) (C++)
4. noexcept (C++)
5. what-is-the-lifetime-of-a-c-lambda-expressionios

說明

  1. lambda 語法.
    圖1:
    microsoft的圖片

Capture Clause(捕抓條款)組合:

規則1:

[] : 空捕抓條款,代表 lambda body 不訪問閉合範圍(enclosing scope)的不論什麼變量.
[&] : 以引用的方式訪問閉合範圍內的前面已聲明變量.
[=] : 以值的方式訪問閉合範圍內的前面已聲明的變量.
[this] : 訪問類實例的this指針.express

規則2

  • &,=,this 默認類型不能同一時候聲明
  • 一樣類型的捕抓不能和默認類型同一時候聲明,比方[&,&i] // 編譯錯誤
  • 不一樣樣類型的非默認類型可以同一時候聲明.比方[&i,j]
  • 對同一個變量不能捕抓屢次或者同一時候以不一樣捕抓方式聲明. [&i,&i] [&i,i]

Parameter List(參數列表)

  1. 和捕抓列表不同,lambda可以輸入參數,普通狀況下參數是爲了和 C++ 函數轉換才需要.
  2. 也可以使用 lambda 表達式做爲參數.
  3. 在C++14裏, 假設使用的是泛型參數,那麼你可以使用 auto 聲明.
auto y = [] (auto first, auto second)
{
 return first + second;
};

Mutable Specification(Mutable關鍵字)

  1. 可以使用mutable來改動捕抓條款裏聲明的傳值變量, 注意僅僅是至關於聲明瞭一個本地的mutable變量做爲暫時變量而已,並不會改動enclosing scope 變量範圍的值. 看 樣例1

Exception Specification(異常規範)

  1. 可以使用throw()來聲明這個lambda 不拋出C++異常. 但是在C++11裏這樣的使用方式已經被廢棄.

Return Type(返回類型)

  1. vs2010 必須聲明返回類型.
  2. gcc 可以不聲明返回類型,但是body 裏必須有能推導的 return 表達式類型.

其它

  1. 參考C++14 lambda Expression 的說明.

lambda 和 C++普通函數的轉換.

  1. 依據C++14 lambda表達式條款6, lambda 可以轉換爲C++函數, 但是必須知足下面的轉化條件,而且僅僅能轉換爲閉包類型自帶的特定類型的函數, 閉包類型自帶了一個函數指針?

    .
    The closure type for a non-generic lambda-expression with no lambda-capture has a public non-virtual non-
    explicit const conversion function to pointer to function with C ++ language linkage (7.5) having the same
    parameter and return types as the closure type’s function call operator.markdown

– 轉換前的 lambda 條件:
1. 非泛型.
2. 沒有捕抓列表(即沒有捕抓不論什麼變量)多線程

– 轉換後的 函數
1. 同參數.
2. 一樣返回類型.
3. 非虛擬
4. 非顯式常量.(non-explicit const)閉包

樣例

樣例1

  1. lambda 在STL裏的使用場景.
  2. 因爲vs2010 並不支持lambda 到 C++ 函數的轉換,因此並不能經過編譯.
  3. mutable 的做用.

vs2010app

#include "stdafx.h"
#include <memory>
#include <Windows.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
#include <regex>

class B
{
public:
    B(int value):two("B")
    {
        one = value;
        std::cout << "B" << std::endl;
    }
    ~B(){two.clear(); std::cout << "~B" << std::endl;}
    int one;
    std::string two;
};

void TestSort()
{
    std::cout << "TestSort" << std::endl;
    // 2010也不支持高速枚舉. for(B* b: bs)
    // 建立10個對象

    std::vector<B*> bs(10);
    int value = 0;
    std::generate(bs.begin(),bs.end(),[&value]()->B*
    {
        B* b = new B(++value);
        return b;
    });

    // 搜索奇數的對象
    std::vector<B*> bs2;
    std::for_each(bs.begin(),bs.end(),[&bs2](B* b)
    {
        if(b->one % 2)
        {
            bs2.push_back(b);
        }
    });

    // 排序以前是升序.
    std::cout << "Before Sort ==" << std::endl;
    std::for_each(bs2.begin(),bs2.end(),[](B* b)
    {
        std::cout << b->one << std::endl;
    });

    // 降序排列
    std::cout << "After Sort ==" << std::endl;
    std::sort(bs2.begin(),bs2.end(),[](B* first,B* second)
    {
        return first->one > second->one;
    });

    std::for_each(bs2.begin(),bs2.end(),[](B* b)
    {
        std::cout << b->one << std::endl;
    });
}

typedef void (*FUNC)();
void Foo(FUNC func)
{
    func();
}

void TestLambdaAsync()
{
    std::cout << "TestLambdaAsync ==" << std::endl;
    //2010 不支持lambda轉換爲FUNC,它僅僅能用於template裏的實現;需要vs2012以上才支持.vs2010支持lambda到FUNC的轉換.
    // 這樣就可以直接在 CreateThread裏使用 lambda.
    //g++ 4.8.1 可以.
    // Foo([](){std::cout << "lambda" << std::endl;});
    // 錯誤 2 error C2664: 「Foo」: 不能將參數 1 從「`anonymous-namespace'::<lambda6>」轉換爲「FUNC」
}


void TestMutable()
{
   std::cout << "TestMutable==========" << std::endl;
   int m = 0;
   int n = 0;


   //去掉mutable會出現編譯錯誤.Error:表達式必須是可以改動的左值.
   // mutable 做用之中的一個就是省略掉本地變量的定義.
   // [&, n] (int a){ int n1 = n; m = ++n1 + a; }(4);

   [&, n] (int a)mutable{m = ++n + a; }(4);
   std::cout << m << std::endl << n << std::endl;
}

class Base
{
public:
  virtual ~Base() {}
  virtual int call( float ) =0;
};

template< typename T>
class Eraser : public Base
{
public:
   Eraser( T t ) : m_t(t) { }
   int call( float f ) { return m_t(f); }
private:
   T m_t;
};

class Erased
{
public:
   template<typename T>
   Erased( T t ) : m_erased( new Eraser<T>(t) ) { }

   int do_call( float f )
   {
      return m_erased->call( f );
   }
private:
   Base* m_erased;
};

template<typename FUNC>
class A1
{
public:
    A1(FUNC func):func_(func){}
    void Run()
    {
        func_();
    }
    FUNC func_;
private:
};

Erased* GetErased()
{
    int i = 9;
    Erased *e_useful = new Erased( [i]( float f ) mutable ->int
    { 
        std::cout << ++i << std::endl;
        return 42; 
    } );
    return e_useful;
}

int main(int argc, char const *argv[])
{
    TestSort();
    TestMutable();

    int i = 0;
    auto func1 = [i]()mutable
    {
        std::cout << "A: " << ++i << std::endl;
    };
    A1<decltype(func1)> a(func1);
    a.Run();

    Erased* e_useful = GetErased();
    e_useful->do_call(9);

    return 0;
}

輸出:函數

TestSort
B
B
B
B
B
B
B
B
B
B
Before Sort ==
1
3
5
7
9
After Sort ==
9
7
5
3
1
TestMutable==========
5
0
A: 1
10

樣例2

  1. 使用了lambda 做爲 pthread 的回調函數.
  2. 多線程下使用 shared_ptr 的方法.

gcc 4.8.1post

// function_lambda_expression.cpp
// compile with: /EHsc /W4
#include <Windows.h>
#include <algorithm>
#include <iostream>
#include <vector>
#include <memory>
#include <string>
#include <string.h>
#include "pthread.h"

class A
{
public:
    A()
    {
        std::cout << "A" << std::endl;
        buf_ = (char*)malloc(6);
        strcpy(buf_,"hello");
    }
    ~A()
    {
        free(buf_);
        buf_ = NULL;
        std::cout << "~A" << std::endl;
    }
    char* buf_;
    /* data */
};

// g++ 4.8.1 支持lambda函數到普通函數的轉換,但是有條件,不支持capture(推理)
// 查看C++14規範第6條款關於lambda表達式和普通C++函數的轉換關係.
// 傳遞共享指針,多線程共享變量樣例.
void TestLambdaAsync(std::shared_ptr<A>& a1)
{
    std::cout << "Begin a1.use_count: " << a1.use_count() << std::endl;
    pthread_t t1;
    std::shared_ptr<A>* a = new std::shared_ptr<A>(a1);
    std::cout << "After a1.use_count: " << a1.use_count() << std::endl;

    // 假設是C函數指針做爲參數,那麼lambda也不能捕抓不論什麼變量,如[&a],否則會報錯.
    // error: cannot convert 'TestLambdaAsync()::__lambda0' to 'void* (*)(void*)' for argument '3' to 'int pthread_create(pthread_t*, pthread_attr_t_* const*, void* (*)(void*), void*)'},NULL);
    pthread_create(&t1,NULL,[](void* data)->void*
    {
        std::shared_ptr<A>* a = reinterpret_cast<std::shared_ptr<A>*>(data);
        std::cout << "pthread_create: " << (*a)->buf_ << std::endl;

        delete a;
        return NULL;
    },a);
}

int main()
{
    std::cout << "Start ==" << std::endl;
    std::shared_ptr<A> a(new A());

    for (int i = 0; i < 10; ++i)
    {
        TestLambdaAsync(a);
    }



    while(a.use_count() > 1)
    {
        std::cout << "Sleep" << std::endl;
        Sleep(1);
    }

    std::cout << "Exit ==" << std::endl;
}

輸出:ui

Start ==
A
Begin a1.use_count: 1
After a1.use_count: 2
Begin a1.use_count: 2
After a1.use_count: 3
Begin a1.use_count: 3
After a1.use_count: 4
pthread_create: hello
Begin a1.use_count: 3
After a1.use_count: 4
pthread_create: hello
pthread_create: hello
Begin a1.use_count: 2
After a1.use_count: 3
pthread_create: hello
Begin a1.use_count: 3
After a1.use_count: 3
Begin a1.use_count: 3
After a1.use_count: 4
pthread_create: hello
Begin a1.use_count: 3
After a1.use_count: 4
pthread_create: hello
Begin a1.use_count: 3
After a1.use_count: 4
pthread_create: hello
pthread_create: hello
Begin a1.use_count: 2
After a1.use_count: 3
pthread_create: hello
Sleep
pthread_create: hello
Exit ==
~A
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程