如何根据函数名称返回对应的函数指针？

[linyu0716]

我想写一个函数，函数返回类型是函数指针，入参是字符串，如何才能根据入参去返回对应的函数指针？
如下这段代码：

int add(int a, int b)
{
return a+b;
}

int sub(int a, int b)
{
return a-b;
}

typedef int(*Func)(int,int);

Func GetFuncname(char * funcname)
{
//如何实现根据funcname返回是add还是sub?
}

[taodm]

函数指针和字符串建立一个表

[ww884203]

strcmp怎么样

[ztenv]

[Quote=引用 1 楼 taodm 的回复:]
函数指针和字符串建立一个表
[/Quote]
c++貌似只能这样吧不知道有没有类似反射的东东可用，

[linyu0716]

to taodm:
建一个表如何解决？

[ww884203]

建立表更高

[linyu0716]

[Quote=引用 2 楼 ww884203 的回复:]

strcmp怎么样
[/Quote]

这个怎么实现？不会是if else吧？我不想这样搞

[ayw215]

typedef struct _Map
{
char* funcname;
void (*func)(int);
} Map;
Map mapping[10]={.......}

[TomTanks]

用宏也可以。
int add(int, int);
int sub(int, int);

typedef int(*Func)(int,int);

#define GetFuncname(fn) fn

int main(void)
{
Func func;
func = GetFuncname(add);
printf("%d\n", func(1, 2));
func = GetFuncname(sub);
printf("%d\n", func(1, 2));
return 0;
}

int add(int a, int b)
{
return a+b;
}

int sub(int a, int b)
{
return a-b;
}
这段代码在codepad.org上编译通过，运行结果是：
3
-1

[linyu0716]

[Quote=引用 7 楼 ayw215 的回复:]

typedef struct _Map
{
char* funcname;
void (*func)(int);
} Map;
Map mapping[10]={.......}
[/Quote]
如果能这样的话，我早就用map来实现了，能否不预先设置字符串与函数的对应关系，直接取得函数指针？

[taodm]

你当C/C++语言是lua啊。

[pengzhixi]

C++没有类似反射之类的东西

[linyu0716]

[Quote=引用 8 楼 tomtanks 的回复:]

用宏也可以。
int add(int, int);
int sub(int, int);

typedef int(*Func)(int,int);

#define GetFuncname(fn) fn

int main(void)
{
Func func;
func = GetFuncname(add);
printf("%d\n", fun……
[/Quote]
这个比较接近了，那如果参数是个字符串就不行了，那有什么方法可以将"add"转换成add呢？用宏怎么实现？

[controstr]

typedef int(*Func)(int,int);
int add(int, int);
int sub(int, int);

#define BEGIN_FUN_MAP(thecls)\
    Func thecls::getFuncName(char *szFunName)\
    {\

#define FUN_EVENT(str, fun)\
    if ( !strcmp(str, "add") )\
        return fun;

#define END_FUN_MAP()\
        return NULL;
    }


// 用法
class FunObj
{
public:
    BEGIN_FUN_MAP(FunObj)
    FUN_EVENT("add", add)
    FUN_EVENT("sub", sub)
    END_FUN_MAP()
}

[rendao0563]

#include <iostream>
#include <string>
#include <map>
using namespace std;

template<class TKey, class TCallBack>
class CCallBackBase
{
public:
    typedef typename std::map<TKey, TCallBack> MapCallBack;
    typedef typename std::map<TKey, TCallBack>::iterator MapCallBackIt;

    virtual bool Init()
    {
        return true;
    }

    bool Register(TKey _1, TCallBack _2)
    {
        MapCallBackIt It = m_mapCallBacks.find(_1);
        if (It != m_mapCallBacks.end())
        {
            return false;
        }

        m_mapCallBacks[_1] = _2;
        return true;
    }

    TCallBack FindCallBack(TKey _1)
    {
        MapCallBackIt It = m_mapCallBacks.find(_1);
        if (It == m_mapCallBacks.end())
        {
            return NULL;
        }

        return It->second;
    }

private:
    MapCallBack m_mapCallBacks;
};

typedef int (*CallBack)(const std::string &strBuf);

class CCallBackHandler : public CCallBackBase<std::string, CallBack>
{
public:
    CCallBackHandler()
    {
        Init();
    }
    virtual bool Init()
    {
        if (Register("Test1", &CCallBackHandler::OnTest1)
            && Register("Test2", &CCallBackHandler::OnTest2))
        {
            return true;
        }
        assert(0);
        return false;
    }

    void Call(const std::string &strKey, const std::string &strBuf)
    {
        CallBack pCallBack = FindCallBack(strKey);
        if (NULL != pCallBack)
        {
            (*pCallBack)(strBuf);
        }
    }

    static int OnTest1(const std::string &strBuf)
    {
        cout << strBuf << endl;
        return 0;
    }
    static int OnTest2(const std::string &strBuf)
    {
        cout << strBuf << endl;
        return 0;
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    CCallBackHandler oCallBackHandler;

    oCallBackHandler.Call("Test1", "测试 调用OnTest1");
    oCallBackHandler.Call("Test2", "测试 调用OnTest2");
    return 0;
}

LZ是这个意思吗?