我想用类名和方法，唯一标识符和指向方法的指针填充地图。
typedef std::map<std::string, std::string, std::string, int> actions_type;
typedef actions_type::iterator actions_iterator;
actions_type actions;
actions.insert(make_pair(class_name, attribute_name, identifier, method_pointer));
//after which I want call the appropriate method in the loop
while (the_app_is_running)
{
std::string requested_class = get_requested_class();
std::string requested_method = get_requested_method();
//determine class
for(actions_iterator ita = actions.begin(); ita != actions.end(); ++ita)
{
if (ita->first == requested_class && ita->second == requested_method)
{
//class and method match
//create a new class instance
//call method
}
}
}
如果方法是静态的，那么一个简单的指针就够了，问题很简单， 但我想动态创建对象，所以我需要存储一个指向类的方法和方法的偏移量，我不知道这是否有效（如果偏移量始终相同等）。
问题在于C ++缺乏反射，使用反射的解释语言中的等效代码应如下所示（PHP中的示例）：
$actions = array
(
"first_identifier" => array("Class1","method1"),
"second_identifier" => array("Class2","method2"),
"third_identifier" => array("Class3","method3")
);
while ($the_app_is_running)
{
$id = get_identifier();
foreach($actions as $identifier => $action)
{
if ($id == $identifier)
{
$className = $action[0];
$methodName = $action[1];
$object = new $className() ;
$method = new ReflectionMethod($className , $methodName);
$method -> invoke($object);
}
}
}
PS：是的我正在尝试用C ++制作一个（web）MVC前端控制器。 我知道我知道为什么不使用PHP，Ruby，Python（在这里插入你最喜欢的网络语言）等等，我只想要C ++。
答案 0 :(得分：7)
也许您正在寻找member function pointers。
基本用法：
class MyClass
{
public:
void function();
};
void (MyClass:*function_ptr)() = MyClass::function;
MyClass instance;
instance.*function_ptr;
正如C ++ FAQ Lite中所述，使用成员函数指针时，宏和typedef会大大提高可读性（因为它们的语法在代码中并不常见）。
答案 1 :(得分：5)
我在最后几个小时写了这些东西，并把它添加到我的有用东西的集合中。如果您要创建的类型不以任何方式相关，最困难的是应对工厂功能。我为此使用了boost::variant。你必须给它一组你想要使用的类型。然后它将跟踪变体中当前“活动”类型的内容。 （boost :: variant是一种所谓的歧视联盟）。第二个问题是如何存储函数指针。问题是指向A成员的指针无法存储到指向B成员的指针。这些类型是不兼容的。为了解决这个问题，我将函数指针存储在一个重载其operator()的对象中并采用boost :: variant：
return_type operator()(variant<possible types...>)
当然，所有类型的函数都必须具有相同的返回类型。否则整场比赛只会毫无意义。现在代码：
#include <boost/variant.hpp>
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/function_types/parameter_types.hpp>
#include <boost/function_types/result_type.hpp>
#include <boost/function_types/function_arity.hpp>
#include <boost/preprocessor/repetition.hpp>
#include <map>
#include <string>
#include <iostream>
// three totally unrelated classes
//
struct foo {
std::string one() {
return "I ";
}
};
struct bar {
std::string two() {
return "am ";
}
};
struct baz {
std::string three() const {
return "happy!";
}
};
// The following are the parameters you have to set
//
// return type
typedef std::string return_type;
// variant storing an object. It contains the list of possible types you
// can store.
typedef boost::variant< foo, bar, baz > variant_type;
// type used to call a function on the object currently active in
// the given variant
typedef boost::function<return_type (variant_type&)> variant_call_type;
// returned variant will know what type is stored. C++ got no reflection,
// so we have to have a function that returns the correct type based on
// compile time knowledge (here it's the template parameter)
template<typename Class>
variant_type factory() {
return Class();
}
namespace detail {
namespace fn = boost::function_types;
namespace mpl = boost::mpl;
// transforms T to a boost::bind
template<typename T>
struct build_caller {
// type of this pointer, pointer removed, possibly cv qualified.
typedef typename mpl::at_c<
fn::parameter_types< T, mpl::identity<mpl::_> >,
0>::type actual_type;
// type of boost::get we use
typedef actual_type& (*get_type)(variant_type&);
// prints _2 if n is 0
#define PLACEHOLDER_print(z, n, unused) BOOST_PP_CAT(_, BOOST_PP_ADD(n, 2))
#define GET_print(z, n, unused) \
template<typename U> \
static variant_call_type get( \
typename boost::enable_if_c<fn::function_arity<U>::value == \
BOOST_PP_INC(n), U>::type t \
) { \
/* (boost::get<actual_type>(some_variant).*t)(n1,...,nN) */ \
return boost::bind( \
t, boost::bind( \
(get_type)&boost::get<actual_type>, \
_1) BOOST_PP_ENUM_TRAILING(n, PLACEHOLDER_print, ~) \
); \
}
// generate functions for up to 8 parameters
BOOST_PP_REPEAT(9, GET_print, ~)
#undef GET_print
#undef PLACEHOLDER_print
};
}
// incoming type T is a member function type. we return a boost::bind object that
// will call boost::get on the variant passed and calls the member function
template<typename T>
variant_call_type make_caller(T t) {
return detail::build_caller<T>::template get<T>(t);
}
// actions stuff. maps an id to a class and method.
typedef std::map<std::string,
std::pair< std::string, std::string >
> actions_type;
// this map maps (class, method) => (factory, function pointer)
typedef variant_type (*factory_function)();
typedef std::map< std::pair<std::string, std::string>,
std::pair<factory_function, variant_call_type>
> class_method_map_type;
// this will be our test function. it's supplied with the actions map,
// and the factory map
std::string test(std::string const& id,
actions_type& actions, class_method_map_type& factory) {
// pair containing the class and method name to call
std::pair<std::string, std::string> const& class_method =
actions[id];
// real code should take the maps by const parameter and use
// the find function of std::map to lookup the values, and store
// results of factory lookups. we try to be as short as possible.
variant_type v(factory[class_method].first());
// execute the function associated, giving it the object created
return factory[class_method].second(v);
}
int main() {
// possible actions
actions_type actions;
actions["first"] = std::make_pair("foo", "one");
actions["second"] = std::make_pair("bar", "two");
actions["third"] = std::make_pair("baz", "three");
// connect the strings to the actual entities. This is the actual
// heart of everything.
class_method_map_type factory_map;
factory_map[actions["first"]] =
std::make_pair(&factory<foo>, make_caller(&foo::one));
factory_map[actions["second"]] =
std::make_pair(&factory<bar>, make_caller(&bar::two));
factory_map[actions["third"]] =
std::make_pair(&factory<baz>, make_caller(&baz::three));
// outputs "I am happy!"
std::cout << test("first", actions, factory_map)
<< test("second", actions, factory_map)
<< test("third", actions, factory_map) << std::endl;
}
它使用来自boost预处理器，函数类型和绑定库的非常有趣的技术。可能循环复杂，但如果你得到该代码中的键，那就不再需要掌握了。如果要更改参数计数，只需调整variant_call_type：
typedef boost::function<return_type (variant_type&, int)> variant_call_type;
现在您可以调用带有int的成员函数。以下是呼叫方的外观：
return factory[class_method].second(v, 42);
玩得开心！
如果您现在说上述内容过于复杂，我必须同意您的意见。 很复杂，因为C ++ 实际上是为了这种动态使用而制作的。如果您可以在要创建的每个对象中对方法进行分组和实现，则可以使用纯虚函数。或者，您可以在默认实现中抛出一些异常（如std :: runtime_error），因此派生类不需要实现所有内容：
struct my_object {
typedef std::string return_type;
virtual ~my_object() { }
virtual std::string one() { not_implemented(); }
virtual std::string two() { not_implemented(); }
private:
void not_implemented() { throw std::runtime_error("not implemented"); }
};
对于创建对象，通常的工厂会做
struct object_factory {
boost::shared_ptr<my_object> create_instance(std::string const& name) {
// ...
}
};
地图可以通过映射将ID映射到一对类和函数名称（与上面相同），以及映射到boost :: function的映射：
typedef boost::function<my_object::return_type(my_object&)> function_type;
typedef std::map< std::pair<std::string, std::string>, function_type>
class_method_map_type;
class_method_map[actions["first"]] = &my_object::one;
class_method_map[actions["second"]] = &my_object::two;
调用该函数将如下工作：
boost::shared_ptr<my_object> p(get_factory().
create_instance(actions["first"].first));
std::cout << class_method_map[actions["first"]](*p);
当然，通过这种方法，您可以放松灵活性并且（可能没有分析）效率，但是您可以大大简化设计。
答案 2 :(得分：2)
与许多C ++问题一样，这看起来像是Boost的另一个应用程序。你基本上想要存储boost :: bind（＆amp; Class :: member，＆amp; Object）的结果。 [edit]使用boost :: function可以很容易地存储这样的结果。
答案 3 :(得分：2)
我认为这里最重要的是，你的所有方法都有相同的签名吗？如果他们这样做，这是一个微不足道的使用boost绑定（如果你是这样），functor是一个选项（静态，duck类型），或只是普通的ole虚拟继承是一个选项。继承目前还不流行，但它很容易理解，我不认为它使事情变得复杂，然后使用boost bind（imho最适合小型非系统函子）。
这是一个示例实现
#include<iostream>
#include<map>
#include<string>
using std::map;
using std::string;
using std::cout;
using std::pair;
class MVCHandler
{
public:
virtual void operator()(const string& somekindofrequestinfo) = 0;
};
class MyMVCHandler : public MVCHandler
{
public:
virtual void operator()(const string& somekindofrequestinfo)
{
cout<<somekindofrequestinfo;
}
};
void main()
{
MyMVCHandler myhandler;
map<string, MVCHandler*> handlerMap;
handlerMap.insert(pair<string, MVCHandler*>("mysuperhandler", &myhandler));
(*handlerMap["mysuperhandler"])("somekindofrequestdata");
}
答案 4 :(得分：1)
答案 5 :(得分：1)
如果您不想使用member function pointers，则可以使用带有类实例参数的静态。例如：
class MyClass
{
public:
void function();
static void call_function(MyClass *instance); // Or you can use a reference here.
};
MyClass instance;
MyClass::call_function(&instance);
这需要对编码器进行更多的工作并导致可维护性问题（因为如果更新一个的签名，则必须更新另一个的签名）。
您还可以使用一个静态函数调用所有成员函数：
class MyClass
{
public:
enum Method
{
fp_function,
};
void function();
static void invoke_method(MyClass *instance, Method method); // Or you can use a reference here.
};
void MyClass::invoke_method(MyClass *instance, Method method)
{
switch(method)
{
default:
// Error or something here.
return;
case fp_function:
instance->function();
break;
// Or, if you have a lot of methods:
#define METHOD_CASE(x) case fp_##x: instance->x(); break;
METHOD_CASE(function);
#undef METHOD_CASE
}
// Free logging! =D
}
MyClass instance;
MyClass::invoke_method(instance, MyClass::fp_function);
答案 6 :(得分：0)
您还可以使用动态加载功能：
在Windows中使用GetProcAddress，在Unix中使用dlsym。
答案 7 :(得分：0)
转到主题观察者设计模式。