クラス名を保持する文字列からオブジェクトをインスタンス化する方法はありますか？
ファイルがあります：Base.h
class Base;
class DerivedA : public Base;
class DerivedB : public Base;
/*etc...*/
および別のファイル：BaseFactory.h
#include "Base.h"
class BaseFactory
{
public:
BaseFactory(const string &sClassName){msClassName = sClassName;};
Base * Create()
{
if(msClassName == "DerivedA")
{
return new DerivedA();
}
else if(msClassName == "DerivedB")
{
return new DerivedB();
}
else if(/*etc...*/)
{
/*etc...*/
}
};
private:
string msClassName;
};
/*etc.*/
この文字列を実際の型（クラス）に何らかの方法で変換する方法はありますか？BaseFactoryがすべての可能な派生クラスを知る必要がなく、それぞれのクラスにif（）が必要ですか？この文字列からクラスを作成できますか？
これは、Reflectionを介してC＃で実行できると思います。 C++に似たようなものはありますか？
いいえ、マッピングを自分で行わない限り、ありません。 C++には、実行時に型が決定されるオブジェクトを作成するメカニズムがありません。ただし、マップを使用して自分でそのマッピングを行うことができます。
template<typename T> Base * createInstance() { return new T; }
typedef std::map<std::string, Base*(*)()> map_type;
map_type map;
map["DerivedA"] = &createInstance<DerivedA>;
map["DerivedB"] = &createInstance<DerivedB>;
そして、あなたはできる
return map[some_string]();
新しいインスタンスを取得します。別のアイデアは、型に自分自身を登録させることです。
// in base.hpp:
template<typename T> Base * createT() { return new T; }
struct BaseFactory {
typedef std::map<std::string, Base*(*)()> map_type;
static Base * createInstance(std::string const& s) {
map_type::iterator it = getMap()->find(s);
if(it == getMap()->end())
return 0;
return it->second();
}
protected:
static map_type * getMap() {
// never delete'ed. (exist until program termination)
// because we can't guarantee correct destruction order
if(!map) { map = new map_type; }
return map;
}
private:
static map_type * map;
};
template<typename T>
struct DerivedRegister : BaseFactory {
DerivedRegister(std::string const& s) {
getMap()->insert(std::make_pair(s, &createT<T>));
}
};
// in derivedb.hpp
class DerivedB {
...;
private:
static DerivedRegister<DerivedB> reg;
};
// in derivedb.cpp:
DerivedRegister<DerivedB> DerivedB::reg("DerivedB");
登録用のマクロを作成することもできます
#define REGISTER_DEC_TYPE(NAME) \
static DerivedRegister<NAME> reg
#define REGISTER_DEF_TYPE(NAME) \
DerivedRegister<NAME> NAME::reg(#NAME)
しかし、これらの2つには、より良い名前があると確信しています。ここで使用するのがおそらく理にかなっている別のことは、shared_ptrです。
共通の基本クラスを持たない関連のないタイプのセットがある場合は、代わりにboost::variant<A, B, C, D, ...>の戻りタイプを関数ポインターに与えることができます。クラスFoo、Bar、Bazがある場合、次のようになります。
typedef boost::variant<Foo, Bar, Baz> variant_type;
template<typename T> variant_type createInstance() {
return variant_type(T());
}
typedef std::map<std::string, variant_type (*)()> map_type;
boost::variantは結合のようなものです。どのオブジェクトが初期化または割り当てに使用されたかを調べることで、どのタイプが格納されているかがわかります。そのドキュメントをご覧ください here 。最後に、生の関数ポインタの使用も少し古いです。最新のC++コードは、特定の関数/タイプから分離する必要があります。より良い方法を探すには、 Boost.Function を調べてください。この場合、次のようになります（マップ）。
typedef std::map<std::string, boost::function<variant_type()> > map_type;
std::functionは、std::shared_ptrを含むC++の次のバージョンでも使用可能になります。
いいえ、ありません。この問題に対する私の好ましい解決策は、名前を作成方法にマップする辞書を作成することです。このように作成したいクラスは、作成メソッドを辞書に登録します。これについては GoFパターンブック で詳しく説明しています。
簡単な答えは、あなたはできないということです。以下のSOの質問を参照してください。理由：
boost :: functionalには、非常に柔軟なファクトリテンプレートがあります。 http://www.boost.org/doc/libs/1_54_0/libs/functional/factory/doc/html/index.html
私の好みは、マッピングとオブジェクト作成メカニズムを隠すラッパークラスを生成することです。私が遭遇する一般的なシナリオは、いくつかの基本クラスの異なる派生クラスをキーにマップする必要があることです。ここで、派生クラスはすべて、利用可能な共通コンストラクタシグネチャを持っています。これが私がこれまでに考え出した解決策です。
#ifndef GENERIC_FACTORY_HPP_INCLUDED
//BOOST_PP_IS_ITERATING is defined when we are iterating over this header file.
#ifndef BOOST_PP_IS_ITERATING
//Included headers.
#include <unordered_map>
#include <functional>
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition.hpp>
//The GENERIC_FACTORY_MAX_ARITY directive controls the number of factory classes which will be generated.
#ifndef GENERIC_FACTORY_MAX_ARITY
#define GENERIC_FACTORY_MAX_ARITY 10
#endif
//This macro magic generates GENERIC_FACTORY_MAX_ARITY + 1 versions of the GenericFactory class.
//Each class generated will have a suffix of the number of parameters taken by the derived type constructors.
#define BOOST_PP_FILENAME_1 "GenericFactory.hpp"
#define BOOST_PP_ITERATION_LIMITS (0,GENERIC_FACTORY_MAX_ARITY)
#include BOOST_PP_ITERATE()
#define GENERIC_FACTORY_HPP_INCLUDED
#else
#define N BOOST_PP_ITERATION() //This is the Nth iteration of the header file.
#define GENERIC_FACTORY_APPEND_PLACEHOLDER(z, current, last) BOOST_PP_COMMA() BOOST_PP_CAT(std::placeholders::_, BOOST_PP_ADD(current, 1))
//This is the class which we are generating multiple times
template <class KeyType, class BasePointerType BOOST_PP_ENUM_TRAILING_PARAMS(N, typename T)>
class BOOST_PP_CAT(GenericFactory_, N)
{
public:
typedef BasePointerType result_type;
public:
virtual ~BOOST_PP_CAT(GenericFactory_, N)() {}
//Registers a derived type against a particular key.
template <class DerivedType>
void Register(const KeyType& key)
{
m_creatorMap[key] = std::bind(&BOOST_PP_CAT(GenericFactory_, N)::CreateImpl<DerivedType>, this BOOST_PP_REPEAT(N, GENERIC_FACTORY_APPEND_PLACEHOLDER, N));
}
//Deregisters an existing registration.
bool Deregister(const KeyType& key)
{
return (m_creatorMap.erase(key) == 1);
}
//Returns true if the key is registered in this factory, false otherwise.
bool IsCreatable(const KeyType& key) const
{
return (m_creatorMap.count(key) != 0);
}
//Creates the derived type associated with key. Throws std::out_of_range if key not found.
BasePointerType Create(const KeyType& key BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N,const T,& a)) const
{
return m_creatorMap.at(key)(BOOST_PP_ENUM_PARAMS(N,a));
}
private:
//This method performs the creation of the derived type object on the heap.
template <class DerivedType>
BasePointerType CreateImpl(BOOST_PP_ENUM_BINARY_PARAMS(N,const T,& a))
{
BasePointerType pNewObject(new DerivedType(BOOST_PP_ENUM_PARAMS(N,a)));
return pNewObject;
}
private:
typedef std::function<BasePointerType (BOOST_PP_ENUM_BINARY_PARAMS(N,const T,& BOOST_PP_INTERCEPT))> CreatorFuncType;
typedef std::unordered_map<KeyType, CreatorFuncType> CreatorMapType;
CreatorMapType m_creatorMap;
};
#undef N
#undef GENERIC_FACTORY_APPEND_PLACEHOLDER
#endif // defined(BOOST_PP_IS_ITERATING)
#endif // include guard
私は通常、マクロを頻繁に使用することに反対していますが、ここでは例外を設けています。上記のコードは、Generic_FACTORY_MAX_ARITY + 1バージョンのGenericFactory_Nという名前のクラスの0からGENERIC_FACTORY_MAX_ARITYまでの各Nに対して生成します。
生成されたクラステンプレートの使用は簡単です。ストリングマッピングを使用して、ファクトリでBaseClass派生オブジェクトを作成するとします。派生オブジェクトはそれぞれ、コンストラクターパラメーターとして3つの整数を受け取ります。
#include "GenericFactory.hpp"
typedef GenericFactory_3<std::string, std::shared_ptr<BaseClass>, int, int int> factory_type;
factory_type factory;
factory.Register<DerivedClass1>("DerivedType1");
factory.Register<DerivedClass2>("DerivedType2");
factory.Register<DerivedClass3>("DerivedType3");
factory_type::result_type someNewObject1 = factory.Create("DerivedType2", 1, 2, 3);
factory_type::result_type someNewObject2 = factory.Create("DerivedType1", 4, 5, 6);
GenericFactory_Nクラスのデストラクターは、次のことを可能にするために仮想化されています。
class SomeBaseFactory : public GenericFactory_2<int, BaseType*, std::string, bool>
{
public:
SomeBaseFactory() : GenericFactory_2()
{
Register<SomeDerived1>(1);
Register<SomeDerived2>(2);
}
};
SomeBaseFactory factory;
SomeBaseFactory::result_type someObject = factory.Create(1, "Hi", true);
delete someObject;
ジェネリックファクトリジェネレーターマクロのこの行
#define BOOST_PP_FILENAME_1 "GenericFactory.hpp"
ジェネリックファクトリヘッダーファイルの名前がGenericFactory.hppであると仮定します
オブジェクトを登録し、文字列名でそれらにアクセスするための詳細なソリューション。
common.h：
#ifndef COMMON_H_
#define COMMON_H_
#include<iostream>
#include<string>
#include<iomanip>
#include<map>
using namespace std;
class Base{
public:
Base(){cout <<"Base constructor\n";}
virtual ~Base(){cout <<"Base destructor\n";}
};
#endif /* COMMON_H_ */
test1.h：
/*
* test1.h
*
* Created on: 28-Dec-2015
* Author: ravi.prasad
*/
#ifndef TEST1_H_
#define TEST1_H_
#include "common.h"
class test1: public Base{
int m_a;
int m_b;
public:
test1(int a=0, int b=0):m_a(a),m_b(b)
{
cout <<"test1 constructor m_a="<<m_a<<"m_b="<<m_b<<endl;
}
virtual ~test1(){cout <<"test1 destructor\n";}
};
#endif /* TEST1_H_ */
3. test2.h
#ifndef TEST2_H_
#define TEST2_H_
#include "common.h"
class test2: public Base{
int m_a;
int m_b;
public:
test2(int a=0, int b=0):m_a(a),m_b(b)
{
cout <<"test1 constructor m_a="<<m_a<<"m_b="<<m_b<<endl;
}
virtual ~test2(){cout <<"test2 destructor\n";}
};
#endif /* TEST2_H_ */
main.cpp：
#include "test1.h"
#include "test2.h"
template<typename T> Base * createInstance(int a, int b) { return new T(a,b); }
typedef std::map<std::string, Base* (*)(int,int)> map_type;
map_type mymap;
int main()
{
mymap["test1"] = &createInstance<test1>;
mymap["test2"] = &createInstance<test2>;
/*for (map_type::iterator it=mymap.begin(); it!=mymap.end(); ++it)
std::cout << it->first << " => " << it->second(10,20) << '\n';*/
Base *b = mymap["test1"](10,20);
Base *b2 = mymap["test2"](30,40);
return 0;
}
コンパイルして実行します（Eclipseでこれを実行しました）
出力：
Base constructor
test1 constructor m_a=10m_b=20
Base constructor
test1 constructor m_a=30m_b=40
Javaのような意味の反映。ここにいくつかの情報があります： http://msdn.Microsoft.com/en-us/library/y0114hz2（VS.80）.aspx
一般的に、Googleで「c ++反射」を検索します
Tor Brede Vekterliは、求める機能を正確に提供するブースト拡張機能を提供します。現在、現在のブーストライブラリには少し不自然ですが、ベース名前空間を変更した後、1.48_0で動作するようになりました。
なぜそのようなもの（リフレクションとして）がc ++に役立つのか疑問に思う人への答え-UIとエンジン間の相互作用のためにそれを使用します-ユーザーはUIのオプションを選択し、エンジンはUI選択文字列を受け取ります目的のタイプのオブジェクトを生成します。
ここでフレームワークを使用する主な利点は（フルーツリストをどこかに維持するよりも）、登録関数が各クラスの定義内にあることです（登録されたクラスごとに登録関数を呼び出すコードが1行だけ必要です）。フルーツリスト。新しいクラスが派生するたびに手動で追加する必要があります。
ファクトリを基本クラスの静的メンバーにしました。
これは工場出荷時のパターンです。ウィキペディアを参照してください（および this の例）。ひどいハックがなければ、文字列から型自体を作成することはできません。なぜこれが必要なのですか？