C++基础 - 函数指针和 lamdba 表达式

函数指针介绍

函数指针，可以作为一个参数传递到另一个函数中。基本语法如下：

data_types(*func_pointer)(data_type arg1,data_type arg2,....,data_type arg)
返回值类型(函数指针)(形参类型 形参)

例如 下面定义了一个 返回值为 string 的 combine 函数，第一个参数是 string 类型，第二参数则是一个函数指针，这个函数指针对应的函数，返回值为 string，函数指针名为fc，包含了string 类型的形参

//函数指针的定义格式
//data_types(*func_pointer)(data_type arg1,data_type arg2,....,data_type arg)
//返回值类型(函数指针)(形参类型 形参)
string combine(string s, string(*fc)(string content)) {
    return (*fc)(s);
}

细节的函数指针语法可以参考:C++ 函数指针 & 类成员函数指针

lambda 表达式介绍

根据 c++ 官网的介绍：

Constructs a closure: an unnamed function object capable of capturing variables in scope.

译者注：lambda 构造了一个匿名函数的简便方式，可以捕获可见范围内的变量

lambda 表达式的格式如下：

[capture list](params list)mutable exception -> return type (function body)
[捕获外部变量列表](形参列表)mutable 指示符用来说明是否可以修改捕获的变量 exception 表示异常  -> return type 返回值类型 {函数体}

lambda 表达是有特定的格式要求，就是说，一个 lambda 必须为以下格式：

各个部分的解释如下：

[捕获外部变量列表]

以[] 包含了一个可以捕获的外部参数列表，必须存在，但是捕获的变量可以为空，只能捕获在定义该 lambda 表达是之前可见的局部变量（包括lambda 所在的类this）。该列表参数会传递给编译器作为函数对象的构造器参数，所以 lambda 的本质也是个对象。

捕获的外部变量列表，可以是以下几种形式：

• 空，等于没有任何参数
• =，函数体范围内 lambda 表达式范围内可见的局部变量，以值传递的方式。意味着lambda 里面不可以修改相关的值
• &，函数体范围内 lambda 表达式范围内可见的局部变量，以引用传递的方式。意味着lambda 里面可以修改相关的值
• this，函数体可以使用 lambda 所在类的成员变量
• a变量，表示把 a 变量按照值传递。默认情况不能修改该变量，因为函数默认是 const，添加 mutable 修饰符之后，可以修改变量。
• &a,表示把 a 变量按照引用传递，可以在 lambda 内部修改 a 的内容。
• &a。将 a 按引用进行传递。
• a，&b。将 a 按值传递，b 按引用进行传递。
• =，&a，&b。除 a 和 b 按引用进行传递外，其他参数都按值进行传递。
• &，a，b。除 a 和 b 按值进行传递外，其他参数都按引用进行传递。

(形参列表)

这里的参数会传递给编译器，作为函数对象的构造器参数，如果没有，可以省略。参数可以在使用值传递或者引用传递。

mutable 或 exception 声明

这部分可以省略。按值传递函数对象参数时，加上 mutable 修饰符后，可以修改传递进来的拷贝（注意是能修改拷贝，而不是
值本身）。exception 声明用于指定函数抛出的异常，如抛出整数类型的异常，可以使用 throw(int)。

-> 返回值类型

标识函数返回值的类型，当返回值为 void，或者函数体中只有一处 return 的地方（此时编译器可以自动推断出返回值类型）
时，这部分可以省略。

{函数体}

标识函数的实现，这部分不能省略，但函数体可以为空。

示例代码如下：

#include "template_learn.h"
#include 
#include 

using namespace std;
string base{"hello"};

string append(string s) {
    return base.append(" ").append(s);
}

string prepend(string s) {
    return s.append(" ").append(base);
}

//函数指针的定义格式
//data_types(*func_pointer)(data_type arg1,data_type arg2,....,data_type arg)
//返回值类型(函数指针)(形参类型 形参)
string combine(string s, string(*fc)(string content)) {
    return (*fc)(s);
}
//捕获变量范围 this，表示可以捕获该类的
class test_capture{
    string  name = "name";
    int id = 99;
    void test_capture_thiz(){
        auto append_f = [this](string s)->string {
            return name.append(" ").append(s);
        };
    }
};

int main() {
    cout << combine("from MSVC", append) << "\n";
    cout << combine("Good morning and", prepend) << "\n";

    string  content = "test";
    //lambda 表达式的格式
    //[capture list](params list)mutable exception -> return type (function body)
    //[捕获外部变量列表](形参列表)mutable 指示符用来说明是否可以修改捕获的变量 exception 表示异常  -> return type 返回值类型 {函数体}
    auto append_f = [](string s)->string {
        return base.append(" ").append(s);
    };

    auto prepend_f = [](string s)->string {
        return s.append(" ").append(base);
    };

    string myName = "kotlon";

    cout << append_f("from MSVC1") << "\n";
    cout << prepend_f("Good morning and1") << "\n";

}

不同的编译器的具体实现有所不同，但是期望的结果就是，按引用捕获的任何变量，Lambda 函数实际存储的应该是这些变量在创建这个 lambda 函数的函数的栈指针，而不是函数本身栈变量的引用。不管怎样，因为大多数 lambda 函数都是在很小且局部的作用中，与候选的内联函数很类似，所以按照引用捕获那些变量不需要额外的存储空间。

Lambda 函数是一个依赖于实现的函数对象类型,这个类型的名字只有编译器知道. 如果用户想把 lambda 函数做为一个参数来传递, 那么形参的类型必须是模板类型或者必须能创建一个 std::function 类似的对象去捕获 lambda 函数.使用 auto 关键字可以帮助存储 lambda 函数。可以看下面介绍。

lambda 表达式作为函数参数

第一种是使用 template 作为声明这个 lambda ，代码如下：

template
void make_scence(F const &f) {
    auto re = f();
    cout << re << "\n";
}

void test_lambda_params() {
    auto lambda_f = []() -> int {
        return 0;
    };
    make_scence(lambda_f);
}

第二种是使用 std:function 定义这个 lambda 表达式，代码如下：

void make_scence1(function const &f) {

}
void test_lambda_params1() {
    auto lambda_f = []() -> string {
        return "name";
    };
    make_scence1(lambda_f);
}

参考

Lambda 表达式 (C++11 起)