Re: Templates vs factories
{ Edits: quoted signature removed. -mod }
On May 8, 3:25 am, Matt Messina <mess...@yahoo.com> wrote:
Imre <imr...@pager.hu> wrote:
Now the problem is: how to register the creator functions? If we only
create new objects through the factory, it's entirely possible that
there's no direct reference to the creatable classes anywhere in the
program. This means that they won't be instantiated, nor their static
initializers, so they won't be registered, and thus cannot be
created.
Wouldn't the creator function templates reference the product (i.e.
creatable) class templates? And wouldn't taking the address of those
creator function template specializations (to pass into a register
function) cause the creator function templates to be instantiated, and
therefore cause the product class tempates to be instantiated?
I guess I don't see the templates vs factories problem. Correct me if
I'm wrong.
The problem is you pass pointer to creator function for all types
(creator function is a template and we don't specialize it), and you
don't explicitly instanciate creator functions.
You have something like this:
// interface of classes we are creating with Factory
template <class T>
struct Base
{
virtual ~Base() {}
};
// interface of creators (they should be registered in Factory)
template <class T>
struct Creator
{
virtual ~Creator() {}
virtual Base<T> * Create() = 0;
};
template <class T>
struct Factory
{
// Factory is a singleton
static Factory & Instance();
Base<T> * Create(const char * name);
// each type should be registered before it can be created
void Register(const char * name, Creator<T> * creator);
};
template <class T, template <class> class Impl>
struct CreatorImpl : Creator<T>
{
Base<T> * Create() { return new Impl<T>; }
};
// constructor of this class will register Impl in Factory
// it usually happens on program startup
template <class T, class Impl, const char * Name>
struct Registrar
{
Registrar() { Factory<T>::Instance().Register(Name, new
CreatorImpl<T, Impl>); }
};
extern const char FOO[] = "Foo";
// concrete class which we gonna create using Factory
template <class T>
struct Foo : Base<T>
{
private:
static Registrar<T, Foo, FOO> registrar_;
};
template <class T>
Registrar<T, Foo, FOO> Foo<T>::registrar_;
int main()
{
Base<T> * foo = Factory<int>::Instance().Create("Foo");
}
Here Factory<int>::Instance().Create("Foo") will fail because Foo<int>
is never instantiated and therefore not registered. If we explicitly
instantiate Foo<int> then it should work (maybe you need some
additional tricks to prevent optimizing out registrar_).
When we instantiate Factory<int> we want Foo<int> to be instantiated
also. OP is asking how he can do it.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]