c++函数对象

August 17, 2022

函数对象：函数指针、函数符、lambda 表达式
后两者实际上通过重载 () 运算符的对象实现函数功能。

函数指针参见另一篇

函数符

cpp

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>
using namespace std;

template <typename T>
void print_vec(vector<T> &vec)
{
    for (auto i : vec)
        cout << i << ", ";
    cout << endl;
}

int always_one()
{
    return 1;
}

class Always_two
{
public:
    int operator()()
    {
        return 2;
    }
};

Always_two always_two;

int main()
{
    vector<int> numbers(5);
    generate(numbers.begin(), numbers.end(), rand);
    // rand 的签名是 int rand()
    // generate 的签名在此处可以看作
    // template< class ForwardIt, class Generator >
    // void generate( ForwardIt first, ForwardIt last, Generator g );

    print_vec(numbers); // 41, 18467, 6334, 26500, 19169,

    generate(numbers.begin(), numbers.end(), always_one);
    print_vec(numbers); // 1, 1, 1, 1, 1,

    generate(numbers.begin(), numbers.end(), always_two);
    print_vec(numbers); // 2, 2, 2, 2, 2,
}

lambda

模仿上例，给出如下代码

cpp

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>
using namespace std;

int always_one()
{
    return 1;
}

class Always_two
{
public:
    int operator()()
    {
        return 2;
    }
};

Always_two always_two;

template <typename T>
class Store
{
private:
    T value;

public:
    template <typename Fn>
    void set_fn(Fn func) noexcept
    {
        value = func();
    }
    void set(T val) noexcept
    {
        value = val;
    }
    T get() const noexcept
    {
        return value;
    }
    void print() const noexcept
    {
        cout << value << endl;
    }
};

int main()
{
    Store<int> store;

    store.set_fn(rand);
    store.print(); // 41

    store.set_fn(always_one);
    store.print(); // 1

    store.set_fn(always_two);
    store.print(); // 2

    store.set_fn([](){ return 3; });
    store.print(); // 3
}

Microsoft C++ 文档中的描述非常直观
https://docs.microsoft.com/zh-cn/cpp/cpp/lambda-expressions-in-cpp
lambda 表达式的各个部分

capture 子句 (C++ 规范中也称为 lambda 引入器)

[] 表示不捕获 [=] 表示默认按值捕获(不能修改) [&] 表示默认按引用捕获
[x] 表示按值捕获变量 x (不能修改)
[&x] 表示按引用捕获变量 x
[x, &y] 表示变量 x 按值捕获，变量 y 按引用捕获
[=, &x] 表示除变量 x 按引用捕获外，其余变量按值捕获
[&, x] 表示除变量 x 按值捕获外，其余变量按引用捕获
此外，不允许这样：[&, &x] [=, x]
捕获 this 同理 [this] [&, this] [=, *this]
捕获一个可变模板 [args...]
声明临时变量（v1, v2 仅在函数体有效） [v1 = 1, v2 = std::move(important)]

参数列表，可选 (也称为 lambda 声明符)

lambda 函数的参数列表与普通函数基本相同，不过不支持默认参数和可变参数
使用 auto 关键字替代模板语法，来实现泛型

cpp

auto plus = [] (auto first, auto second) { return first + second; };

可变规范，可选

mutable 表示允许修改按值捕获的变量

cpp

int a = 123;
auto f = [a](int x) mutable { a=x;cout<<a<<endl; };
// 不加 mutable 则报编译错误
f(456); // 456
cout << a; // 123

异常规范，可选

异常规范同普通函数

cpp

auto err = []() noexcept { throw "ERROR"; };
// 编译器警告

返回类型，可选

返回类型可以自动推导时无需声明返回类型。

cpp

#include <iostream>
#include <functional>
using namespace std;
int main()
{
    auto add_two_integers = [](int x) -> function<int(int)>
    {// 这里也是可以自动推导返回类型的
        return [=](int y) { return x + y; };
    };
    cout << add_two_integers(1)(2); // 3
}

lambda 正文

lambda 函数根据 capture 子句获取封闭范围捕获的变量

functional 头文件

`std::function<>`

类模板 std::function 是通用多态函数封装器。
std::function 的实例能存储、复制及调用任何可调用函数对象（函数指针、函数符、lambda 表达式）的类型。
尖括号中传入函数对象表达的函数的类型：

cpp

function<int(int,int)> add = [](auto a, auto b){return a+b;};

`std::invoke()`

`std::ref()`

`std::bind()` `std::placeholders` （弃用）

←Back to home