c++委托中涉及到类成员函数指针的问题

[freshow]

// 委托类
#ifndef _DELEGATE_H_
#define _DELEGATE_H_

#include <list>
using namespace std;

typedef unsigned int NativePtr;         // 用于存储函数指针
typedef void (*FuncHandler)(void);      // 如果是多个不同的类，这里就要定义多个不同的类成员指针？？？

class CDelegate
{
public:    
    // 实现对列表中的函数逐个调用
    void Invoke(void)
    {
        FuncHandler handle;
        list<NativePtr>::iterator Iter = m_listFPter.begin();
        for (; Iter != m_listFPter.end(); Iter++)
        {
            handle = (FuncHandler)*Iter;
            handle();
        }        
    }

    // 运算符重载 AddFun
    void operator +=(void* vFunPtr)
    {
        this->AddFun(vFunPtr);
    }

    // 运算符重载 RemFun
    void operator -=(void* vFunPtr)
    {
        this->RemFun(vFunPtr);
    }

    // 运算符重载 Invoke
    void operator()(void)
    {
        this->Invoke();
    }

private:
    list<NativePtr> m_listFPter;    // 函数列表，被添加的函数指针都放在该列表中
};

#endif  // _DELEGATE_H_

// 2个简单的测试类
class Class A
{
public:    

    void FunA(void)
    {        
    }
};

class Class B
{
public:    

    void FunB(void)
    {        
    }
};

  
// 测试的客户端类  
A* pObA = NULL;
pObA = new A();    

if (NULL != pObA)
{
    FuncHandler HandlerA = (FuncHandler)(pObA->FunA()); // 这样调用不行，因为FuncHandler不是类A成员函数指针
}

问题：如果是多个不同的类，这里就要定义多个不同的类成员函数指针？

[soulzbg]

呃，貌似很负责的东东。学C的飘过

[taodm]

呃，boost::function，现成的。

[jixingzhong]

如果是多个不同的类，这里就要定义多个不同的类成员指针？？？

是的

[jixingzhong]

不过你可以考虑是否可以抽象个基类，将方法定义为virtual以实现你的功能，比如这样：
BASE* pObBase = new A();
可以考虑直接用pObBase->Fun();访问A的成员方法（Fun为virtual）

参考一下多态相关的内容。

[机智的呆呆]

如果被委托的对象都有一个公共基类，那么只需要一个基类的成员函数指针即可。
以前写的代码，lz可以参考一下：

#include <iostream>
#include <map>
using namespace std;
class Subscriber
{

};
class Pulisher
{
private:
	map <Subscriber*,void (Subscriber::*)()> subscribers;
public:
	void Print(){cout<<"Base"<<endl;}
	void AddSubscriber(Subscriber* obj ,void (Subscriber::*memf)())
	{
		subscribers.insert(pair<Subscriber*,void (Subscriber::*)()>(obj,memf));
	}
	void publish()
	{
		map<Subscriber*,void (Subscriber::*)()>::iterator it=subscribers.begin();
		for (;it!=subscribers.end();it++)
		{
			void (Subscriber::*memf)()=it->second;
			(it->first->*memf)();
		}
	}
};

class A:public Subscriber
{
public:
	void PrintA(){cout<<"A"<<endl;}
};
class B:public Subscriber
{
public:
	void PrintB(){cout<<"B"<<endl;}
};
class C:public Subscriber
{
public:
	void PrintC(){cout<<"C"<<endl;}
};

int main()
{
	Pulisher pulisher;
	pulisher.AddSubscriber(new A(),(void (Subscriber::*)())&A::PrintA);
	pulisher.AddSubscriber(new B(),(void (Subscriber::*)())&B::PrintB);
	pulisher.AddSubscriber(new C(),(void (Subscriber::*)())&C::PrintC);
	pulisher.publish();
	system("pause");
}