0909，bind函数，std::function & std::bind的回调函数实现

最新推荐文章于 2024-10-17 21:38:17 发布
最新推荐文章于 2024-10-17 21:38:17 发布
阅读量463 收藏 4
点赞数 8
分类专栏： 我爱学习 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51583806/article/details/142054899
版权
  1. remove if
  2. bind1st,bind2nd
  3. bind(普通，成员)
  4. copy
  5. 引用折叠
  6. 函数指针/指针函数
  7. 回调函数-延迟调用的思想
  8. 占位符
  9. function
  10. function+lambda
  11. 对象+回调函数对象
  12. bind+function+mem fn
  13. std::cref占位遍历

01_bind.cc

#include <iostream>
#include <functional>
using std::cout;
using std::endl;
using std::bind;
using std::function;

int add0(int a,int b){
    cout<<"add(0)(int int )"<<endl;
    return a+b;
}
int add1(int a,int b,int c){
    cout<<"add(1)(int int int)"<<endl;
    return a+b+c;
}

class Exemple{
public:
    int add2(int a,int b){
        cout<<"Exemple::add(2)(int int )"<<endl;
        return a+b;
    }
    int _data=100;
};

void test(){
    //函数的形态（类型，标签）:函数的返回类型+参数列表
    //（参数的个数，顺序，类型）

    //add0:int (int,int)
    //f0:int()
    auto f0=bind(&add0,1,2);
    cout<<f0()<<endl<<endl;

//----------//
//引用折叠
//& &&-->  &
//& & -->  &
//&& & ->  &
//&& &&->  &&

    //add1:int (int,int,int)
    //f1:int()
    auto f1=bind(add1,3,4,6);
    cout<<f1()<<endl<<endl;

    //add2:int (Exemple*,int,int)
    //f2:int()
    Exemple ex;
    auto f2=bind(&Exemple::add2,&ex,10,20);
    cout<<f2()<<endl<<endl;
    /* Exemple::add2(10,20); */
    //成员函数有隐藏参数this指针

    auto f4=bind(&Exemple::add2,ex,10,20);
    cout<<f4()<<endl<<endl;
    //如果ex已经销毁，&ex就会对空指针进行解引用
    //传对象则没有影响(copy了一份副本,生命周期和bind一致)
    //传地址（一个地址的开销）   传对象（一个对象的开销）


    //占位符
    //add1:int (int,int,int)
    //f5:  int(int)
    using namespace std::placeholders;
    auto f5=bind(add1,100,_1,20);
    cout<<f5(400,500,500)<<endl<<endl;
    /* f1=bind(add1,100,_1,20); */
    

    function<int()> f3=bind(&Exemple::_data,&ex);
    cout<<f3()<<endl<<endl;
    //数据成员（将数据成员的名字看成函数名字
    //数据成员的类型看成函数的返回类型

}






void func(int a1,int a2,int a3,const int &a4,int a5){
    cout<<"a1--"<<a1
        <<"\ta2--"<<a2
        <<"\ta3--"<<a3
        <<"\ta4--"<<a4
        <<"\ta5--"<<a5<<endl;
}

void test1(){
    //占位符整体，代表的函数的形参位置
    //占位符种的数字，代表的是实参的位置
    //std::cref=const reference,引用的包装器
    int num=100;
    using namespace std::placeholders;
    auto f=bind(func,10,_1,_2,std::cref(num),num);
                              //100->a4,a5
                              //默认的传递方式是值传递
    num=200;
    f(1,20,300,4000,5000);
    //a1--10	a2--1	a3--20	a4--100	a5--100
    //10->a1   1/_1->a2   20/_2->a3,剩下的扔掉
    f(800,200);
}



int main(void)
{
    test();
    test1();
    return 0;
}

02_funcPoint.cc

#include <iostream>
using std::cout;
using std::endl;

int func1(){
    return 10;
}
int func2(){
    return 20;
}
int add0(int a,int b){
    cout<<"add(0)(int int )"<<endl;
    return a+b;
}

//指针函数，函数的返回类型是指针
//int* re_arr(){
//  reuturn int*=new int[5]();
//}
//<深入理解C指针>

void test(){
    typedef int (*pFunc1)();//函数指针
                            //C写法
    /* typedef int(*)() pfunc;//error */
    using pfunc=int(*)();//取别名的另一种方式
                         //C++写法

    //回调函数--将函数作为参数传递(延迟调用的思想？？不懂)

    pFunc1 f=func1;//注册回调函数
    pfunc f1=func1;
    cout<<f()<<endl;//回调函数的执行
    cout<<f1()<<endl;

    f=func2;
    f1=func2;
    cout<<f()<<endl;
    cout<<f1()<<endl;

    /* f=add; */
    //函数形态不一致
}

int main(void)
{
    test();
    return 0;
}

03_lambda.cc

#include <iostream>
#include <functional>
#include <vector>
#include <string>
using std::cout;
using std::endl;
using std::vector;
using std::string;
using std::function;

void test(){

    int num=10;
    int age=20;

    //fuction,类模板，封装一切可以调用的对象
    //普通/成员函数，函数对象，lambda表达式

    //lambda 的函数形态:void(int)
    function<void(int)> f=[&age,num](int value){
        /* auto f=[&age,num](int value){ */
        ++age;
        ++value;
        cout<<"age--"<<age<<"\tnum--"
            <<num<<"\tvalue--"<<value<<endl;
    };

    f(100);
    f(200);

}

vector<function<void(const string &)>> vec;
void test1(){


    int num=100;
    string name("xixi");
    /* function<void(const string &)> f= */
    /*     [&num,&name](const string & val)->void{ */
    /*         cout<<num<<"--"<<name<<"--"<<val<<endl; */
    /*     }; */
    //return type可以省略

    /* vec.push_back([&num,&name](const string &val){ */
    vec.push_back([num,name](const string &val){
                  cout<<num<<"--"<<name<<"--"<<val<<endl;
                  });
    //捕获局部变量的引用，药保证其不被销毁
    for(auto ele:vec){
        ele("wuhan");
    }
}
void test2(){
    for(auto ele:vec){
        ele("wuhan");
    }
}

int main(void)
{
    test();
    test1();
    test2();
    return 0;
}

04_bind1st_bind2nd.cc

#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
using std::cout;
using std::endl;
using std::bind;
using std::vector;


template <typename Container>
void display( Container & con){
    for(auto &ele: con){
        cout<<ele<<" ";
    }
    cout<<endl;
}


void test(){
    vector<int> vec{1,5,3,6,2,7,23,3,6};
    display(vec);
    //delete all val>4
    auto it=remove_if(vec.begin(),vec.end(),[](int & value)->bool{
                      return value>4;
                      });
    display(vec);
    //pread pwrite 满足一元谓词->删除,read++
    //不满足，swap *pread & *pwrite,pread++,return ++pwrite
    vec.erase(it,vec.end());
    display(vec);
}
void test1(){
    vector<int> vec{1,5,3,6,2,7,23,3,6};
    display(vec);
    //less(val1,val2){return val1<val2;}
    /* auto it=remove_if(vec.begin(),vec.end(), */
    /*                   bind1st(std::less<int>(),4)); */
    auto it=remove_if(vec.begin(),vec.end(),
                      bind2nd(std::greater<int>(),4));
    display(vec);
    vec.erase(it,vec.end());
    display(vec);
}



int main(void)
{
    test();
    test1();
    return 0;
}

05_bind_figure.cc

#include <iostream>
#include <functional>
#include <math.h>
using std::cout;
using std::endl;
using std::bind;
using std::function;

//面向对象：继承+虚函数（纯虚函数）
//基于对象：std::bind+std::function（更加灵活
//
//总结：在C语言中，解决回调函数的注册与执行 --> 函数指针
//C++：std::bind + std::function
//-------------------------------------------------//
class Figure
{
public:
    //纯虚函数
    /* virtual void display() const = 0; */
    /* virtual double area() const = 0; */
    using DisplayCallBack=function<void()>;
    using AreaCallBack=function<double()>;

    //bind(``````)是右值
    /* void setDisplayC(const DisplayCallBack & dc){ */
    //函数注册到成员函数
    void setDisplayC(const DisplayCallBack && dc){
        _display_callback=std::move(dc);
    }
    void setArea(const AreaCallBack && dc){
        _area_callback=std::move(dc);
    }
    //执行注册的函数
    void handleDisplayC()const{
        if(_display_callback){
            _display_callback();
        }//nullptr
    }
    double handleAreaC()const{
        if(_area_callback){
            return _area_callback();
        }
        return 0.0;
    }
public:
    DisplayCallBack _display_callback;
    AreaCallBack _area_callback;
};

//-------------------------------------------------//
class Rectangle
: public Figure
{
public:
    Rectangle(double length = 0, double width = 0)
    : _length(length)
    , _width(width){
        cout << "Rectangle(double = 0, double = 0)" << endl;
    }

    void displsy_r(int val) const {
        cout << "Rectangle";
    }

    double area_r() const {
        return _length * _width;
    }

    ~Rectangle(){}
private:
    double _length;
    double _width;
};

//-------------------------------------------------//
class Circle
: public Figure
{
public:
    Circle(double radius = 0)
    : _radius(radius){
        cout << "Circle(double = 0)" << endl;
    }

    void display_c() const {
        cout << "Circle";
    }

    double area_c() const {
        return 3.14 * _radius *_radius;;
    }
    ~Circle(){}
private:
    double _radius;
};


//-------------------------------------------------//
class Triangle
: public Figure
{
public:
    Triangle(double a = 0, double b = 0, double c = 0)
    : _a(a)
    , _b(b)
    , _c(c){
        cout << "Triangle(double = 0, double = 0, double = 0)" << endl;
    }

    void display_t() const {
        cout << "Triangle";
    }

    double area_t() const {
        //海伦公式
        double tmp = (_a + _b + _c)/2;
        return sqrt(tmp * (tmp - _a) * (tmp - _b) * (tmp - _c));
    }

    ~Triangle(){}
private:
    double _a;
    double _b;
    double _c;
};


//-------------------------------------------------//
//-------------------------------------------------//
/* void func(const Figure &fig){ */
/*     fig.display(); */
/*     cout << "的面积 : " << fig.area() << endl; */
/* } */

void func(const Figure  &fig){
    fig.handleDisplayC();
    cout<<"area: "<<fig.handleAreaC()<<endl;
}

//-------------------------------------------------//
//-------------------------------------------------//
void test(){
    Rectangle r(10, 20);
    Circle c(10);
    Circle c1;
    Triangle t(3, 4, 5);
    cout<<endl;

    Figure fig;
    /* &bind(&Rectangle::displsy_r(),&r,10); */
    fig.setDisplayC(bind(&Rectangle::displsy_r,&r,10));
    fig.setArea(bind(&Rectangle::area_r,&r));
    func(fig);

    fig.setDisplayC(bind(&Circle::display_c,&c));
    fig.setArea(bind(&Circle::area_c,&c));
    func(fig);
    fig.setDisplayC(bind(&Circle::display_c,&c1));
    fig.setArea(bind(&Circle::area_c,&c1));
    func(fig);
    
    fig.setDisplayC(bind(&Triangle::display_t,&t));
    fig.setArea(bind(&Triangle::area_t,&t));
    func(fig);
}



int main(void)
{
    test();
    return 0;
}

06_mem_fn.cc

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using std::cout;
using std::endl;
using std::for_each;
using std::mem_fn;
using std::ostream;
using std::vector;
using std::function;

class Number
{
public:
    Number(size_t data=0)
        :_data(data)
    {}
    ~Number(){}
    bool isEven()const{
        return _data%2==0;
    }
    bool isPrime()const{
        if(_data==1){
            return false;//1不是素数
        }
        for(size_t i=2;i<=_data/2;++i){
            if(_data%i==0){return false;}
        }
        return true;
    }
    void print(){
        cout<<_data<<" ";
    }
    friend ostream & operator<<(ostream & os,const Number & n);
private:
    size_t _data;
};
ostream & operator<<(ostream & os,const Number & n){
    os<<n._data<<" ";
    return os;
}


void test(){
    vector<Number> vec;
    for(size_t i=1;i!=30;++i){
        vec.push_back(Number(i));
    }
    //mem_fn用于将成员函数指针封装成一个函数对象
    //使得可以像普通函数一样调用
    /* for_each(vec.begin(),vec.end(),mem_fn(&Number::operator=)); */
    for_each(vec.begin(),vec.end(),mem_fn(&Number::print));
    cout<<endl;

    //删除偶数
    auto it=remove_if(vec.begin(),vec.end(),mem_fn(&Number::isEven));
    vec.erase(it,vec.end());
    for_each(vec.begin(),vec.end(),mem_fn(&Number::print));
    cout<<endl;

    //删除质数
    it=remove_if(vec.begin(),vec.end(),mem_fn(&Number::isPrime));
    vec.erase(it,vec.end());
    for_each(vec.begin(),vec.end(),mem_fn(&Number::print));
    cout<<endl;


//--------------------------------------------------//
    Number n(10);
    for_each(vec.begin(),vec.end(),std::bind(&Number::print,&n));
    /* for_each(vec.begin(),vec.end(),std::bind(&Number::print,n)); */
    cout<<endl;

    using namespace std::placeholders;

    /* function<void(Number)> f=bind(&Number::print,_1); */
    //成员函数，类型不正确？？

    function<void(Number&)> f=bind(&Number::print,_1);
/* 创建一个 std::function<void(Number&)> 对象 f，它将 
 * Number 类的iprint 成员函数与占位符 _1 绑。 */
/* 这里 _1 表示在 for_each 中调用 f 时，将传递的每个元素
 * 作为 print 的参数，即每个 Number 对象的引用。 */

    for_each(vec.begin(),vec.end(),f);
    cout<<endl;
    for_each(vec.begin(),vec.end(),bind(&Number::print,_1));
    cout<<endl;

}

int main(void)
{
    test();
    return 0;
}

作业：

01 什么是回调函数，注册回调函数，执行回调函数？(掌握std::bind用法,非常重要)

std::bind的实现原理阅读材料

http://www.cnblogs.com/xusd-null/p/3698969.html

01_bind.cc 

02 std::bind可以绑定什么？bing绑定成员函数的传参有什么区别？

1，普通函数

2，成员函数（普通成员函数还需要传递函数对象，静态成员函数不需要

3，数据成员（名字看作函数名字，类型看作返回类型

4，lambda表达式

03 使用std::bind与std::function（基于对象的形式）实现上课所讲的Figure的例子的代码？

05_bind_figure.cc

qq_51583806 彩雷王
关注
专栏目录
用std::function和std::bind实现回调函数
窑下吴彦祖的博客
04-22 1794
1.参考资料 std::function - C++中文 - API参考文档 (apiref.com) std::bind - C++中文 - API参考文档 (apiref.com) 这两个类用到的头文件都是#include <functional> 2.理解 ①std::function 可以用多种形式存储函数，包括直接保存，lambda表达式，bind表达式。 ②std::bind 一个可以打包函数的工具，不同的c++标准用法不一样，我们这里用的是c++11所以，...
std::bind
qq_44186550的博客
03-21 456
可以方便地用来创建回调函数，尤其是在那些需要用户提供一个在未来某个时间点执行，并且可能带有预定义参数的函数的地方。，以及预先设定的参数。这样就创建了一个可以作为回调函数使用的对象。函数，它接受一个无参数的回调函数，并在一个指定的延迟后执行。函数，从而实现了在2秒后通过回调机制调用。在这个例子中，我们首先定义了一个类。
【C++】C++11的std::function和std::bind用法详解
热门推荐
Yngz_Miao的博客
12-23 4万+
在设计回调函数的时候，无可避免地会接触到可回调对象。在C++11中，提供了std::function和std::bind两个方法来对可回调对象进行统一和封装。 可调用对象 C++中有如下几种可调用对象：函数、函数指针、lambda表达式、bind对象、函数对象。其中lambda表达式和bind对象是C++11标准中提出的(bind机制并不是新标准中首次提出，而是对旧版本中bind1st和bind2...
std::function和std::bind函数
嵌入式大师之路
06-20 572
在这个示例中，std::bind创建了一个绑定第一个参数的函数对象，而std::function将其存储并调用。std::placeholders::_1, std::placeholders::_2等占位符用于表示未绑定的参数位置。std::function和std::bind是C11引入的功能强大的库组件，用于处理函数对象和函数调用的高级操作。std::function和std::bind可以结合使用，以创建更加灵活和强大的函数对象。// 使用std::bind绑定参数。
回调函数|std::function|std::bind
总结和收藏
11-16 465
如果你把函数的指针（地址）作为参数传递给另一个函数(类)，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。std::function的实例可以对任何可以调用的目标实体进行存储、复制、和调用操作，这些目标实体包括普通函数、Lambda表达式、函数指针、以及其它函数对象等。std::bind()函数的意义就像它的函数名一样，是用来绑定函数调用的某些参数的。
C++常用新特性: std::bind && std::function
Sandy_WYM_的博客
09-26 504
dkjf
c++ 回调函数，std::function，std::bind
Ken的博客
09-05 620
定义回调函数的指针类型，包括返回值类型、(*类型名)函数指针、参数表回调函数的使用者函数符合函数指针类型的实现函数实现函数的类型必须要和函数指针的类型声明一致，也就是返回值和参数表（个数、类型）要完全一致。
c++ 回调函数与std::function使用实例
guotianqing的博客
12-12 1万+
理解回调 实际项目中，经常有使用回调函数的需求，如： 双方通信中，等待接收对方的数据并处理，如使用socket进行的TCP通信 定时器事件，当定时器计时结束时，需要处理某任务 信号的触发，需要执行某任务 在同步编程中，需要启动一个专门的线程来阻塞监听并处理那些可能在未来发生的事件，而在异步编程中，只需要使用回调函数就可以了。 在这种场景下，可以简单地理解为：我为某事件注册一个处理函数，当该事...
通过c++11的std::bind及std::function实现类方法回调，模拟Qt实现信号槽
10-06
c++11引入了std::bind及std::function，实现了函数的存储和绑定，即先将可调用的对象保存起来，在需要的时候再调用。定义了SignalObject信号类和SlotObject槽类，其中信号类中的 std::function(int)> _call就是要...
C++ 11 std::function和std::bind使用详解
08-25
std::function 和 std::bind 的使用可以实现类似函数指针的功能，但它们比函数指针更加灵活，特别是在函数指向类的非静态成员函数时。std::function 和 std::bind 的使用可以提高代码的可读性和可维护性，提高开发...
C++11中lambda、std::function和std:bind详解
08-31
这篇文主要关注三个核心概念：lambda表达式、std::function和std::bind。 **Lambda表达式**是C++11引入的一种内联匿名函数，它允许我们在需要的地方直接定义函数对象，而无需单独声明一个函数。Lambda表达式的语法...
C++11 新特性 ④ | 模板类 std::function 和标准库函数 std::bind
dvlinker的技术专栏
09-09 1万+
详细讲解模板类std::function和标准库函数std::bind。
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 292
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
C++，STL 028（24.10.11）
Erif_Liu的博客
10-12 223
利用sort排序算法来对deque容器进行排序。
C++ 游戏开发技术选型指南
进击的码农
10-12 721
在使用C++进行游戏开发时，选择合适的技术栈和工具链是项目成功的关键之一。我们探讨了游戏开发常用的一些引擎、示例代码的实现、性能优化及潜在问题解决方案。通过合理选择和配置，可以有效提高开发效率和产品质量。在此过程中，我深刻感受到技术的选择与应用只是成功的一部分，持续学习和思考如何创新更是推动项目成功的动力。希望这篇博客能对你的项目有所帮助，并期待你在开发过程中创造出更多技术上的创新与突破。
2023-06 GESP C++三级试卷
ya888g
10-17 465
位同学，每位同学有从 0 到?到达的同学都会报出的编号，不会报出别人的编号，但有的同 学很顽皮，会多次报出。10 如果 a 为 int 类型的变量，且表达式((a | 3) == 3)的值为 true，则说 明 a 在从 0 到 3 之间（可能为 0、可能为 3）3 已知大写字符’A’的 ASCII 编码的十六进制表示为 0x41，则字符’F’的 ASCII 编码的十六进制表示为（ ）12 如果 a 为 int 类型的变量，下列哪个表达式可以正确求出满足“小于等于 a且是 4 的倍数”的整数中最大的（ ）
关于C语言中局部变量与全局变量——超详细解释篇
2401_87108776的博客
10-17 244
在函数的开头进行定义。
【C++】list
最新发布
Hello World!
10-17 455
然后修改链接关系即可。那么怎么定位到最后一个节点呢？
通过c++11的std::bind及std::function实现类方法回调
09-17
总的来说，通过使用std::bind和std::function，我们可以将类方法转换为可以被传递和调用的函数对象，实现类方法的回调功能。这种方式在实际开发中非常有用，可以方便地实现各种回调机制，提高代码的灵活性和可重用性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值