The ideal factory

[Dave]

Hello all,

I'd like to find a way to inject N overloads of a static member function
named Create() into a class foo. The number and type of the parameters of
these overloads will be fixed at compile time but should be able to be
anything. The return values of these overloads will be foo * (later, I'll
want to return boost::shared_ptr<>, but for this discussuion, I'll leave it
at raw pointers to keep it on-topic and simpler). Things should work
seamlessly with multiple inheritance so that we never get into an ambiguous
case if multiple Create() static member functions are pulled in from
different bases. The approaches I've tried have bit me in this case.

The Create() static member functions will return a pointer to a foo that has
been newly-constucted on the heap. The parameters to Create() (however many
there are and whatever their types may be) are used as constructor
parameters.

Assume this hierarchy: foo --> base. Here are some examples of desired
usage:

foo *ptr1 = foo::Create();
foo *ptr2 = foo::Create(my_type_1(), 42, my_type_2());
base *ptr3 = foo::Create(12);

Of course, I could manually insert the Create() overloads into foo myself.
But I would like to find a scheme that automates this as much as possible
for me. This will undoubtedly involve things such as templates, tuples,
perhaps a couple of macros (yuck), etc.

1. Are there any other characteristics I should include in my definition of
an ideal factory?

2. What are some of the approaches I should look into that are most likely
to be successful?

Thanks,
Dave

[Victor Bazarov]

Dave wrote:

I'd like to find a way to inject N overloads of a static member
function named Create() into a class foo. The number and type of the
parameters of these overloads will be fixed at compile time but
should be able to be anything. The return values of these overloads
will be foo * (later, I'll want to return boost::shared_ptr<>, but
for this discussuion, I'll leave it at raw pointers to keep it
on-topic and simpler). Things should work seamlessly with multiple
inheritance so that we never get into an ambiguous case if multiple
Create() static member functions are pulled in from different bases.
From different bases of what? You're inserting 'Create' functions to
the 'foo' class, right? How are those functions going to be used in
the derived classes? Are you hoping to somehow override them in the
derived classes?
The approaches I've tried have bit me in this case.
And which approaches were these?
The Create() static member functions will return a pointer to a foo
that has been newly-constucted on the heap. The parameters to
Create() (however many there are and whatever their types may be) are
used as constructor parameters.

Assume this hierarchy: foo --> base. Here are some examples of desired
usage:

foo *ptr1 = foo::Create();
foo *ptr2 = foo::Create(my_type_1(), 42, my_type_2());
base *ptr3 = foo::Create(12);
Looks fine. Supposedly your 'foo' class has at least three constructors,
one default, one with one 'int' (or something convertible from 'int'),
and one with three arguments. Are these constructors private? It would
probably be nice to have them private if you need to always filter the
creation of 'foo' through the same place (foo::Create). What I don't
really understand is the advantage of this approach versus having just
three public constructors...
Of course, I could manually insert the Create() overloads into foo
myself.
....just like you have to do with constructors...
But I would like to find a scheme that automates this as much
as possible for me.
Automate based on what? I can only see something like the macros:

#define DECLARE_CREATE(clazz, t1) \
private: \
clazz(t1); \
public: \
static clazz* Create (t1)

#define DECLARE_CREATE(clazz, t1, t2) \
private: \
clazz(t1, t2); \
public: \
static clazz* Create (t1, t2)

#define DECLARE_CREATE(clazz, t1, t2, t3) \
private: \
clazz(t1, t2, t3); \
public: \
static clazz* Create (t1, t2, t3)

and then just use those:

class foo : public base {
DECLARE_CREATE(foo, int);
DECLARE_CREATE(foo, double, int);
DECLARE_CREATE(foo, string const&);
This will undoubtedly involve things such as
templates, tuples, perhaps a couple of macros (yuck), etc.
Undoubtedly?
1. Are there any other characteristics I should include in my
definition of an ideal factory?
And what definition is that? I've not seen one so far. Perhaps you
should begin with the actual definition.
2. What are some of the approaches I should look into that are most
likely to be successful?

Read "Modern C++ Design", chapter 6, IIRC. Creation Policies, I
think, is the title of that chapter.

V