C++ でクラスメソッドを動的に作成して呼び出す最も簡単な方法は何ですか?

https://stackoverflow.com/questions/405432

03-07-2019
|

質問

マップにクラス名とメソッド、一意の識別子、およびメソッドへのポインタを入力したいと考えています。

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);    
         }
     }
 }

追伸：はい、C++ で (Web) MVC フロントコントローラーを作成しようとしています。PHP、Ruby、Python (ここにお気に入りの Web 言語を挿入してください) などを使用しない理由はわかっていますが、C++ が必要なだけです。

解決

私はそれをここ数時間書いて、役立つもののコレクションに追加しました。最も難しいのは、作成したい型がまったく関連していない場合に、ファクトリ関数に対処することです。私が使用したのは、 boost::variant このために。使用したいタイプのセットをそれに与える必要があります。次に、バリアント内の現在の「アクティブ」タイプが何であるかを追跡します。(boost::variant はいわゆる差別共用体です)。2 番目の問題は、関数ポインターをどのように保存するかです。問題は、次のメンバーへのポインタが 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;
}

ブーストプリプロセッサ、関数タイプ、バインドライブラリなどの非常に楽しいテクニックを使用しています。ループは複雑になるかもしれませんが、そのコードでキーを取得すれば、もう理解するのはそれほど難しくありません。パラメータ数を変更したい場合は、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);

もちろん、このアプローチでは柔軟性と (おそらくプロファイリングを行っていない) 効率は失われますが、設計は大幅に簡素化されます。

他のヒント

おそらくあなたは探していますメンバー関数ポインター.

基本的な使い方:

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

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

MyClass instance;

instance.*function_ptr;

C++ FAQ Lite に記載されているように、マクロと typedefs を使用すると、メンバー関数ポインターを使用する場合の可読性が大幅に向上します (コード内でその構文が一般的ではないため)。

ここで確認すべき最も重要なことは、すべてのメソッドが同じシグネチャを持っているかどうかだと思います。そうする場合、これはブーストバインドの簡単な使用法であり (興味がある場合)、ファンクターはオプション (静的、アヒル型の種類)、または単なる単純な仮想継承がオプションです。継承は現在流行っていませんが、非常に理解しやすく、ブーストバインドを使用するよりも物事を複雑にすることはないと思います (小規模な非システミックファンクターに最適であると私は考えています)。

これはサンプル実装です

#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");
}

多くの C++ の質問と同様、これは Boost の別のアプリケーションのように見えます。基本的には boost::bind(&Class::member, &Object) の結果を保存する必要があります。[編集] このような結果の保存は、boost::function を使用すると簡単です。

クラスにはファクトリまたは抽象ファクトリデザインパターンを使用し、関数には関数ポインタを使用してみることができます。

同様の問題の解決策を探していたときに、実装が記載された次の 2 つの Web ページを見つけました。

工場

抽象的な工場

使用したくない場合は、メンバー関数ポインター, 、クラスインスタンスの引数を取る静的を使用できます。例えば：

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);

関数の動的ロードを使用することもできます。

Windows では GetProcAddress を使用し、Unix では dlsym を使用します。

Subject-Observer デザインパターンを選択してください。

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow

C++ でクラス メソッドを動的に作成して呼び出す最も簡単な方法は何ですか?

C++ でクラスメソッドを動的に作成して呼び出す最も簡単な方法は何ですか?