代码如下：
#include <iostream.h>
 // ================= 定义三个类
class Ctest0 {                    // class 0
public:
    void    __cdecl fn0() {
        cout<<"test0"<<endl;
    }
};
class Ctest1 {                    // class 1
public:
    void     __cdecl fn1() {
        cout<<"test1"<<endl;
    }
};
class Ctest2 {                    // class 2
public:
    void    __cdecl fn2() {
        cout<<"test2"<<endl;
    }
};
void main() {
    Ctest0 t0;                    // 实例化三个对象
    Ctest1 t1;
    Ctest2 t2;
    typedef    void (*Fun[3])();
    Fun        f ;                    // 定义一个指针函数数组
    f[0] = t0.fn0;                // ！！！编译出错
    f[1] = t1.fn1;                // ！！！编译出错
    f[2] = t2.fn2;                // ！！！编译出错
    for(int i=0;i<3;i++)        // 通过数组调用个对象中的功能函数
        f[i]();
}
编译出错提示（3个同样的错误）：
...cannot convert from 'void (__cdecl Ctest0::*)(void)' to 'void (__cdecl *)(void)'
如果把类中fn0()函数声明中的"__cdecl"去掉。则出错提示如下：
...cannot convert from 'void (__stdcall Ctest0::*)(void)' to 'void (__cdecl *)(void)'

    该程序是实际编程遇到的问题的一个简化。其意图是把各类中相应的功能函数的指针放在一个数组内，以便于程序自动调用运行。这是一种常用的编程手段。但是我始终编译不成功，无法把各类函数的指针装入数组内。
    可是如果这些函数不是类的成员函数（如全局函数），就可以装入指针数组（编译通过并运行正常）。只要是类的成员函数（哪怕这些函数都集中在一个类中）就无法通过编译。出现上面的错误提示。
    此问题困惑我快一周了， c++新手恳请大家指点迷津。先谢过


[ 本帖最后由 处c 于 2010-3-12 13:33 编辑 ]

类函数做函数指针时，如下声明
typedef void ( Ctest0::*FunPtr_t )() ;
而且编译出来的三个错误在描述上是不一样的。它是三个不同类的函数在转换成函数指针时发生错误，由于这三个类不存在隐式转换，所以建议使用一个基类来解决这个问题，代码如下:

#include <map>
using namespace std;

class TestClass ;
typedef void ( TestClass::*FunPtr_t )() ;
class TestClass
{
public:
    TestClass(void){}
    virtual ~TestClass(void){}

    void registerMsg( int ID , FunPtr_t pFun ,TestClass* Member)
    {
        if ( m_vFunPtr.find( ID ) == m_vFunPtr.end() )
        {
            m_vFunPtr[ID] = pFun ;
        }
        if ( m_MemberV.find( ID ) == m_MemberV.end() )
        {
            m_MemberV[ID] = Member ;
        }
    }
    static std::map<int , FunPtr_t> m_vFunPtr ;
    static std::map<int , TestClass*> m_MemberV ;
};
std::map<int , FunPtr_t> TestClass::m_vFunPtr ;
std::map<int , TestClass*> TestClass::m_MemberV ;
class TestClass1 :
    public TestClass
{
public:
    TestClass1(){}
    virtual ~TestClass1() {}
    void Fun0(){cout<<"class TestClass1::Fun0()"<<endl;}
};
class TestClass2 :
    public TestClass
{
public:
    TestClass2(){}
    virtual ~TestClass2(){}
    void Fun0(){cout<<"class TestClass2::Fun0()"<<endl;}
};
int _tmain(int argc, _TCHAR* argv[])
{
    TestClass a;
    TestClass1 b;
    TestClass2 c;
    //注册
    a.registerMsg(1000,(static_cast< FunPtr_t >(&TestClass1::Fun0 )),&b);
    a.registerMsg(1001,(static_cast< FunPtr_t >(&TestClass2::Fun0 )),&c);

    //调用
    std::map<int , FunPtr_t>::iterator itFunP = a.m_vFunPtr.begin();
    for ( ; itFunP !=a.m_vFunPtr.end() ; ++itFunP )
    {
        std::map<int , TestClass*>::iterator itMember = a.m_MemberV.find(itFunP->first);
        if ( itMember != a.m_MemberV.end() )
        {
            ((itMember->second)->*(itFunP->second))() ;
        }
    }
    return 0;
}

多谢版主回复~研究ing。。。