bind与lambda

本文通过实例比较了C++中lambda表达式与bind函数在性能上的差异,结果显示lambda表达式的运行速度明显优于bind函数。

  bind() 和 lambda 表达式都可以实现类似的功能,在使用的时候有时候不知道选择哪一个。这里来做一个简单的总结。主要参考了一下的文章:

http://stackoverflow.com/questions/1930903/bind-vs-lambda

http://www.gockelhut.com/c++/articles/lambda_vs_bind

1. bind() 在多层嵌套的时候会使代码非常难看懂(参见文章一)

2. lambda 不支持“多态性”(其实就是泛型),需要在定义的时候指定参数类型

3. lambda 运行速度会比bind() 函数快很多

4. lambda 可以通过 std::function 实现“多态”特性

下面是一个例子,表明lambda 的运行时间比bind 的情况要快很多:

#include <cstdint>
#include <chrono>
#include <iostream>
#include <string>
#include <functional>
#include <thread>

class timer
{
public:
    typedef std::chrono::high_resolution_clock clock;
    typedef clock::time_point                  time_point;
    typedef clock::duration                    duration;
    
public:
    timer()
    {
        reset();
    }
    
    void reset()
    {
        _starttime = clock::now();
    }

    duration elapsed() const
    {
        return clock::now() - _starttime;
    }
protected:
    time_point _starttime;
};

template <typename T>
void volatile_write(const T& x)     
{
    volatile T* p = new T;
    *p = x;
    delete p;
}

template <typename Function>
void run_test(const std::string& name, Function func)
{
    std::cout << name;
    timer t;                //初始化的时候已经开始计时
    volatile_write(func());
    timer::duration duration = t.elapsed();
    std::cout << '\t' << duration.count() << std::endl;
}

template <typename Function>
void do_test_loop(Function func, const uint64_t upper_limit = 100000)
{
    for (uint64_t i = 0; i < upper_limit; ++i)
        func(i);
}

uint64_t test_accumulate_lambda()
{
    uint64_t x = 0;
    auto accumulator = [&x] (uint64_t i) { x += i; };
    do_test_loop(accumulator);
    return x;
}

void test_accumulate_bind_function(uint64_t& x, uint64_t i)
{
    x += i;
}

uint64_t test_accumulate_bind()
{
    namespace arg = std::placeholders;
    
    uint64_t x = 0;
    std::function<void (uint64_t)> accumulator = std::bind(&test_accumulate_bind_function, std::ref(x), arg::_1);
    do_test_loop(accumulator);
    return x;
}
uint64_t test_accumulate_bind_auto()
{
    namespace arg = std::placeholders;
    
    uint64_t x = 0;
    auto accumulator = std::bind(&test_accumulate_bind_function, std::ref(x), arg::_1);
    do_test_loop(accumulator);
    return x;
}

uint64_t test_accumulate_bound_lambda()
{
    uint64_t x = 0;
    std::function<void (uint64_t)> accumulator = [&x] (uint64_t i) { x += i; };
    do_test_loop(accumulator);
    return x;
}


int main()
{
   
    run_test("Accumulate (lambda)            ", &test_accumulate_lambda);
    run_test("Accumulate (bind)              ", &test_accumulate_bind);
    run_test("Accumulate (bound lambda)      ", &test_accumulate_bound_lambda);
    run_test("Accumulate (bind_auto)        ", &test_accumulate_bind_auto);
    return 0;
}

运行结果:

C:\Windows\system32\cmd.exe /c lambda_vs_bind.exe
Accumulate (lambda) 20001
Accumulate (bind) 110007
Accumulate (bound lambda) 50003
Accumulate (bind_auto) 90005
Hit any key to close this window...

 

从运行结果可以看出,使用lambda比bind快一个数量级,使用auto 修饰函数对象比用std::function<>速度也略有提升。

 

### C++ Lambda 表达式 Bind 函数详解 #### Lambda 表达式的结构和特性 Lambda 表达式是一种匿名函数,可以捕获其所在作用域内的局部变量。语法如下: ```cpp [capture](parameters) -> return_type { // function body } ``` - `capture`:指定如何捕获外部变量,支持按值(`=`),按引用(`&`)或混合模式。 - `parameters`:形参列表,类似于常规函数声明。 - `return_type`:返回类型,默认推导可省略。 示例展示 lambda 表达式的简单应用[^1]: ```cpp #include <iostream> int main() { auto greet = []() { std::cout << "Hello from lambda!" << std::endl; }; greet(); return 0; } ``` #### Bind 函数的作用及其应用场景 Bind 是一种工具,允许将某些参数固定下来形成新的函数对象,在后续调用时只需提供剩余未固定的参数即可完成操作。这有助于简化回调机制的设计以及提高代码复用度。 对于标准库算法而言,当需要传递带有额外状态信息的操作给它们执行时尤为有用;比如筛选满足特定条件的数据项、累加计算等场景下经常能看到 bind 的身影[^3]. #### 结合使用的实例分析 下面通过一个具体的案例来说明两者配合工作的过程: 假设有一个整型数组想要找出里面所有的偶数值并打印出来。传统做法可能涉及编写辅助函数再传入迭代器范围内进行处理。现在借助于 lambdabind 可以更加简洁高效地达成目标。 ```cpp #include <algorithm> #include <vector> #include <functional> // For std::bind and placeholders like _1 #include <iostream> bool is_even(int n){ return (n % 2 == 0); } void print_vector(const std::vector<int>& vec){ for(auto elem : vec) std::cout<<elem<<" "; std::cout<<"\n"; } int main(){ using namespace std::placeholders; std::vector<int> numbers{1,2,3,4,5}; // Using both lambda expression and bind together. auto even_filter = std::bind(is_even,_1); std::copy_if(numbers.begin(),numbers.end(), std::ostream_iterator<int>(std::cout," "), [](const int& value){return !(value%2);} );// Directly use lambda without binding std::cout<<"\nUsing bind with predicate:\n"; std::vector<int> evens; std::copy_if(numbers.begin(),numbers.end(), back_inserter(evens), even_filter); print_vector(evens); return 0; } ``` 此段代码展示了如何利用 lambda 实现自定义逻辑的同时又可以通过 bind 来封装已有的谓词函数作为过滤条件的一部分参 STL 算法运算之中[^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值