C++可调用对象详解

ゝ一纸荒年。 2022-02-16 01:37 121阅读 0赞

> 我认为深刻理解 Lambda 表达式最好的方法就是结合具体的场景多用，个人强烈建议对照这篇文章来理解本文的知识：[可调用对象的应用场景][Link 1]

### 文章目录 ###

*   *   *  一、函数
         *  二、函数指针
         *  三、重载了函数调用运算符的类
         *  四、Lambda表达式(C++11)
         *   *  1.参数
             *  2.捕获列表
             *   *  2.1值捕获
                 *  2.2引用捕获
                 *  2.3隐式捕获
                 *  2.4混合捕获
             *  3.返回值类型
             *  4.深度理解
             *   *  4.1 Lambda是函数对象
                 *  4.1 表示Lambda捕获行为的类
             *  5.应用场景

> 对于一个对象或者表达式，如果可以对其使用调用运算符，即。如果a是一个可调用的表达式，则我们可以编写 a(args) ,其中 args 是一个逗号分割的一个或多个参数的列表。

### 一、函数 ###

//定义函数 add_func
    int add_func(int a, int b){ 
        int c = a + b;
        return c;
    }
    
    //调用函数 add_func
    int sum = add_func(3, 5);

### 二、函数指针 ###

通常我们可以定义一个指向函数的指针，通过这个指针调用特定类型的函数。

demo:

#include <iostream>
    
    int add(int a, int b){ 
        return a + b;
    }
    
    int sub(int a, int b){ 
        return a - b;
    }
    
    using pfunc = int(*)(int, int); //定义一个函数指针pfunc
    
    int middle_func(pfunc p, int a, int b){ 
        int result = p(a, b); //通过函数指针类型对象调用函数
        return result;
    }
    
    int main(){ 
        int a = 2;
        int b = 3;
        int sum = middle_func(add, a, b); //传入函数 add 给函数指针类型形参
        std::cout << a << " + " << b << " = " << sum << std::endl;
    }

### 三、重载了函数调用运算符的类 ###

如果类重载了函数调用运算符，则我们可以像使用函数一样使用该类的对象。因为这样的类同时也能存储状态，所以与普通函数相比更加灵活。（函数对象常常用作泛型算法的谓词）

demo：

//不包含状态的函数对象类
    struct SortCmp{ 
        int operator()(const std::string& s1, const std::string& s2){ 
            return s1.size() < s2.size();
        }  
    };
    
    std::vector<std::string> words{ "aaa", "aa", "aaaa", "a"};
    //对words进行排序，注意传递谓词时要带上调用符，下面是一个错误示范
    //std::sort(words.begin(), words.end(), SortCmp); //error
    std::sort(words.begin(), words.end(), SortCmp());

demo:

//包含状态的函数对象类
    
    struct Doc{ 
        int id;
        std::string doc;
    };
    
    class FindCmp{ 
    public:
        FindCmp(int id): doc_id(id){  }
        bool operator()(const Doc& d){ 
            return d == doc_id;
        }
    private:
        int doc_id;
    };
    
    //需求：在vector<Doc> doc_set中查找指定id的Doc，前提是vector<Doc>中不包含
    //重复的Doc（即包含的Doc的成员id不相同）
    
    int pos_id = 5;
    auto result = std::find_if(doc_set.begin(), doc_set.end(), 
    						   FindCmp(pod_id));
    
    if(result != doc_set.end()){ 
        std::cout << result->doc << std::endl;
    }else{ 
        std::cout << "not found" << std::endl;
    }

### 四、Lambda表达式(C++11) ###

一个Lambda表达式表示一个可调用的代码单元，可以理解为一个匿名函数。

Lambda 表达式的基本语法：

[捕获列表](参数列表) mutable(可选) -> 返回值类型 { 
    	//函数体
    }

其中，捕获列表是一个Lambda所在函数中定义的局部变量的列表（通常为空）；参数列表、返回值类型、函数体和普通函数一样，有一点区别的是，Lambda必须使用尾置返回（C++11）来指定返回类型。mutable后面再讲。

#### 1.参数 ####

Lambda的参数和普通函数几乎一样，有一点不同的是，Lambda不能有默认参数。因此，一个Lambda调用的实参数目永远和形参数量相等，一旦形参初始化完毕，就可以执行函数体了。

demo：

//打印vector中的数据
    std::vector<std::string> ve{ "hello", ",", "Lambda"};
    //for_each函数的作用是对传入的序列范围中每一个元素执行第三个参数传入的可调用对象
    std::for_each(ve.begin(), ve.end(), [](const std::string& s){ 
    									std::cout << s; });

#### 2.捕获列表 ####

> 一个Lambda可以出现在一个函数中，使用其局部变量，但是它只能使用哪些明确指明的变量。一个Lambda通过将局部变量包含在其捕获列表中来指明将会在Lambda函数体中使用这些变量。捕获列表指引Lambda在其内部包含访问局部变量所需的信息。

##### 2.1值捕获 #####

与参数传值类似，值捕获的前提是变量可以拷贝。（不同之处则在于，被捕获的变量在 Lambda 表达式被创建时拷贝，而非调用时才拷贝）

demo：

//打印vector中所有长度大于给定值的单词
    
    void PrintWords(std::vector<std::string>& words, const int& size){ 
        //对单词集合进行排序（sort函数按照第三个参数传入的可调用对象中的规则对传入序列
        //中的元素进行排序)
        std::sort(words.begin(), words.end(), 
                  [](const std::string& s1. const std::string& s2){ 
                      return s1.size() < s2.size()
                  }
                 );
    	//从前往后找到单词集合中第一个符合要求的单词位置
        //(find_if函数对传入序列中的每个元素调用第三个参数传入的可调用对象，返回令可
        //调用对象返回值为true的第一个元素的迭代器)
        //这里写的Lambda表达式在捕获列表中捕获当前函数中的变量size，说明在Lambda函
        //数内部要使用它
    	auto divide = std::find_if(words.begin(), words.end(),
                                   [size](const std::string& s1){ 
                                       return s1.size() > size;
                                   }
                                  );
        //从找到的位置往后都是符合要求的单词，遍历打印之。
    	std::for_each(divide, words.end(), [](const string& s){ 
    									       std::cout << s << " ";
    									   });
    }

默认情况下，对于一个值捕获的变量，在Lambda函数内部无法更改其值：

void func(){ 
        int n = 10;
        auto f = [n]() ->int {  return ++n; }; // error:令只读变量‘n’自增
        std::cout << f() << std::endl;
    }

如果想要在Lambda内部改变一个被值捕获的变量的值，就必须在参数列表末尾加上`mutable`：

void func(){ 
        int n = 10;
        auto f = [n]() mutable ->int {  return ++n; };
        std::cout << f() << std::endl; //输出11
        std::cout << n << std::endl; //输出10
    }

##### 2.2引用捕获 #####

与引用传参类似，引用捕获保存的是引用。是否可以在Lambda内部更改引用捕获的变量，取决于此引用指向的是一个const类型还是非const类型。

demo：

void func(){ 
        int n = 10;
        //Lambda如果没有参数，可以省略参数列表；如果没有指明返回值类型，那么由编译器
        //自动推导
        auto f = [&n] {  return ++n; }; 
        std::cout << f() << std::endl; //输出11
        std::cout << n << std::endl; //输出11
    }

##### 2.3隐式捕获 #####

除了显式列出我们希望使用的来自所在函数的变量之外，还可以让编译器根据Lambda函数体中的代码来自动推导我们要使用哪些变量。

为了指示编译器推导捕获列表，应在捕获列表中写一个`=`或`&`。

<table> 
 <thead> 
  <tr> 
   <th>格式</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>[=]</td> 
   <td>隐式捕获列表，Lambda体中所使用的所有来自Lambda所在函数的变量都采用值捕获的方式。</td> 
  </tr> 
  <tr> 
   <td>[&amp;]</td> 
   <td>隐式捕获列表，Lambda体中所使用的所有来自Lambda所在函数的变量都用引用的方式来使用。</td> 
  </tr> 
 </tbody> 
</table>

demo：

//把值捕获例子中的一行代码改一下，同样可以达到相同的目的
    auto divide = std::find_if(words.begin(), words.end(),
                               [=](const std::string& s1){ 
                                   return s1.size() > size;
                               });

##### 2.4混合捕获 #####

如果我们希望对一部分变量采用值捕获，对其他变量采用引用捕获，则可以采用混合使用隐式捕获和显式捕获。

<table> 
 <thead> 
  <tr> 
   <th>格式</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>[&amp;, 变量列表]</td> 
   <td>变量列表是一个逗号分隔的列表，包含0个或者多个来自所在函数的变量，这些变量采用值捕获的方式，而任何隐式捕获的变量都采用引用方式捕获。变量列表中的变量前不能使用&amp;。</td> 
  </tr> 
  <tr> 
   <td>[=, 变量列表]</td> 
   <td>变量列表中的变量都采用引用方式捕获，而任何隐式捕获的变量都采用值方式捕获。变量列表中的变量不能包含this，且这些变量之前必须使用&amp;。</td> 
  </tr> 
 </tbody> 
</table>

#### 3.返回值类型 ####

如果 Lambda 体中只包含一句 return 语句，则可以不用指定返回值的类型；如果 Lmbda 体中包含 return 之外的语句，则编译器假定此 Lambda 返回 void。（与其他返回void的函数类似，被编译器推导返回void的 Lambda 表达式不能返回值）如果我们还想要让 Lambda 返回值，就要显式指明 Lambda 的返回类型。

demo：

std::vector<int> ve{ 1, -2, 3, -4, 5, -6};
    //transform函数作用是将第三个参数传入的可调用对象应用到传入序列的元素上
    std::transform(ve.begin(), ve.end(),
                   [](int n) { 
                       if(n < 0) reutrn -n; else return n; }); //error
                       
    std::transform(ve.begin(), ve.end(),
                   [](int n) ->int { 
                       if(n < 0) return -n; else return n; }) //successful

#### 4.深度理解 ####

##### 4.1 Lambda是函数对象 #####

当我们编写了一个Lambda表达式后，编译器其实会将该表达式编译成一个未命名类的未命名对象。在Lambda表达式产生的类中含有一个重载的函数调用运算符。举一个例子：

下面sort函数的第三个参数我们传递了一个Lambda表达式：

std::vector<std::string> words{ "begin", "end", "word", "reinterpret"};
    //对words中的string按照长度进行降序排序
    std::sort(words.begin(), words.end(), 
              [](const std::string& s1, const std::string& s2){ 
                  return s1.size() < s2.size();
              }
             );

这个Lambda表达式其行为类似下面这个类的一个匿名对象：

class SortCmp{ 
    public:
        bool operator()(const std::string& s1, const std::string& s2){ 
            return s1.size() < s2.size();
        }
    }
    
    //用上面这个类替换Lambda表达式后，调用sort完成和上面相同的操作
    //对words中的string按照长度进行降序排序
    std::sort(words.begin(), words.end(), SortCmp());

##### 4.1 表示Lambda捕获行为的类 #####

通过值捕获的变量会被拷贝到Lambda中，因此，这种Lambda产生的类必须为每个值捕获的变量建立对应的数据成员，同时创建其构造函数。用捕获的变量来初始化这个Lambda产生的类的数据成员。举一个例子：

下面这个find\_if函数的第三个参数传入了一个Lambda表达式：

std::vector<std::string> words{ "begin", "end", "word", "reinterpret"};
    int size = 5;
    //找到words中长度第一个大于size的string
    auto distance = std::find_if(words.begin(), words.end(), 
                                 [size](const std::string& s) { 
                                     return s.size() > size 
                                 });

这个Lambda表达式其行为类似下面这个类的一个匿名对象：

class FindCondition{ 
    public:
        FindCondition(int n): _size(n) {  } //该形参对应捕获变量
        //该调用运算符的返回值类型，形参列表，函数体都同上面的Lambda表达式
        bool operator()(const std::string& s){ 
            return s.size() > _size;
        }
    private:
        int _size;
    };
    
    //用上面这个类替换Lambda表达式后，调用sort完成和上面相同的操作
    //找到words中长度第一个大于size的string
    auto distance = std::find_if(words.begin(), words.end(), 
    							 FindCondition(size));

#### 5.应用场景 ####

Lambda通常应用于那种只在一两个地方使用的简单操作。如果我们需要在很多地方使用相同的操作，最好还是应该定义一个函数，而不是多次编写相同的Lambda表达式。

还有就是，如果Lambda体中的逻辑比较复杂，那么最好还是编写一个函数或者一个存储状态的函数对象来替代它。（第二个替代者可以完成和Lambda捕获列表相同的工作，原因见本文第三个模块）

[Link 1]: https://blog.csdn.net/zanda_/article/details/89432807