✨️ 复制成功，转载请标注本文地址

lambda和function

3887 字
19 分钟
lambda和function
2026-05-22
C++
C++

引言#

C++ 提供了多种方式来表示和操作可调用对象，包括传统的函数指针、仿函数（Functors）、Lambda表达式、std::function 和 std::bind 等。这些工具极大地增强了C++的灵活性和表达能力，尤其在处理回调、事件驱动编程和函数式编程时表现尤为出色。

函数指针#

函数指针是C++中最基本的可调用对象之一，用于指向普通函数和静态成员函数。

定义与使用#

函数指针的定义涉及到函数的返回类型和参数列表。例如，定义一个指向返回 int 且接受两个 int 参数的函数指针：

// 定义函数指针类型
int (*funcPtr)(int, int);


// 定义一个普通函数
int add(int a, int b) {
    return a + b;
}


int main() {
    // 给函数指针赋值
    funcPtr = &add;


    // 调用函数
    int result = funcPtr(3, 4);
    std::cout << "结果: " << result << std::endl; // 输出: 结果: 7


    return 0;
}

优点与局限性#

优点:

  • 简单直观，适用于简单的回调函数。

局限性:

  • 不能捕获上下文（如lambda中的闭包）。
  • 语法相对复杂，尤其是指针的声明和使用。

仿函数（Functors）#

仿函数（Functors），又称函数对象（Function Objects），是在C++中重载了 operator() 的类或结构体实例。仿函数不仅可以像普通函数一样被调用，还能携带状态，提供更大的灵活性和功能性。

定义与使用#

仿函数是通过定义一个类或结构体，并重载其调用运算符 operator() 来实现的。

#include <iostream>


// 定义一个仿函数类
struct Adder {
    int to_add;


    // 构造函数
    Adder(int value) : to_add(value) {}


    // 重载()运算符
    int operator()(int x) const {
        return x + to_add;
    }
};


int main() {
    Adder add5(5); // 创建一个添加5的仿函数


    std::cout << "10 + 5 = " << add5(10) << std::endl; // 输出: 10 + 5 = 15


    return 0;
}

特点#

  1. 携带状态： 仿函数可以拥有内部状态，通过成员变量存储数据，使其在调用时具备上下文信息。
  2. 灵活性高： 可以根据需要添加更多的成员函数和变量，扩展功能。
  3. 性能优化： 编译器可以对仿函数进行优化，例如内联展开，提高执行效率。

高级示例#

仿函数不仅可以执行简单的计算，还可以进行复杂的操作。例如，实现一个可变的仿函数，用于累加多个值。

#include <iostream>


// 可变累加器仿函数
struct Accumulator {
    int sum;


    Accumulator() : sum(0) {}


    // 重载()运算符
    void operator()(int x) {
        sum += x;
    }
};


int main() {
    Accumulator acc;


    acc(10);
    acc(20);
    acc(30);


    std::cout << "总和: " << acc.sum << std::endl; // 输出: 总和: 60


    return 0;
}

使用仿函数的标准库算法#

许多标准库算法可以接受仿函数作为参数，使得算法的行为更加灵活和可定制。

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


// 仿函数：判断一个数是否大于某个阈值
struct IsGreaterThan {
    int threshold;


    IsGreaterThan(int t) : threshold(t) {}


    bool operator()(int x) const {
        return x > threshold;
    }
};


int main() {
    std::vector<int> numbers = {1, 5, 10, 15, 20};


    // 使用仿函数进行筛选
    IsGreaterThan greaterThan10(10);
    auto it = std::find_if(numbers.begin(), numbers.end(), greaterThan10);


    if(it != numbers.end()) {
        std::cout << "第一个大于10的数是: " << *it << std::endl; // 输出: 第一个大于10的数是: 15
    } else {
        std::cout << "没有找到大于10的数。" << std::endl;
    }


    return 0;
}

仿函数与模板#

仿函数与模板相结合，可以实现高度通用和可复用的代码。例如，编写一个通用的比较仿函数。

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


// 通用比较仿函数
template <typename T>
struct Compare {
    bool operator()(const T& a, const T& b) const {
        return a < b;
    }
};


int main() {
    std::vector<int> numbers = {5, 2, 8, 1, 9};


    // 使用仿函数进行排序
    std::sort(numbers.begin(), numbers.end(), Compare<int>());


    std::cout << "排序后的数字: ";
    for(auto num : numbers) {
        std::cout << num << " "; // 输出: 1 2 5 8 9
    }
    std::cout << std::endl;


    return 0;
}

仿函数的优势#

  • 可扩展性： 能够根据需要添加更多功能和状态。
  • 与Lambda的互补性： 在需要携带复杂状态或多次调用时，仿函数比Lambda更适合。
  • 类型安全： 仿函数是具体的类型，可以在编译期进行类型检查。

何时使用仿函数#

  • 需要携带状态时： 当回调函数需要维护内部状态时，仿函数是理想选择。
  • 复杂操作： 当简单的函数指针或Lambda难以表达复杂逻辑时。
  • 性能关键场景： 由于仿函数可以被编译器优化，适用于性能敏感的代码。

Lambda表达式#

Lambda表达式是C++11引入的一种轻量级函数对象，允许在代码中定义匿名函数。它们可以捕获周围的变量，具有更强的表达能力。

基本语法#

[captures](parameters) -> return_type {
    // 函数体
}
  • captures: 捕获外部变量的方式，可以是值捕获、引用捕获或者混合捕获。
  • parameters: 参数列表。
  • return_type: 返回类型，可以省略，编译器会自动推导。
  • 函数体: 实际执行的代码。

示例#

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


int main() {
    int threshold = 5;
    std::vector<int> numbers = {1, 6, 3, 8, 2, 7};


    // 使用lambda表达式进行过滤
    numbers.erase(std::remove_if(numbers.begin(), numbers.end(),
        [threshold](int n) -> bool {
            return n < threshold;
        }), numbers.end());


    // 输出结果
    for(auto n : numbers) {
        std::cout << n << " "; // 输出: 6 8 7
    }


    return 0;
}

捕获方式#

  1. 值捕获 ([=]): 捕获所有外部变量的副本。
  2. 引用捕获 ([&]): 捕获所有外部变量的引用。
  3. 混合捕获: 指定部分变量按值捕获，部分按引用捕获，如 [=, &var] 或 [&, var]。
  4. 无捕获 ([]): 不捕获任何外部变量。

可变Lambda#

默认情况下，Lambda表达式是不可变的（const）。通过mutable关键字，可以允许修改捕获的变量副本。

#include <iostream>


int main() {
    int count = 0;


    auto increment = [count]() mutable {
        count++;
        std::cout << "Count inside Lambda: " << count << std::endl;
    };


    increment(); // 输出: Count inside Lambda: 1
    increment(); // 输出: Count inside Lambda: 2


    std::cout << "Count outside Lambda: " << count << std::endl; // 输出: Count outside Lambda: 0


    return 0;
}

捕获成员函数和类变量#

Lambda表达式可以捕获类的成员变量和成员函数，使其在类的上下文中更加灵活。

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


class Processor {
public:
    Processor(int threshold) : threshold(threshold) {}


    void process(std::vector<int>& data) {
        std::cout << "处理前数据: ";
        for(auto num : data) std::cout << num << " ";
        std::cout << std::endl;


        // 使用Lambda表达式进行过滤
        data.erase(std::remove_if(data.begin(), data.end(),
            [this](int n) -> bool {
                return n < threshold;
            }), data.end());


        std::cout << "处理后数据: ";
        for(auto num : data) std::cout << num << " ";
        std::cout << std::endl;
    }


private:
    int threshold;
};


int main() {
    std::vector<int> numbers = {1, 6, 3, 8, 2, 7};
    Processor proc(5);
    proc.process(numbers);
    /*
    输出:
    处理前数据: 1 6 3 8 2 7
    处理后数据: 6 8 7
    */


    return 0;
}

Lambda与标准库算法#

Lambda表达式与标准库算法紧密结合，提供了更简洁和直观的代码书写方式。

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


int main() {
    std::vector<int> numbers = {4, 2, 5, 1, 3};


    // 使用Lambda表达式进行排序
    std::sort(numbers.begin(), numbers.end(),
        [](int a, int b) -> bool {
            return a < b;
        });


    std::cout << "排序后的数字: ";
    for(auto num : numbers) {
        std::cout << num << " "; // 输出: 1 2 3 4 5
    }
    std::cout << std::endl;


    return 0;
}

Lambda表达式的优势#

  • 简洁性： 代码更加紧凑，易于理解。
  • 灵活性： 能够捕获外部变量，适应更多场景。
  • 性能优化： 编译器可以对Lambda进行优化，如内联展开。
  • 与标准库的良好集成： 与STL算法无缝结合，简化代码逻辑。

std::function 对象#

std::function 是C++11提供的一个通用的可调用包装器，能够封装任何可调用对象，包括普通函数、Lambda表达式、函数对象以及绑定表达式。它实现了类型擦除，使得不同类型的可调用对象可以通过统一的接口进行操作。

定义与使用#

#include <iostream>
#include <functional>


// 普通函数
int add(int a, int b) {
    return a + b;
}


// 函数对象
struct Multiply {
    int operator()(int a, int b) const {
        return a * b;
    }
};


int main() {
    // 封装普通函数
    std::function<int(int, int)> func1 = add;
    std::cout << "Add: " << func1(3, 4) << std::endl; // 输出: Add: 7


    // 封装Lambda表达式
    std::function<int(int, int)> func2 = [](int a, int b) -> int {
        return a - b;
    };
    std::cout << "Subtract: " << func2(10, 4) << std::endl; // 输出: Subtract: 6


    // 封装函数对象
    Multiply multiply;
    std::function<int(int, int)> func3 = multiply;
    std::cout << "Multiply: " << func3(3, 4) << std::endl; // 输出: Multiply: 12


    return 0;
}

特点#

  • 类型擦除： 可以存储任何符合签名的可调用对象。
  • 灵活性： 支持动态改变存储的可调用对象。
  • 性能开销： 相比于直接使用函数指针或Lambda，std::function 可能带来一定的性能开销，尤其是在频繁调用时。

用法场景#

  • 回调函数的传递。
  • 事件处理系统。
  • 策略模式的实现。

示例：回调机制#

#include <iostream>
#include <functional>


// 定义回调类型
using Callback = std::function<void(int)>;


// 触发事件的函数
void triggerEvent(Callback cb, int value) {
    // 事件发生，调用回调
    cb(value);
}


int main() {
    // 使用Lambda作为回调
    triggerEvent([](int x) {
        std::cout << "事件触发，值为: " << x << std::endl;
    }, 42); // 输出: 事件触发，值为: 42


    // 使用仿函数作为回调
    struct Printer {
        void operator()(int x) const {
            std::cout << "Printer打印值: " << x << std::endl;
        }
    } printer;


    triggerEvent(printer, 100); // 输出: Printer打印值: 100


    return 0;
}

存储和调用不同类型的可调用对象#

std::function 可以在容器中存储各种不同类型的可调用对象，只要它们符合指定的签名。

#include <iostream>
#include <functional>
#include <vector>


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


struct Multiply {
    int operator()(int a, int b) const {
        return a * b;
    }
};


int main() {
    std::vector<std::function<int(int, int)>> operations;


    // 添加不同类型的可调用对象
    operations.emplace_back(add); // 普通函数
    operations.emplace_back(Multiply()); // 仿函数
    operations.emplace_back([](int a, int b) -> int { return a - b; }); // Lambda


    // 执行所有操作
    for(auto& op : operations) {
        std::cout << op(10, 5) << " "; // 输出: 15 50 5
    }
    std::cout << std::endl;


    return 0;
}

std::bind 操作#

std::bind 是C++11中提供的一个函数适配器，用于绑定函数或可调用对象的部分参数，生成一个新的可调用对象。它允许提前固定某些参数，简化函数调用或适应接口需求。

基本用法#

#include <iostream>
#include <functional>


// 普通函数
int add(int a, int b) {
    return a + b;
}


int main() {
    // 绑定第一个参数为10，生成新的函数对象
    auto add10 = std::bind(add, 10, std::placeholders::_1);


    std::cout << "10 + 5 = " << add10(5) << std::endl; // 输出: 10 + 5 = 15


    return 0;
}

占位符 (std::placeholders)#

std::bind 使用占位符来表示未绑定的参数，这些占位符决定了在生成的新函数对象中如何传递参数。

常用的占位符包括：

  • std::placeholders::_1
  • std::placeholders::_2
  • std::placeholders::_3
  • 等等，根据需要传递的参数数量。

示例#

#include <iostream>
#include <functional>


void display(const std::string& msg, int count) {
    for(int i = 0; i < count; ++i) {
        std::cout << msg << std::endl;
    }
}


int main() {
    // 绑定消息为"Hello"，生成新的函数对象，只需要传递次数
    auto sayHello = std::bind(display, "Hello", std::placeholders::_1);


    sayHello(3);
    /*
    输出:
    Hello
    Hello
    Hello
    */


    // 绑定次数为2，生成新的函数对象，只需要传递消息
    auto sayTwice = std::bind(display, std::placeholders::_1, 2);
    sayTwice("Hi");
    /*
    输出:
    Hi
    Hi
    */


    return 0;
}

与Lambda表达式的对比#

std::bind 曾在C++11中广泛使用，但随着Lambda表达式的普及，很多情况下Lambda更为直观和高效。不过，在某些复杂的参数绑定场景下，std::bind 依然有其独特优势。

使用 std::bind:

#include <iostream>
#include <functional>


int multiply(int a, int b) {
    return a * b;
}


int main() {
    // 绑定第一个参数为2，生成新的函数对象
    auto multiplyBy2 = std::bind(multiply, 2, std::placeholders::_1);


    std::cout << "2 * 5 = " << multiplyBy2(5) << std::endl; // 输出: 2 * 5 = 10


    return 0;
}

使用 Lambda 表达式:

#include <iostream>
#include <functional>


int multiply(int a, int b) {
    return a * b;
}


int main() {
    // 使用Lambda表达式绑定第一个参数为2
    auto multiplyBy2 = [](int b) -> int {
        return multiply(2, b);
    };


    std::cout << "2 * 5 = " << multiplyBy2(5) << std::endl; // 输出: 2 * 5 = 10


    return 0;
}

总结：

  • 可读性： Lambda表达式通常更具可读性，语法更直观。
  • 灵活性： Lambda更易于捕获和使用外部变量。
  • 性能： Lambda通常比std::bind更高效，因为std::bind可能引入额外的间接层。

绑定类的成员函数#

在C++中，成员函数与普通函数不同，因为它们需要一个对象实例来调用。使用 std::bind 或Lambda表达式，可以方便地绑定类的成员函数，生成可调用对象。

使用 std::bind 绑定成员函数#

#include <iostream>
#include <functional>


class Calculator {
public:
    int multiply(int a, int b) const {
        return a * b;
    }
};


int main() {
    Calculator calc;


    // 绑定成员函数multiply，固定第一个参数为5
    auto multiplyBy5 = std::bind(&Calculator::multiply, &calc, 5, std::placeholders::_1);


    std::cout << "5 * 3 = " << multiplyBy5(3) << std::endl; // 输出: 5 * 3 = 15


    return 0;
}

使用Lambda表达式绑定成员函数#

#include <iostream>
#include <functional>


class Greeter {
public:
    void greet(const std::string& name) const {
        std::cout << "Hello, " << name << "!" << std::endl;
    }
};


int main() {
    Greeter greeter;


    // 使用Lambda表达式绑定成员函数
    auto greetFunc = [&greeter](const std::string& name) {
        greeter.greet(name);
    };


    greetFunc("Alice"); // 输出: Hello, Alice!


    return 0;
}

绑定静态成员函数#

静态成员函数不依赖于类的实例，可以像普通函数一样使用 std::bind 和 std::function。

#include <iostream>
#include <functional>


class Logger {
public:
    static void log(const std::string& message) {
        std::cout << "Log: " << message << std::endl;
    }
};


int main() {
    // 使用std::bind绑定静态成员函数
    auto logFunc = std::bind(&Logger::log, std::placeholders::_1);


    logFunc("This is a static log message."); // 输出: Log: This is a static log message.


    return 0;
}

绑定带有返回值的成员函数#

#include <iostream>
#include <functional>


class Math {
public:
    double power(double base, double exponent) const {
        double result = 1.0;
        for(int i = 0; i < static_cast<int>(exponent); ++i) {
            result *= base;
        }
        return result;
    }
};


int main() {
    Math mathObj;


    // 绑定成员函数power，固定基数为2
    auto powerOf2 = std::bind(&Math::power, &mathObj, 2.0, std::placeholders::_1);


    std::cout << "2^3 = " << powerOf2(3) << std::endl; // 输出: 2^3 = 8


    return 0;
}

注意事项#

  • 对象生命周期： 绑定成员函数时，确保对象在可调用对象使用期间依然存在，以避免悬空指针问题。
  • 指针与引用： 可以通过指针或引用传递对象实例给 std::bind 或Lambda表达式。
  • 捕获方式： 在使用Lambda表达式时，选择合适的捕获方式（值捕获或引用捕获）以确保对象的正确访问。

C++ 可调用对象的总结#

C++ 提供了多种方式来定义和操作可调用对象，每种方式有其独特的特点和适用场景。

可调用对象描述示例用法
函数指针指向普通函数或静态成员函数的指针int (*func)(int) = &funcName;
仿函数（Functors）重载了 operator() 的类实例，可以携带状态struct Foo { void operator()(); };
Lambda表达式定义在表达式中的匿名函数，支持捕获上下文变量[capture](params) { /* code */ }
std::function通用的可调用对象包装器，能够封装任何符合签名的可调用对象std::function<void(int)> func;
std::bind绑定函数或可调用对象的部分参数，生成新的可调用对象auto newFunc = std::bind(func, _1);

选择建议#

  • 简单回调： 使用函数指针或Lambda表达式。
  • 需要携带状态或更复杂逻辑： 使用Lambda表达式或仿函数（Functors）。
  • 接口要求 std::function： 使用 std::function，不过要注意可能的性能开销。
  • 参数预绑定： 使用 std::bind，但在现代C++中，许多情况下Lambda表达式能达到相同效果且更直观。

文章分享

如果这篇文章对你有帮助，欢迎分享给更多人！

lambda和function
https://godze.online/posts/c-plus-plus/lambda和function/
作者
Vafail
发布于
2026-05-22
许可协议
CC BY-NC-SA 4.0
stl容器
智能指针
相关文章智能推荐
1
变量和输出
C++2026-05-02
2
继承和多态
C++2026-05-19
3
类型推导和别名
C++2026-05-08
4
头文件和源文件
C++2026-05-04
5
万能引用和原样转发
C++2026-05-30
随机文章随机推荐

评论区

分享你的想法，与大家交流讨论

公告
欢迎来到我的博客！
分类
标签
最新动态
站点统计
文章
61
分类
6
标签
8
总字数
136,467
运行时长
0 天
最后活动
0 天前
站点信息
构建平台
Vercel
博客版本
Firefly v6.15.3
文章许可
CC BY-NC-SA 4.0
© 2026Vafail. All Rights Reserved.RSSSitemap
Powered byAstroFirefly