C++ lambda 表达式与闭包：在设计模式中的使用

c++++ lambda 表达式和闭包可以在设计模式中发挥作用：策略模式：lambda 表达式可定义可互换的行为。状态模式：lambda 表达式可定义状态转换行为。实际案例：lambda 表达式可用于闭包中，从而可以在函数之外访问变量，例如文件过滤。

C++ lambda 表达式与闭包：在设计模式中的使用

介绍

lambda 表达式是一种简洁的语法，用于定义在运行时创建的匿名函数。在 C++ 中，lambda 表达式通常与闭包结合使用，闭包是一种函数，可以访问其定义作用域之外的变量。本教程将探讨 lambda 表达式和闭包，并展示如何在设计模式中使用它们。

C++ lambda 表达式

lambda 表达式的语法如下：

立即学习“C++免费学习笔记（深入）”；

[capture-list] (parameters) -> return-type { body }

capture-list：指定 lambda 表达式可以访问的外部变量。

parameters：lambda 表达式接受的参数（可选）。

return-type：lambda 表达式返回的类型（可选）。

闭包

闭包是包含对至少一个外部变量的引用的 lambda 表达式。这允许 lambda 表达式访问其定义范围之外的数据，即使它已经超出范围。

设计模式中的使用

策略模式

在策略模式中，lambda 表达式可用于定义可互换的行为。例如，下方的代码使用 lambda 表达式定义比较策略：

// 定义一个比较策略类
struct CompareStrategy {
    bool operator()(int a, int b) {
        return a < b;
    }
};

// 定义一个使用策略模式的函数
void sort(vector<int>& vec, CompareStrategy strategy) {
    sort(vec.begin(), vec.end(), strategy);
}

int main() {
    vector<int> vec = {1, 3, 2, 4};

    // 使用lambda 表达式定义比较策略
    sort(vec, [](int a, int b) { return a > b; });

    // 打印排序后的向量
    for (int i : vec) {
        cout << i << " ";
    }

    return 0;
}

状态模式

在状态模式中，lambda 表达式可用于定义状态转换行为。例如，下方的代码使用 lambda 表达式定义一个状态机，它控制一个简单对象的交互：

// 定义一个状态接口
struct State {
    virtual void handle(Context* context) = 0;
};

// 定义具体状态类
class StateA : public State {
    void handle(Context* context) override {
        // 执行状态 A 的逻辑
        cout << "State A" << endl;
        // 转换到状态 B
        context->setState(new StateB());
    }
};

// 定义具体状态类
class StateB : public State {
    void handle(Context* context) override {
        // 执行状态 B 的逻辑
        cout << "State B" << endl;
        // 转换到状态 A
        context->setState(new StateA());
    }
};

// 定义上下文类
class Context {
private:
    State* state;
public:
    Context(State* state) : state(state) {}
    void request() {
        state->handle(this);
    }
    void setState(State* state) {
        this->state = state;
    }
};

int main() {
    // 创建一个上下文对象
    Context context(new StateA());

    // 处理请求并输出状态
    for (int i = 0; i < 5; i++) {
        context.request();
    }

    return 0;
}

实际案例

以下是一个使用 C++ lambda 表达式和闭包进行文件过滤的实际案例：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// 定义一个函数，返回一个 lambda 表达式，该表达式的目的是根据条件过滤一个文件
auto filter_files(const string& path, const string& extension) {
    return [path, extension](const string& file) {
        // 如果文件的路径包含给定路径且扩展名与给定扩展名匹配，则返回true
        return file.find(path) != string::npos && file.rfind(extension) == file.length() - extension.length();
    };
}

int main() {
    // 定义一个文件列表
    vector<string> files = {"file1.txt", "file2.cpp", "file3.pdf", "file4.h", "file5.txt", "file6.js"};

    // 使用lambda 表达式过滤文件列表
    auto filtered_files = filter_files("/home/user/Documents", ".txt");
    vector<string> result;  // 用于存储过滤后的文件列表

    // 将过滤后的文件添加到结果向量中
    copy_if(files.begin(), files.end(), back_inserter(result), filtered_files);

    // 打印过滤后的文件列表
    for (auto& file : result) {
        cout << file << endl;
    }

    return 0;
}

在这个例子中，lambda 表达式用于接受一个文件路径字符串，并根据给定的条件对其进行过滤，即文件路径是否包含指定的路径且扩展名是否与指定的扩展名匹配。

以上就是C++ lambda 表达式与闭包：在设计模式中的使用的详细内容，更多请关注本网内其它相关文章！