• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

C11简洁之道:函数绑定

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

  在C++中,有“可调用对象”这么个概念,那么什么是调用对象呢?有哪些情况?我们来看看:

  • 函数指针;
  • 具有operator()成员函数的类对象(仿函数);
  • 可以被转换为函数指针的类对象;
  • 类成员(函数)指针。

  我们来看代码:

//函数指针

void func(void)
{
    //...
}

struct Foo
{
    void operator()(void)
    {
        //...
    }
};

struct Bar
{
    using fr_t = void(*)(void);
    static void func(void)
    {
        //...
    }

    operator fr_t(void)
    {
        return func;
    }
};

struct A
{
    int mia;

    void mem_func(void)
    {
           //...
    }
};

int main(void)
{
    //函数指针
    void(* func_ptr)(void) = &func;
    func_ptr();

    //仿函数
    Foo foo;
    foo();

    //被转为指针的类对象
    Bar bar;
    bar();

    //类成员函数指针
    void (A::*mem_func_ptr)(void) = &A::mem_func;

    //类成员指针
    int A::*mem_obj_ptr = &A::mia;

    A aa;
    (aa.*mem_func_ptr)();
    aa.*mem_obj_ptr = 123;

    return 0;
}

  上述的对象都是可调用对象,这些对象的类型统称为“可调用类型”。这些可调用对象都具有统一的操作形式,除了类成员指针之外,都是通过括号的方式来进行调用,但是定义的方法比较多,在C++11中增加了std::function来进行函数对象的调用。

2、  std::function

  std::function是一个可调用对象的包装器,他是一个类模板,可以容纳除了类成员(函数)指针之外的所用可调用对象,通过指定他的模板参数,可以以统一的方式处理函数、函数对象、函数指针,并允许保存或者延迟执行。

  当我们给std::function填入合适的函数签名(即一个函数类型,只需要包括返回值和参数列表)之后,它就变成了一个可以容纳所有这一类调用方式的“函数包装器”。

#include <iostream>
#include <functional>

void func(void)
{
    std::cout << __FUNCTION__ << std::endl;
}

class Foo
{
public:
    static int foo_func(int a)
    {
        std::cout << __FUNCTION__ << "(" << a << ")->: ";
        return a;
    }
};

class Bar
{
public:

    int operator()(int a)
    {
        std::cout << __FUNCTION__ << "(" << a << ")->: ";
        return a;
    }
};

int main(void)
{
    //绑定一个普通函数
    std::function<void(void)> fr1 = func;
    fr1();

    //绑定一个静态成员函数
    std::function<int(int)> fr2 = Foo::foo_func;
    std::cout << fr2(111) << std::endl;

    //绑定一个仿函数
    Bar bar;
    fr2 = bar;
    std::cout << fr2(111) << std::endl;

    return 0;
}

  执行结果:

 

  std::function还可以取代函数指针的作用,因为它可以保存函数延迟执行,所以也适合做回调函数。

#include <iostream>
#include <functional>

class A
{
    std::function<void()> callback;
public:
    A(const std::function<void()> &f) : callback(f){}

    void notify(void)
    {
        callback();
    }
};

class Foo
{
public:
    void operator()(void)
    {
        std::cout << __FUNCTION__ << std::endl;
    }
};
 
int main(void)
{
    Foo foo;
    A aa(foo);
    aa.notify();

    return 0;
}

  std::function还可以作为函数入参,比普通函数指针更加灵活和便利。

#include <iostream>
#include <functional>

void call_when_event(int x, const std::function<void(int)>& f)
{
    if(!(x & 1)) //x % 2 == 0
    {
        f(x);
    }
}

void output(int x)
{
    std::cout << x << "  ";
}

int main(void)
{
    for(int i = 0; i < 10; i++)
    {
        call_when_event(i, output);
    }

    std::cout << std::endl;

    return 0;
}

3、  std::bind绑定器

3.1 std::bind绑定器

  std::bind用来将可调用对象与起参数一起进行绑定,绑定的结果使用std::function进行保存,并在我们需要调用的时候调用。它主要有两大作用:

  • 将可调用对象和参数绑定成为一个仿函数;
  • 将多元(参数个数为n,n-1)可调用对象转换成一元或者(n-1)元可调用对象,即只绑定部分对象。

  我们来看实际使用:

#include <iostream>
#include <functional>

void call_when_event(int x, const std::function<void(int)>& f)
{
    if(!(x & 1)) //x % 2 == 0
    {
        f(x);
    }
}

void output(int x)
{
    std::cout << x << "  ";
}

void output2(int x)
{
    std::cout << x + 2 << "  ";
}

int main(void)
{
    {
        auto fr = std::bind(output, std::placeholders::_1);
        for(int i = 0; i < 10; i++)
        {
            call_when_event(i, fr);
        }

        std::cout << std::endl;
    }
    {
        auto fr = std::bind(output2, std::placeholders::_1);
        for(int i = 0; i < 10; i++)
        {
            call_when_event(i, fr);
        }

        std::cout << std::endl;
    }

    return 0;
}

  通过代码我们可以知道std::bind在函数外部通过绑定不同的函数,控制执行结果。这里我们还使用了std::placeholders占位符来绑定函数参数。

3.2 std::placeholders

  通过std::placeholders占位符绑定函数参数,使得std::bind的使用非常灵活。std::placeholders决定函数占用位置取用输入参数的第几个参数。

#include <iostream>
#include <functional>

void output(int x, int y)
{
    std::cout << x << "  " << y << std::endl;
}

int main(void)
{
    std::bind(output, 1, 2)();                                                 //输出:1 2
    std::bind(output, std::placeholders::_1, 2)(1);                         //输出:1 2
    std::bind(output, 2, std::placeholders::_1)(1);                            //输出:2 1
    //std::bind(output, 2, std::placeholders::_2)(1);                         //error,没有第二个参数
    std::bind(output, 2, std::placeholders::_2)(1,2);                         //输出:2 2,第一个参数被抛弃
    std::bind(output, std::placeholders::_1, std::placeholders::_2)(1,2);     //输出:1 2
    std::bind(output, std::placeholders::_2, std::placeholders::_1)(1,2);     //输出:2 1       

    return 0;
}

3.3 std::bind+std::function

  我们先看一组例子:

#include <iostream>
#include <functional>

class A
{
public:
    int mi = 0;

    void output(int x, int y)
    {
        std::cout << x << "  " << y << std::endl;
    }
};

int main(void)
{
    A a;
    std::function<void(int, int)> fr = std::bind(&A::output, &a, std::placeholders::_1, std::placeholders::_2);
    fr(1, 2);   

    std::function<int &(void)> fr_i = std::bind(&A::mi, &a);
    fr_i() = 123;
    std::cout << a.mi << std::endl;

    return 0;
}

  fr的类型是std::function<void(int, int)>,我们通过std::bind将A的成员函数output的指针和a绑定,并转换为一个仿函数存储在fr中。

  通过std::bind将A的成员mi的指针和a绑定,返回的结果放入类型为std::function<int &(void)>的fr_i中,可以在需要的时候修改这个成员的值。

3.4 改善标准函数

  假如我们有一个这样的需求,对某个集合里面的元素进行统计,假设元素类型为int,那么我们需要对类型做比较,必须有一个阀值,即大于或者小于这个数。这里我们可以通过标准库的函数来实现。

#include <iostream>
#include <functional>

int main()
{
    std::vector<int> coll;
    for (int i = 1; i <= 10; ++i)
    {
        coll.push_back(i);
    }

    // 查找元素值大于10的元素的个数
    // 也就是使得10 < elem成立的元素个数
    int res = count_if(coll.begin(), coll.end(), std::bind1st(less<int>(), 10));
    cout << res << endl;

    // 查找元素值小于10的元素的个数
    // 也就是使得elem < 10成立的元素个数
    res = count_if(coll.begin(), coll.end(), std::bind2nd(less<int>(), 10));
    cout << res << endl;

    bool b = less<int>(10, 20); // 返回true

    return 0;
}

  本质上是对一个二元函数less<int>的调用,但是要分别调用bind1st,bind2nd,用起来比较繁杂,现在我们有bind,可以用统一的方式去实现。并不用关心是bind1st还是bind2nd,用bind即可。

#include <iostream>
#include <functional>

int main()
{
    using std::placeholders::_1;
    std::vector<int> coll;

    //查找元素值大于10的元素个数
    int count = std::count_if(coll.begin(), coll.end(), std::bind(less<int>(), 10, _1));

    //查找元素值小于10的元素个数
    count = std::count_if(coll.begin(), coll.end(), std::bind(less<int>(), _1, 10));

    return 0;
}

3.5 组合使用

  bind可以绑定多个函数,假设我们要对某个集合在大于5小于10的元素个数进行统计,我们该怎么封装呢?

  首先封装一个判断是否大于5的函数,使其输入只有一个参数,直接和5比较,大于5返回true。

std::bind(std::greater<int>(), std::placeholders::_1, 5);

  同样,我们需要封装一个判断是否小于10的函数,使其输入一个参数,小于10则返回true。

std::bind(std::less_equal<int>(), std::placeholders::_1, 10);

  然后组合,即可调用:

using std::placeholders::_1;

auto f = std::bind(std::logical_and<bool>(),

std::bind(std::greater<int>(), std::placeholders::_1, 5),

std::bind(std::less_equal<int>(), std::placeholders::_1, 10));

int count = std::count_if(coll.begin(), coll.end(), f);

鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
C#访问SQLSERVER数据库帮助类发布时间:2022-07-14
下一篇:
C语言实现两栈空间共享发布时间:2022-07-14
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap