Komentarz:
Implementacja Artemis jest interesująca. Wymyśliłem podobne rozwiązanie, tyle że nazwałem swoje komponenty „Atrybutami” i „Zachowaniami”. Takie podejście do rozdzielania typów komponentów działało dla mnie bardzo dobrze.
Jeśli chodzi o rozwiązanie:
kod jest łatwy w użyciu, ale implementacja może być trudna do wykonania, jeśli nie masz doświadczenia z C ++. Więc...
Pożądany interfejs
To, co zrobiłem, to mieć centralne repozytorium wszystkich komponentów. Każdy typ komponentu jest mapowany na określony ciąg znaków (który reprezentuje nazwę komponentu). Oto jak korzystasz z systemu:
// Every time you write a new component class you have to register it.
// For that you use the `COMPONENT_REGISTER` macro.
class RenderingComponent : public Component
{
// Bla, bla
};
COMPONENT_REGISTER(RenderingComponent, "RenderingComponent")
int main()
{
// To then create an instance of a registered component all you have
// to do is call the `create` function like so...
Component* comp = component::create("RenderingComponent");
// I found that if you have a special `create` function that returns a
// pointer, it's best to have a corresponding `destroy` function
// instead of using `delete` directly.
component::destroy(comp);
}
Implementacja
Wdrożenie nie jest takie złe, ale wciąż dość skomplikowane; wymaga pewnej wiedzy na temat szablonów i wskaźników funkcji.
Uwaga: Joe Wreschnig poczynił kilka dobrych uwag w komentarzach, głównie na temat tego, jak moja poprzednia implementacja przyjęła zbyt wiele założeń dotyczących tego, jak dobry jest kompilator w optymalizacji kodu; problem nie był szkodliwy, imo, ale również mnie zaskoczył. Zauważyłem również, że poprzednie COMPONENT_REGISTER
makro nie działało z szablonami.
Zmieniłem kod i teraz wszystkie te problemy powinny zostać naprawione. Makro współpracuje z szablonami i rozwiązano problemy, które podniósł Joe: teraz kompilatorom znacznie łatwiej jest zoptymalizować niepotrzebny kod.
składnik / składnik. h
#ifndef COMPONENT_COMPONENT_H
#define COMPONENT_COMPONENT_H
// Standard libraries
#include <string>
// Custom libraries
#include "detail.h"
class Component
{
// ...
};
namespace component
{
Component* create(const std::string& name);
void destroy(const Component* comp);
}
#define COMPONENT_REGISTER(TYPE, NAME) \
namespace component { \
namespace detail { \
namespace \
{ \
template<class T> \
class ComponentRegistration; \
\
template<> \
class ComponentRegistration<TYPE> \
{ \
static const ::component::detail::RegistryEntry<TYPE>& reg; \
}; \
\
const ::component::detail::RegistryEntry<TYPE>& \
ComponentRegistration<TYPE>::reg = \
::component::detail::RegistryEntry<TYPE>::Instance(NAME); \
}}}
#endif // COMPONENT_COMPONENT_H
składnik / szczegół. h
#ifndef COMPONENT_DETAIL_H
#define COMPONENT_DETAIL_H
// Standard libraries
#include <map>
#include <string>
#include <utility>
class Component;
namespace component
{
namespace detail
{
typedef Component* (*CreateComponentFunc)();
typedef std::map<std::string, CreateComponentFunc> ComponentRegistry;
inline ComponentRegistry& getComponentRegistry()
{
static ComponentRegistry reg;
return reg;
}
template<class T>
Component* createComponent() {
return new T;
}
template<class T>
struct RegistryEntry
{
public:
static RegistryEntry<T>& Instance(const std::string& name)
{
// Because I use a singleton here, even though `COMPONENT_REGISTER`
// is expanded in multiple translation units, the constructor
// will only be executed once. Only this cheap `Instance` function
// (which most likely gets inlined) is executed multiple times.
static RegistryEntry<T> inst(name);
return inst;
}
private:
RegistryEntry(const std::string& name)
{
ComponentRegistry& reg = getComponentRegistry();
CreateComponentFunc func = createComponent<T>;
std::pair<ComponentRegistry::iterator, bool> ret =
reg.insert(ComponentRegistry::value_type(name, func));
if (ret.second == false) {
// This means there already is a component registered to
// this name. You should handle this error as you see fit.
}
}
RegistryEntry(const RegistryEntry<T>&) = delete; // C++11 feature
RegistryEntry& operator=(const RegistryEntry<T>&) = delete;
};
} // namespace detail
} // namespace component
#endif // COMPONENT_DETAIL_H
component / component.cpp
// Matching header
#include "component.h"
// Standard libraries
#include <string>
// Custom libraries
#include "detail.h"
Component* component::create(const std::string& name)
{
detail::ComponentRegistry& reg = detail::getComponentRegistry();
detail::ComponentRegistry::iterator it = reg.find(name);
if (it == reg.end()) {
// This happens when there is no component registered to this
// name. Here I return a null pointer, but you can handle this
// error differently if it suits you better.
return nullptr;
}
detail::CreateComponentFunc func = it->second;
return func();
}
void component::destroy(const Component* comp)
{
delete comp;
}
Rozszerzanie z Luą
Powinienem zauważyć, że przy odrobinie pracy (nie jest to bardzo trudne), można to wykorzystać do płynnej pracy ze składnikami zdefiniowanymi w C ++ lub Lua, bez konieczności myślenia o tym.