精华内容
下载资源
问答
  • c++ 注册回调函数研究

    万次阅读 2016-08-19 15:18:03
    连接高层和底层就叫注册回调函数。高层程序C1调用底层程序C2,而在底层程序C2 又调用了高层程序C2的callback函数,那么这个callback函数对于高层程序C1来说就是回调函数。 在设计模式中这个方式叫回调模式。 二 ...

    一 何为注册回调 

       注册回调简单解释就是一个高层调用底层,底层再过头来用高层,这个过程就叫注册回调, 连接高层和底层就叫注册回调函数。高层程序C1调用底层程序C2,而在底层程序C2 又调用了高层程序C2的callback函数,那么这个callback函数对于高层程序C1来说就是回调函数。 在设计模式中这个方式叫回调模式。


    二 注册回调函数的实例:

    //底层程序 C2

    #include<iostream>
    
    using namespace std;
    
    class CCallback
    {
    public:
    	virtual void onCallbackFunc(int value,int type) =0;	
    };
    
    class ClassA
    {
    public: 
    	ClassA(CCallback *pCallbackFunc)
    	{
    		m_pCallBack = pCallbackFunc;	
    	}
    
    	void showValue()
    	{
    		m_pCallBack->onCallbackFunc(15,0);
    		m_pCallBack->onCallbackFunc(17,1);
    	}
    private:
    	CCallback *m_pCallBack;
    
    };
    

    //高层程序 C1

    #include<iostream>
    #include"ClassA.hpp"
    using namespace std;
    
    class ClassB : public CCallback
    {
    public:
    	ClassB()
    	{
    		m_ClassA = new ClassA(this);				
    	}
    
    	void onCallbackFunc(int value,int type)
    	{
    		if(type == 0)
    		{
    			cout<<"Typ_ZERO =  "<< value<<endl;
    		}
    		else
    		{
    			cout<<"Typ_Other =  "<< value<<endl;
    		}
    	}
    
    	void TestShowData()
    	{
    		m_ClassA->showValue();
    	}
    public:
    	ClassA * m_ClassA;
    };
    


    //主程序 main 

    #include "stdafx.h"
    #include"ClassB.hpp"
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    
    	ClassB *m_classB =new ClassB();
    	
    	m_classB->TestShowData();
    
    	system("pause:");
    	return 0;
    }
    

    测试结果:



    上面就是一个简单的注册回调的过程。


    三 : 注册回调有何作用

     注册回调 可以让调用者与被调用者分开。调用者不关心谁是被调用者,所有它需知道的,只是存在一个具有某种特定原型、某些限制条件(如返回值为int)的被调用函数。





    展开全文
  • 一个Demo,描述了C#如何在C++注册函数回调
  • C++回调函数使用心得

    万次阅读 多人点赞 2018-11-11 15:23:52
    C++回调函数使用心得前言回调函数也是普通函数C回调函数C++回调函数使用场景描述C++回调函数定义静态成员函数访问非静态成员函数的方法回调对象更复杂的讨论 前言 关于C++回调函数的介绍网上有很多,要知道它的...

    前言

    关于C++回调函数的介绍网上有很多,要知道它的概念很容易,难的是灵活应用,这里就笔者遇到的一个使用场景对回调函数进行一个简单的介绍,如果能对您有所帮助是我的荣幸。本文不会对C++回调函数的基础知识做过多的介绍,若对其概念不够理解的,笔者在此推介两篇个人认为相当优秀的博客。
    链接: link1.
    链接: link2.

    回调函数也是普通函数

    首先明确一个概念,回调函数也是普通函数,而不是什么神秘的东西。至于为什么叫回调函数,是因为程序通过参数把该函数的函数指针传递给了其它函数,在那个函数里面调用这个函数指针就相当于调用这个函数,这样的过程就叫回调,而被调用的函数就叫回调函数。看得出来,回调的本质是函数指针传递,所以想要理解回调机制,先要理解函数指针。

    C回调函数

    C++回调函数扩展自C回调函数,要想理解C++回调函数,先要理解C回调函数。我们通过一个实例来讲解C回调函数的使用方法。

    //callbackTest.c
    //1.定义函数onHeight(回调函数)
    //@onHeight 函数名
    //@height   参数
    //@contex   上下文
    void onHeight(double height, void* contex)
    {
    	sprint("current height is %lf",height);
    }
    
    //2.定义onHeight函数的原型
    //@CallbackFun 指向函数的指针类型
    //@height      回调参数,当有多个参数时,可以定义一个结构体
    //@contex      回调上下文,在C中一般传入nullptr,在C++中可传入对象指针
    typedef void (*CallbackFun)(double height, void* contex);
    
    //3.定义注册回调函数
    //@registHeightCallback 注册函数名
    //@callback             回调函数原型
    //@contex               回调上下文
    void registHeightCallback(CallbackFun callback, void* contex)
    {
    	double h=100;
    	callback(h,nullptr);
    }
    
    //4.main函数
    void main()
    {
    	//注册onHeight函数,即通过registHeightCallback的参数将onHeight函数指针
    	//传入给registHeightCallback函数,在registHeightCallback函数中调用
    	//callback就相当于调用onHeight函数。
    	registHeightCallback(onHeight,nullptr);
    }

    程序的运行结果是:
    current height is 100
    很多时候,注册的时候并不调用回调函数,而是在其他函数中调用,那我们可以定义一个CallbackFun全局指针变量,在注册的时候将函数指针赋给它,在要调用的调用它。如

    //定义全局指针变量
    CallbackFun* m_pCallback;
    //定义注册回调函数
    void registHeightCallback(CallbackFun callback, void* contex)
    {
    	m_pCallback = callback;
    }
    //定义调用函数
    void printHeightFun(double height)
    {
    	m_pCallback(height,nullptr);
    }
    //main函数
    void main()
    {
    	//注册回调函数onHeight
    	registHeightCallback(onHeight,nullptr);
    	//打印height
    	double h=99;
    	printHeightFun(99);
    }

    程序的运行结果是:
    current height is 99

    C++回调函数

    C++回调函数扩展自C,与C略有不同的是,C++可以使用全局函数和静态函数作为回调函数。考虑到全局函数会破坏封装性,所以一般都用静态成员函数。故除了理解函数指针,还要理解静态成员函数,具体一点是在静态成员函数中访问非静态成员函数的方法,因为我们很可能需要获取静态成员函数中的数据。

    使用场景描述

    比如说你使用了别人提供的sdk,这个sdk可能来自供应商,也有可能来自你的同事,他就提供给你一个注册回调函接口,比如就下面这个,你可以通过回调函数获取到height(某种传感器的实时返回的数据),你要怎么做?

    C++回调函数定义

    //CallbackFun类型
    //@CallbackFun 指向函数的指针类型
    //@height      回调参数,当有多个参数时,可以定义一个结构体
    //@contex      回调上下文,在C中一般传入nullptr,在C++中可传入对象指针
    typedef void (*CallbackFun)(double height, void* contex);
    
    //注册回调函数接口
    //@registHeightCallback 注册函数名
    //@callback             回调函数原型
    //@contex               回调上下文
    void registHeightCallback(CallbackFun callback, void* contex)

    首先,你要定义一个静态成员函数并注册。

    //sensorTest.cpp
    //接收数据类class Sensor
    class Sensor{
    public:
    	Sensor(){}
    	~Sensor(){}
    	//定义回调函数onHeight
    	static void onHeight(double height, void* contex)
    	{
    		cout << "current height is  " << height << endl;
    	}
    	//定义注册回调函数
    	void registCallback()
    	{
    		registHeightCallback(onHeight, this);
    	}
    };
    
    //main 函数
    void main()
    {
    	Sensor sens;
    	sens.registCallback();
    }

    运行程序,我们发现控制台一直在打印
    current height is **
    说明我们的回调函数正确实现了。到这一步不难,只要掌握基本的回调函数概念都能实现。
    现在我们有这样一种情况,我们有另外一个类,要在这个类里面实时打印获取的数据,要怎么做呢?

    静态成员函数访问非静态成员函数的方法

    我们知道静态成员函数中是只能出现静态变量和静态函数的,但是有些时候真的需要访问非静态成员函数或变量,比如我上面说的那种情况。让我们先来实现对同一个类中的非静态成员函数的访问。
    修改class Sensor如下

    //接收数据类class Sensor
    class Sensor{
    public:
    	Sensor(){}
    	~Sensor(){}
    	//定义回调函数onHeight
    	static void onHeight(double height, void* contex)
    	{
    		//cout << "current height is  " << height << endl;
    		Sensor* sen = (Sensor*)contex;
    		if(sen)  //注意判断sen是否有效
    			sen->getHeight(height);
    	}
    	//定义注册回调函数
    	void registCallback()
    	{
    		registHeightCallback(onHeight, this);
    	}
    	//新增的成员函数
    	void getHeight(double height)
    	{
    		cout << "current height is  " << height << endl;
    	}
    };

    如此修改之后,得到与修改前一样的效果(实时打印height),关键点在于注册回调函数的时候将Sensor对象的指针传给了contex,在回调函数中又将contex转换为Sensor对象指针,所以能调用普通函数。
    同理,如果注册时传入某一个对象的指针,就可以在回调函数中对该对象进行操作,这就是我们可以在一个对象中回调另一个对象的思想。

    回调对象

    现在开始解决之前提出的问题,本质是不变的,回调是指针传递,可以是函数指针,也可以是对象指针。

    //先定义一个类class DataPrint
    //打印数据类class DataPrint
    class DataPrint{
    public:
    	DataPrint(){}
    	~DataPrint(){}
    	void printHeight(double height)
    	{
    		cout << "print height is " << height << endl;
    	}
    };
    
    //要在类Sensor中增加DataPrint的指针和一个DataPrint指针赋值函数,class Sensor修改为
    //接收数据类class Sensor
    class Sensor{
    public:
    	Sensor(){}
    	~Sensor(){}
    	//定义回调函数onHeight
    	static void onHeight(double height, void* contex)
    	{
    		DataPrint* dp = (DataPrint*)contex;
    		if(dp)  //注意判断dp是否有效
    			dp->printHeight(height);
    	}
    	//定义注册回调函数
    	void registCallback()
    	{
    		registHeightCallback(onHeight, m_pDataPrint );
    	}
    	//新增的成员函数
    	void getHeight(double height)
    	{
    		//cout << "current height is  " << height << endl;
    	}
    	void setDataPrint(DataPrint* dp)
    	{
    		m_pDataPrint = dp;
    	}
    private:
    	DataPrint* m_pDataPrint;
    };
    
    //main主函数
    void main()
    {
    	DataPrint* dp=new DataPrint();
    	Sensor* sens=new Sensor();
    	//注意这两句的顺序不能颠倒
    	sens->setDataPrint(dp);
    	sens->registCallback();
    }

    这样就能实现在另一个类中取得回调函数的数据,如果无法保证DataPrint的实例化一定在Sensor之前,我们可以这样做

    //先定义一个类class DataPrint
    //打印数据类class DataPrint
    class DataPrint{
    public:
    	DataPrint(){}
    	~DataPrint(){}
    	void printHeight(double height)
    	{
    		cout << "print height is " << height << endl;
    	}
    };
    
    //要在类Sensor中增加DataPrint的指针和一个DataPrint指针赋值函数,class Sensor修改为
    //接收数据类class Sensor
    class Sensor{
    public:
    	Sensor(){}
    	~Sensor(){}
    	//定义回调函数onHeight
    	static void onHeight(double height, void* contex)
    	{
    		Sensor* sen= (Sensor*)contex;
    		if(sen)  //注意判断sen是否有效
    			sen->getHeight(height);
    	}
    	//定义注册回调函数
    	void registCallback()
    	{
    		registHeightCallback(onHeight, m_pDataPrint );
    	}
    	//新增的成员函数
    	void getHeight(double height)
    	{
    		if(m_pDataPrint )
    			m_pDataPrint ->printHeight(height);
    	}
    	void setDataPrint(DataPrint* dp)
    	{
    		m_pDataPrint = dp;
    	}
    private:
    	DataPrint* m_pDataPrint;
    };
    
    //main主函数
    void main()
    {
    	DataPrint* dp=new DataPrint();
    	Sensor* sens=new Sensor();
    	//注意这两句的顺序可以颠倒
    	sens->setDataPrint(dp);
    	sens->registCallback();
    }

    两个的区别是一个直接注册指定类的对象指针,另一个注册当前类的对象指针,间接调用另一个类的对象指针。

    更复杂的讨论

    刚才讨论的问题稍微复杂一点了,不过应该也容易理解,但是我们在实际项目中遇到的情况可能比这个复杂。比如在有层次的软件工程中,回调函数在底层,显示数据的类在上层,我们要如何把底层的数据显示到上层去?容易想到的是上层调用底层,如开个timer刷新,但这是不对的,你无法做到实时调用,你需要的是一个异步的机制,即底层一发生上层就能接收到。
    怎么做呢?还是一样的道理,把上层的类的对象指针传给底层,这时底层需要包含上层的头文件,但这是不对的,上层已经包含了底层的头文件,它们不能互相包含,如何解决这个问题?那就要用到C++继承的特性,首先在底层定义一个基类,然后在上层继承它,在上层实例化这个继承类后,将其指针设置给底层,底层对该指针的操作就是对继承类对象的操作,以此实现数据的传递。
    这里就不贴代码了,思想是这样的,很多情况下需要实际问题实际分析,欢迎讨论。

    展开全文
  • C++实现回调函数

    2020-09-04 18:52:47
    回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,我们就说这是回调函数回调函数不是由该函数的实现方直接调用,而是在特定...

    一、定义

    回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,我们就说这是回调函数。回调函数不是由该函数的实现方直接调用,而是在特定的事件或条件发生时由另外的一方调用的,用于对该事件或条件进行响应。

    回调函数机制:
    1、定义一个函数(普通函数即可);
    2、将此函数的地址注册给调用者;
    3、特定的事件或条件发生时,调用者使用函数指针调用回调函数

    实例一

    #include <stdio.h>
    typedef int(*callback)(int,int);
    
    int add(int a,int b,callback p){
        return (*p)(a,b);
    }
    
    int add(int a,int b){
        return a+b;
    }
    int main(int argc,char *args[]){
        int res = add(4,2,add);
        printf("%d\n",res);
        return 0;
    }

    在这个例子中,可以看到,我们定义了一个callbak的函数指针,参数为两个int,返回值为int,通过调用函数地址来进行简单的相加运算。 

    二、C++中如何将类成员函数作为回调函数使用,必须是静态方法吗?

    必须是静态成员函数或者全局函数来实现回调函数。
    大概原因是普通的C++成员函数都隐含了一个传递函数作为参数,即this指针,C++通过传递this指针给成员函数从而实现函数可以访问C++的数据成员。由于this指针的原因,使得一个普通成员函数作为回调函数时就会因为隐含的this指针问题使得函数参数个数不匹配,从而导致回调函数编译失败。

    实例二

    #include <iostream>
    #include <stdio.h>
    using namespace std;
    
    typedef enum
    {
    	CB_MOVE = 0,    //    
    	CB_COMEBACK,    //  
    	CB_BUYEQUIIP,   //  
    }cb_type;
    
    typedef void(*cb_func)(void *);
    
    class CCommu //模块类  
    {
    public:
    	CCommu()
    	{//初始化函数指针数组
    		memset(func_list, 0, sizeof(cb_func) *(CB_BUYEQUIIP + 1));
    		memset(func_args, 0, sizeof(void *) *(CB_BUYEQUIIP + 1));
    	}
    
    	int reg_cb(cb_type type, cb_func func, void *args = NULL)//注册回调函数   
    	{
    		if (type <= CB_BUYEQUIIP)
    		{
    			func_list[type] = func;
    			func_args[type] = args;
    			return 0;
    		}
    	}
    public:
    	cb_func func_list[CB_BUYEQUIIP + 1];   //函数指针数组  
    	void * func_args[CB_BUYEQUIIP + 1];
    };
    
    class CGameStart
    {
    
    public:
    	CGameStart();
    	~CGameStart();
    	void Init();
    	void run();
    	void Execute();
    
    	//一些回调函数  
    	void static Move(void *args);
    	void static Comeback(void *args);
    	void static Buyequip(void *args);
    
    public:
    	CCommu *pCommu;
    
    };
    
    CGameStart::CGameStart() :pCommu(NULL)
    {}
    
    void CGameStart::Init() //初始化的时候,注册回调函数   
    {
    	pCommu = new CCommu;
    	pCommu->reg_cb(CB_MOVE, Move, this);
    	pCommu->reg_cb(CB_COMEBACK, Comeback, this);
    }
    
    void CGameStart::run()
    {
    	Init();
    }
    
    void CGameStart::Execute()
    {
    	cout << "callback funciton is running" << endl;
    
    }
    CGameStart::~CGameStart()
    {
    	if (pCommu != NULL)
    	{
    		delete pCommu;
    		pCommu = NULL;
    	}
    }
    
    void CGameStart::Move(void *args)
    {
    	CGameStart *pGame = (CGameStart *)args;
    	pGame->Execute();
    }
    void CGameStart::Comeback(void *args)
    {
    	//char *str = (char *)args;  
    	//cout << str <<endl;  
    }
    
    
    
    
    int main()
    {
    	CGameStart *pGame = new CGameStart;
    	pGame->run();
    	if (pGame->pCommu->func_list[CB_MOVE] != NULL)//回调函数的触发  
    	{
    		pGame->pCommu->func_list[CB_MOVE](pGame->pCommu->func_args[CB_MOVE]);
    	}
    }

    参考:

    https://blog.csdn.net/yidu_fanchen/article/details/80513359

    https://blog.csdn.net/yidu_fanchen/article/details/80513359

    展开全文
  • C++ 静态回调函数

    2019-10-31 14:02:14
    注册回调函数时,要求回调函数必须是静态函数或全局函数。 如果使用全局函数,会毁坏类的封装性; 如果在类中不使用static属性的回调函数,则会出现“invalid use of non-static function”的编译错误。 如果在...

    在注册回调函数时,要求回调函数必须是静态函数或全局函数。

    • 如果使用全局函数,会毁坏类的封装性;
    • 如果在类中不使用static属性的回调函数,则会出现“invalid use of non-static function”的编译错误。
    • 如果在类Class A中使用static属性,将使得该回调函数只能访问类中的静态成员,而无法访问非静态成员,这常常不能满足实际应用的要求。

    于是,进入尴尬境地。

     

    为了保持callback function依然为static,同时又能访问类中的所有成员,有两种方法。

    第一种方法

    将一个指向类实例的指针作为callback function的参数传递进去,通过该指针调用类的非静态成员。

    • 有些回调函数有固定的定义,无法接受额外的参数,如 A* p_this。
    • 但也有些回调函数有考虑这个问题,提供user_data作为参数传递到回调函数当中。以下二例说明。

    例1,在libusb中,函数libusb_fill_bulk_transfer调用时需要注册一个回调函数 xfer_callback,而在xfer_callback中需要访问类中的非静态成员,怎么办呢?

    先看libusb_fill_bulk_transfer的定义:

    static void libusb_fill_bulk_transfer	(	
    struct libusb_transfer * 	transfer,
    libusb_device_handle * 	dev_handle,
    unsigned char 	endpoint,
    unsigned char * 	buffer,
    int 	length,
    libusb_transfer_cb_fn 	callback,
    void * 	user_data,
    unsigned int 	timeout 
    )		
    
    Parameters:
    transfer	the transfer to populate
    dev_handle	handle of the device that will handle the transfer
    endpoint	address of the endpoint where this transfer will be sent
    buffer	        data buffer
    length	        length of data buffer
    callback	callback function to be invoked on transfer completion
    user_data	user data to pass to callback function
    timeout	        timeout for the transfer in milliseconds
    

    在libusb_fill_bulk_transfer中,提供了一个user_data的函数参数(第7个参数)用于传递在xfer_callback中所需要的数据(如类中的非静态成员)。

    libusb_fill_bulk_transfer (transfers, dev_handle, endpoint_stream,
                               databuffers[i], reqsize * pktsize, xfer_callback, this, 500);

    在这里,我们将类的指针this作为user_data传递进去。libusb_fill_bulk_transfer做的事情是把this传递到transfers中(在transfer的结构定义中包含user_data),而transfers又是 xfer_callback 唯一的参数(xfer_callback的定义是固定的,为libusb_transfer_cb_fn),从而实现将this传递进xfer_callback的目的。进而,在xfer_callback就能够通过this指针访问类中的所有成员。

     

    例2,类似地,在C++多线程编程中,在构造新的线程时,需要注册一个回调函数。如果回调函数是定义在类当中,同时又需要访问类中的其它非静态成员,那么就不能使用

    std::thread thread_ros(thread_ros_proc_func);

    来初始化,而可以使用

    std::thread thread_ros(&classname::thread_ros_proc_func, this);

    来初始化。

     

    第二种方法

    我们会自然想到在类中再定义一个static pointer指向这个类的对象,这样在static callback function中就可以通过调用static pointer来合理访问类对象当中的成员,包括static member和non-static member。如下:

    class A()
    {
        static void a(); //静态回调函数
        void b();  //非静态函数 
        static A * pThis;   //静态对象指针
    }
    
    A * A::pThis=NULL;
    A::A()   //构造函数中将this指针赋给pThis,使得回调函数能通过pThis指针访问本对象
    {
        pThis=this;
    }
    void A::a()
    {
        if (pThis==NULL) return;
        pThis->b(); //回调函数中调用非静态函数 
    }

     

    但再仔细一想,由于该指针的static属性,使得它只能指向一个类的对象。当有多个类的实例对象时,就会出现问题。

    下面给出一种方法解决多个类实例对象时static pointer只能指向一个对象的尴尬。

    用映射表存所有对象地址,每个对象保存自己的ID号。

      typedef CMap<UINT,UINT,A*,A*> CAMap;
      class A()
      {
          static void a(); //静态回调函数
          void b();  //非静态函数 
          int m_ID;  //本对象在列表中的ID号
          static int m_SID;   //静态当前对象ID        (需要时,将m_ID赋值给m_SID以起到调用本对象函数的功能)
          static CAMap m_Map; //静态对象映射表
      }  
      
      CAMap A::m_Map;
      int   A::m_SID=0;
      
     
      A::A()   //构造函数中将this指针赋给pThis,使得回调函数能通过pThis指针访问本对象
      {
          if(m_Map.IsEmpty())
          {
             m_ID=1;
          }
          else
          { 
            m_ID=m_Map.GetCount()+1;
          }
          m_Map.SetAt( m_ID, this );
      }
      void A::a()
      {
          if (m_Map.IsEmpty()) return;
          A * pThis=NULL;
          if(m_Map.Lookup(m_SID,pThis))
          {
             pThis->b(); //回调函数中调用非静态函数 
          };
      }

     

     

    Reference:

    How to pass callback function to libusb bulk transfer function in C++ Class

    how to pass a non static-member function as a callback?

    C++将类的成员函数作为回调函数 - qing666888的专栏 - CSDN博客

    展开全文
  • C++11 回调函数

    2019-10-25 01:31:08
    在最新的C++11中,引入了std::function和std::bind,让我们更方便使用回调函数(这样回调函数就不必是static的了) 一 声明指针函数,模板类 Common.h #include <functional> //一定要 typedef std::function&...
  • C++回调函数详解

    2015-07-31 13:50:43
    我们经常在C++设计时通过使用回调函数可以使有些应用(如定时器事件回调处理、用回调函数记录某操作进度等)变得非常方便和符合逻辑,那么它的内在机制如何呢,怎么定义呢?它和其它函数(比如钩子函数)有何不同呢?...
  • 从C#注入回调函数C++编写的Dll中网上可以看到很多方法,但是反过来就麻烦多了。 回调函数的本质就是传递一个函数地址给相应的函数进行处理。所以C++往C#中注入回调函数,所需要解决的问题就是,C++的函数要怎么传...
  • 应用c++11实现c++线程回调函数调用类成员函数方法
  • OC & C++运用回调函数

    千次阅读 2014-04-09 11:37:47
    OC & C++运用回调函数 两种方式: 1、参数传递 全局:自定义一种CallBackFunc类型的函数指针 typedef void (*CallBackFunc)(); 在类 A(OC)中 定义回调函数的实现:  void playCallback() {  // ...
  • C++回调函数

    2013-06-25 20:22:17
    在C中写回调函数非常方便,C++中定义回调函数要麻烦一些,成员函数牵涉到一个this指针问题。C++中的static成员函数没有this指针,也可以直接作为回调函数使用。C++的成员函数地址是唯一确定的,数据变量地址是可变的...
  • 采集类A封装成dll,类B是包含A的导出类,如今想要将每次得到的二维码信息实时显示在应用dll的对话框类C中,使用回调函数实现。 实现过程: ①采集类A中定义函数指针: typedef void (*ptrFun)(PVOID pWnd, vector&...
  • c++回调函数

    2020-05-08 21:00:03
    本例子将回调函数注册到一个map中,在消息类触发的服务器应用中常见,比如游戏服务器 话不多说:直接上代码 版本1:定义一个指向函数的指针 CallBack.h #ifndef __CALLBACK_H__ #define __CALLBACK_H__ #include &...
  • C++回调函数用法

    千次阅读 2013-10-24 19:50:56
    我们经常在C++设计时通过使用回调函数可以使有些应用(如定时器事件回调处理、用回调函数记录某操作进度等)变得非常方便和符合逻辑,那么它的内在机制如何呢,怎么定义呢?它和其它函数(比如钩子函数)有何不同呢?...
  • C++回调函数示例

    2015-04-18 23:04:21
    (2)提供函数实现的一方在初始化的时候,将回调函数的函数指针注册给调用者。 (3)当特定的事件或者条件发生的时候,调用者使用函数指针调用回调函数对事件进行处理。 回调函数示例: 正常函数: int main() { ...
  • 浅谈C++回调函数

    千次阅读 2018-02-28 22:09:30
    1.什么是回调函数? 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,我们就说这是回调函数回调函数不是由该函数的实现方...
  • C++调用C#注册回调函数

    千次阅读 2017-12-28 19:12:01
    本文主要讲解C#注册回调函数提供给C++调用,用于异步通知机制。这在编程过程中是经常需要用到的模式。 此过程需要创建三个工程: 1. C++动态库工程 2. C++ CLR 托管动态库工程 3. C# 测试工程 接着前文C++封装...
  • 1.回调函数基本定义 什么是函数指针 通俗来说,函数指针是一个指向特定函数的指针。函数的类型由其参数及返回类型共同决定,与函数具体名称无关。示例代码如下: int testFun1(int param1,long param2,float ...
  • C++回调函数的一个简单例子?

    万次阅读 多人点赞 2016-01-08 14:13:57
    回调函数应用实例: 1、定义一个Person类 (Person.h)文件: 注意:在这个类中指定了回调函数回调函数的执行者,和回调函数指针 重要的是  回调函数回调函数指针是怎么关联的? 2、Person类的具体实现...
  • C++ 回调函数

    2011-07-15 18:14:18
    回调函数我们经常在C++设计时通过使用回调函数可以使有些应用(如定时器事件回调处理、用回调函数记录某操作进度等)变得非常方便和符合逻辑,那么它的内在机制如何呢,怎么定义呢?它和其它函数(比如钩子函数)有...
  • C++ bind与回调函数

    2020-04-20 23:35:00
    函数1,2 为一个模块,为回调函数,函数3为一个模块,为注册回调函数,形参为函数指针 注册回调函数的入参为函数指针,指向回调函数,回调函数实际就是指针类型的实例化 与类无关的回调函数 void basketball()//...
  • Objective C++实现回调函数

    千次阅读 2012-07-22 22:35:55
    下面为大家介绍一下在Objective C++中怎么样去实现回调,大家都知道Object C 与 C++ 混编的时候,是不能用Cocoa 自带的委托机制来实现回调的。比如在做一些多平台的项目时,由于接口是c++编写的,这个时候你要怎么样...
  • 回调函数c++实现

    2017-06-02 15:26:25
    C++中如何将类成员函数作为回调函数使用,必须是静态方法吗? 必须是静态成员函数或者全局函数来实现回调函数 大概原因是普通的C++成员函数都隐含了一个传递函数作为参数,即this指针,C++通过传递this指针给...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,506
精华内容 13,002
关键字:

c++注册回调函数

c++ 订阅