函数指针、函数对象、lambda 表达式、std::function

Posted on 2022-02-05 In C++ Word count in article: 742 Reading time ≈ 3 mins.

1. 函数指针

函数指针 (Function Pointer) 就是指向函数地址的指针

int Sum(int a, int b) {
	return a + b;
}

typedef int(*SumFunc)(int x, int y);

// --------

SumFunc sum = Sum;
std::cout << sum(1, 2) << std::endl;

2. 函数对象

函数对象，也就是 Function Object, 也被称为 Functor，它可以被当作一个函数来调用。通常指重载了 operator() 的类对象。因为它是一个对象，因此它的优势是可以保存一些状态，比如下面的 padding 属性。不过相对函数指针，多增加了一个类的实现，二进制体积也相应地增加。

class SumClass {
public:
	SumClass(int padding): padding(padding){}

	int operator()(int a, int b) {
		return a + b + padding;
	}

private:
	int padding;
};

// ---------------------

SumClass sumObj(3);
std::cout << sumObj(1, 2) << std::endl;
// 等价于
std::cout << sumObj.operator()(1, 2) << std::endl;

3. `Lambda` 表达式

lambda 表达式内部会创建一个上面所说的函数对象，不过是匿名的，只有编译器知道类名是什么. lambda 可以捕获外部的变量，都会转换为匿名函数对象的属性值来保存.

int padding = 3;
auto sum_lambda = [padding](int a, int b) -> int {
	return a + b + padding;
};
std::cout << sum_lambda(1, 2) << std::endl;

我们用 cppinsight 来看一下转换后的代码：

int padding = 3;

class __lambda_11_19
{
  public:
  inline /*constexpr */ int operator()(int a, int b) const
  {
    return (a + b) + padding;
  }

  private:
  int padding;

  public:
  __lambda_11_19(int & _padding)
  : padding{_padding}
  {}
};

__lambda_11_19 sum_lambda = __lambda_11_19{padding};
std::cout.operator<<(sum_lambda.operator()(1, 2)).operator<<(std::endl);

可见，编译器会为我们生成一个类，并创建一个 functor 类 __lambda_11_19，最终调用 functor. 因为 lambda 中值捕获了 padding 参数，因此，该生成类中有一个 private 的 padding 属性。可见跟上面手写的 SumClass 类实现几乎完全一致。

4. `std::function`

C++ 对 std::function 的描述:

Class template std::function is a general-purpose polymorphic function wrapper

Instances of std::function can store, copy, and invoke any CopyConstructible Callable target–functions, lambda expressions, bind expressions, or other function objects, as well as pointers to member functions and pointers to data members

std::function 是一个函数包装器模板，一个 std::function 类型对象可以包装以下类型：

函数指针
类成员函数指针 (如使用 std::bind 传递)
函数对象（定义了 operator() 操作符的类对象）

既然能包装这些类型，也相当于可以从这些类型转换过来:

class TestClass {
public:
  int Sum(int x, int y) {
    return x + y;
  }
};

// ---------------------

// 包装函数指针
std::function<int(int, int)> sum_func_1 = sum;
std::cout << sum_func_1(1, 2) << std::endl;;

// 包装函数对象
std::function<int(int, int)> sum_func_2 = sumObj;
std::cout << sum_func_2(1, 2) << std::endl;;

// 包装 Lambda (即便 capture 了参数)
std::function<int(int, int)> sum_func_3 = sum_lambda;
std::cout << sum_func_3(1, 2) << std::endl;;

// 包装类成员函数指针
TestClass test_obj;
using std::placeholders::_1;
using std::placeholders::_2;
std::function<int(int, int)>  sum_func_4 = std::bind(&TestClass::Sum, &test_obj, _1, _2);
std::cout << sum_func_4(1, 2) << std::endl;;

5. 相互转换

4 中提到的都可以转换为 std::function
没有什么可以直接转换为 lambda
一个没有捕获变量的 lambda 函数，可以显式转换成函数指针：

// lambda without capturing any value -> function ptr
SumFunc func_ptr = [/*padding (error) */](int x, int y) -> int {
  return x + y;
};
std::cout << func_ptr(1, 2) << std::endl;;

1. 函数指针

2. 函数对象

3. Lambda 表达式

4. std::function

5. 相互转换

3. `Lambda` 表达式

4. `std::function`