C++类成员的CALLBACK

本文通过一个小案例介绍了CEGUI中CALLBACK机制的工作原理。详细解释了如何定义消息映射类MessageMap及其成员函数,并通过SendMessage类实现不同消息的传递与处理。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

这几天在用CEGUI,学习了一下他的CALLBACK原理,写了一个小CASE
FOLLOWING IS IT:
// main.cpp : Defines the entry point for the console application.
//

#include 
"stdafx.h"
#include 
<string>
#include 
<iostream>
#include 
<map>

class MessageMap//功能类,调用对象
{
public:
    MessageMap()
    
{

    }

    
~MessageMap()
    
{

    }

    
int print(int para1,int para2)
    
{
        std::cout
<<"Para1="<<para1<<std::endl;
        std::cout
<<"para2="<<para2<<std::endl;
        
return 1;
    }


    
int add(int para1,int para2)
    
{
        std::cout
<<"para1+para2="<<para1+para2<<std::endl;
        
return 1;
    }

}
;

typedef 
int (MessageMap::*MemberFunction)(int ,int );//Callback函数原型

class FuncCode//函数的从属关系
{

public:
    FuncCode(MessageMap
* pObj,MemberFunction pFun)
    
{
        obj
=pObj;
        fun
=pFun;
    }

public:

    MessageMap
* obj;
    MemberFunction fun;
}
;

class SendMessage//调用类
{
public:
    SendMessage()
    
{

    }

    
~SendMessage()
    
{
        FunMapIterator itend
=funmap.end();
        
for (FunMapIterator it=funmap.begin ();it!=itend;it++)
        
{
            delete it
->second;
        }

        funmap.clear ();
    }

    
int addMessageFunction(std::string msg,int (MessageMap::*fun)(int,int),MessageMap* pobj)
    
{
        funmap[msg]
=new FuncCode(pobj,fun);
        
return 1;
    }

     
int operator()(std::string msg,int para1,int para2)
    
{
         
return ((funmap[msg]->obj)->*(funmap[msg]->fun))(para1,para2);
        
    }

protected:
    typedef std::map
<std::string,FuncCode*> FunMap;
    typedef std::map
<std::string,FuncCode*>::iterator FunMapIterator;
    FunMap funmap;
}
;

int _tmain(int argc, _TCHAR* argv[])
{
    MessageMap
* pObj= new MessageMap();
    SendMessage SendMsg;
    
{//初始化
        SendMsg.addMessageFunction ("print",&MessageMap::print,pObj);
        SendMsg.addMessageFunction (
"add",&MessageMap::add,pObj);
    }


    
{//调用
        SendMsg("print",1,2);
        SendMsg(
"add",1,2);
    }


    delete pObj;
    
return 0;
}


//说明
//1、这种调用可以用类模板扩展,其实这是一个CALLBACK简略版,有兴趣的话可以参考CEGUI源码,里面用的是类模板
//,这样的话将不再受类型(MESSAGEMAP)的限制。
//
//2、对于int addMessageFunction(std::string msg,int (MessageMap::*fun)(int,int),MessageMap* pobj)
//的参数问题,主要说明int (MessageMap::*fun)(int,int)。
//这是一个很有意思的参数,他的类型为int (MessageMap::*)(int,int),值为 fun,有兴趣的可以看看ASM的传参过程
//,其实这里可以用MemberFunction fun代替,当然用模板的话会有所不同,参考CEGUI.
//3.不要把typedef int (MessageMap::*MemberFunction)(int ,int ) 定义成
//typedef int (*MemberFunction)(int ,int ),这是代码的关键所在,一般的C++BOOK都会提及他们的不同之处。




### C++ 中回调函数的使用与实现 在 C++ 中,回调函数是一种常见的设计模式,用于在某个事件发生时通知调用方执行特定的操作。以下是几种常见的实现方式: #### 1. 使用函数指针作为回调 这是最基础的方式之一,通过将一个函数地址传递给另一个函数来实现回调。 ```cpp // 定义回调函数类型 typedef void (*CallbackFunction)(int); // 接收回调函数的函数 void executeWithCallback(CallbackFunction callback, int value) { callback(value); } // 回调函数实现 void myCallback(int value) { std::cout << "Callback received value: " << value << std::endl; } int main() { // 调用并传递回调函数 executeWithCallback(myCallback, 42); return 0; } ``` 这种方式简单直接,但存在局限性:它只能处理全局函数或静态成员函数,无法直接处理非静态成员函数[^4]。 #### 2. 使用 `std::function` 和 Lambda 表达式 `std::function` 是 C++11 引入的一个通用函数包装器,可以存储任何可调用对象(如函数、Lambda 表达式或绑定表达式)。结合 Lambda 表达式,这种方式更加灵活且现代。 ```cpp #include <iostream> #include <functional> // 接收 std::function 类型的回调 void executeWithCallback(const std::function<void(int)>& callback, int value) { callback(value); } int main() { // 使用 Lambda 表达式作为回调 executeWithCallback([](int value) { std::cout << "Callback received value: " << value << std::endl; }, 42); return 0; } ``` 这种方式的优势在于它可以封装任意类型的可调用对象,包括非静态成员函数和捕获上下文的 Lambda 表达式[^1]。 #### 3. 使用类的非静态成员函数作为回调 如果需要将类的非静态成员函数作为回调,可以通过组合函数指针和对象指针的方式实现。 ```cpp #include <iostream> class ProgramA { public: void FunA1() { std::cout << "I'm ProgramA.FunA1() and be called.." << std::endl; } void FunA2() { std::cout << "I'm ProgramA.FunA2() and be called.." << std::endl; } }; class ProgramB { public: void FunB1(void (ProgramA::*callback)(), ProgramA* context) { std::cout << "I'm ProgramB.FunB1() and be called.." << std::endl; (context->*callback)(); } }; int main() { ProgramA PA; ProgramB PB; // 调用非静态成员函数作为回调 PB.FunB1(&ProgramA::FunA2, &PA); return 0; } ``` 这种方式允许回调函数访问类的成员变量和方法,解决了静态函数不能访问非静态成员的问题。 #### 4. 使用 `std::bind` 绑定回调 `std::bind` 是一种将函数与参数绑定在一起的工具,可以用于创建回调函数。 ```cpp #include <iostream> #include <functional> class MyClass { public: void myMethod(int value) { std::cout << "Callback in MyClass: " << value << std::endl; } }; void executeWithCallback(const std::function<void()>& callback) { callback(); } int main() { MyClass obj; auto boundCallback = std::bind(&MyClass::myMethod, &obj, 42); executeWithCallback(boundCallback); return 0; } ``` 这种方式适用于需要提前绑定部分参数的情况[^1]。 #### 5. 结合 JNI 实现跨语言回调 在 C++ 和 Kotlin/Java 等其他语言交互时,可以通过 JNI 实现回调机制。 ```cpp // 假设这是 C++ 的 JNI 方法 extern "C" { JNIEXPORT void JNICALL Java_com_example_NativeLib_nativeCallback(JNIEnv* env, jobject obj, jobject callback) { jclass callbackClass = env->GetObjectClass(callback); jmethodID methodId = env->GetMethodID(callbackClass, "onDataReceived", "(Ljava/lang/String;)V"); const char* data = "Hello from C++"; jstring jstr = env->NewStringUTF(data); env->CallVoidMethod(callback, methodId, jstr); } } ``` Kotlin 侧定义接口并实现回调逻辑: ```kotlin interface DataCallback { fun onDataReceived(data: String) } fun main() { val callback = object : DataCallback { override fun onDataReceived(data: String) { println("Received data: $data") } } nativeCallback(callback) } ``` 这种方式适用于需要跨语言调用的场景[^2]。 ### 总结 C++ 中的回调函数可以通过多种方式实现,每种方式都有其适用场景: - 函数指针适合简单的全局函数回调。 - `std::function` 和 Lambda 表达式提供更高的灵活性。 - 非静态成员函数结合对象指针可以访问类内部状态。 - `std::bind` 适用于参数预绑定的场景。 - JNI 可用于跨语言回调。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值