在C++中动态创建和调用类方法的最简单方法是什么？

我想用类名和方法填充一个映射,一个唯一的标识符和指向该方法的指针.

typedef std::map 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++.

也许你正在寻找成员函数指针.

基本用法:

class MyClass
{
    public:
        void function();
};

void (MyClass:*function_ptr)() = MyClass::function;

MyClass instance;

instance.*function_ptr;

正如C++ FAQ Lite中所述,typedef使用成员函数指针时,宏和s会大大提高可读性(因为它们的语法在代码中并不常见).

我在最后几个小时写了这些东西,并将它添加到我的有用的东西集合中.如果您要创建的类型不以任何方式相关,最困难的是应对工厂功能.我用了boost::variant这个.你必须给它一组你想要使用的类型.然后它将跟踪变体中当前"活动"类型的内容.(boost :: variant是一种所谓的歧视联盟).第二个问题是如何存储函数指针.问题是指向成员的指针A不能存储到指向成员的指针B.这些类型是不兼容的.为了解决这个问题,我将函数指针存储在一个重载它的对象中operator()并采用boost :: variant:

return_type operator()(variant)

当然,所有类型的函数都必须具有相同的返回类型.否则整场比赛只会毫无意义.现在的代码:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

它使用来自boost预处理器,函数类型和绑定库的非常有趣的技术.可能循环复杂,但如果你得到该代码中的键,那就不再需要掌握了.如果要更改参数计数,只需调整variant_call_type即可:

typedef boost::function 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 create_instance(std::string const& name) {
        // ...
    }
};

地图可以通过映射将ID映射到一对类和函数名称(与上面相同),以及映射到boost :: function的映射:

typedef boost::function function_type;
typedef std::map< std::pair, 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 p(get_factory().
    create_instance(actions["first"].first));
std::cout << class_method_map[actions["first"]](*p);

当然,通过这种方法,您可以放松灵活性(可能没有分析)效率,但是您可以大大简化设计.