C++解析字符串，调用函数

using namespace RTT::detail;


template<typename SigT,typename FounctionT>
class MethodRegst
{
};


class DatapramBase
{
public:
int m_numparam;
};


class DataSourceBase
{
public:
virtual std::string getType() const = 0;
};


template<typename T>
class DataSource
:public DataSourceBase
{


public:
//virtual T produce() = 0;
T result_t;


virtual T value() const = 0;


virtual void SetArgs(DatapramBase dataIn)  = 0;


std::string getType() const
{
std::string dddds = typeid(T).name();
return dddds;
}
};


//boost::function<SignatureT>


template<typename FunctorT>
struct FunctorDataSource0
: public DataSource< typename FunctorT::result_type >
{
typedef typename FunctorT::result_type value_t;
//mutable FunctionForwarder<value_t, FunctorT> ff;
typename FunctorT ff;
public:
//typedef boost::intrusive_ptr< FunctorDataSource0<FunctorT> > shared_ptr;


FunctorDataSource0(FunctorT g)
: ff(g)
{
}


void SetArgs(DatapramBase dataIn) const
{
return;
}


value_t value() const
{
//return ff.invoke();
return g();
}
};


template<typename FunctorT, typename Arg1T>
struct FunctorDataSource1
: public DataSource< typename FunctorT::result_type >
{
typedef typename FunctorT::result_type value_t;
typename Arg1T arg1;
typename FunctorT ff;

public:

FunctorDataSource1(FunctorT g)
: ff(g), arg1(10)
{
}


void setArguments(Arg1T a1)
{
arg1 = a1;
}


void SetArgs(DatapramBase dataIn) 
{
arg1 = dataIn.m_numparam;
return;
}

value_t value() const
{
return ff(arg1);
}
};

template<int, class F>
struct FunctorDataSourceI;

template<class F>
struct FunctorDataSourceI<0, F>
: public FunctorDataSource0<F>
{
FunctorDataSourceI(F f)
: FunctorDataSource0<F>(f) {}
};


template<class F>
struct FunctorDataSourceI<1, F>
: public FunctorDataSource1<F, typename F::arg1_type>
{
FunctorDataSourceI(F f)
: FunctorDataSource1<F, typename F::arg1_type>(f) {}
};


template<class F>
struct FunctorDataSource
: public FunctorDataSourceI<F::arity, F>
{
FunctorDataSource(F f)
: FunctorDataSourceI<F::arity, F>(f) {}
};


class taskkk
{
public:


taskkk()
{
}
~taskkk()
{
}


typedef std::map<std::string, DataSourceBase*> map_t;
map_t m_data;




template<typename F>
void AddMethod(std::string name, F g)
{
m_data.insert(std::make_pair(name, new FunctorDataSource<F>(g)));
}


void setArgs(std::string name, DatapramBase dataIn)
{
DataSourceBase* dds = m_data[name];
std::string reultTypeStr = dds->getType();


if (reultTypeStr == "int")
{
DataSource<int>* ret = dynamic_cast< DataSource<int>* >(dds);
if (ret)
{
ret->SetArgs(dataIn);
//ret->value();
}
}
}


void getMethod(std::string name)
{
DataSourceBase* dds = m_data[name];
std::string reultTypeStr = dds->getType();


if (reultTypeStr == "int")
{
DataSource<int>* ret = dynamic_cast< DataSource<int>* >(dds);
if (ret)
{
//ret->SetArgs()
ret->value();
}
}
}
};




int test1(int dataIn)
{
printf("------%d--------\r\n", dataIn);
return 22;
}


int main()
{
taskkk ddd;
ddd.AddMethod< boost::function<int(int) >>("test", boost::bind(&test1, _1));
DatapramBase  dParam;
dParam.m_numparam = 30;
ddd.setArgs("test",dParam);
ddd.getMethod("test");
    return 0;
}

代码结构主要是通过模板和boost::function，把函数绑定到map中，然后查找名字。在函数绑定时通过

typedef typename FunctorT::result_type value_t;
typename Arg1T arg1;
typename FunctorT ff;

把参数和函数指针都作为成员，在value中进行调用。

这样就可以达到解析一个函数字符串，并调用对应的函数。这是脚本的的基础，有了这个接口，就可以使用lua、python等脚本动态调用C++程序中的函数，只要把字符串传到程序中解析就可以了。

这是一个思路例子，完善的工作就是细节的工作了。