* Pascal J. Bourguignon:
mathieu <mathieu.malaterre@gmail.com> writes:
On Aug 6, 11:45 am, Ian Collins <ian-n...@hotmail.com> wrote:
mathieu wrote:
Hi there,
I am looking for a trick to avoid maintaining the 'Create' function
as describe below. All it does is a simple template instantiation, are
there any trick which would avoid having to maintain this 'Create' as
the number of enum grows ?
Thanks
typedef enum {
TYPE1,
TYPE2
} TYPES;
class type {};
class type1 : public type {};
class type2 : public type {};
template <int T> struct Factory;
template <> struct Factory<TYPE1> { typedef type1 Type; };
template <> struct Factory<TYPE2> { typedef type2 Type; };
type* Create(TYPES e)
{
switch(e)
{
case TYPE1:
return new Factory<TYPE1>::Type;
break;
case TYPE2:
return new Factory<TYPE2>::Type;
break;
}
}
What about
template <int N>
type* create()
{
return Factory<N>::type;
}
Ooops, I missed the whole point of my issue. 'TYPE' are read from a
file, so I need a dynamic binding which is not expressed in my
example. I'll try to post another example.
Depends. Is this file determined when you compile the program, or is
it determined at run time?
In the former case, you can generate the function to instanciate the
templates with a mere sed command:
instanciate.c++ : types.h
( echo 'void instanciateTemplate(){' ;\
sed -n -e '/typedef enum/,/} TYPES/s/^ *\([A-Z][A-Za-z0-9]*\),?/{type * t=create<\1>();}/p <types.h \;
echo '}' ) > instanciate.c++
In the later case, you will have to generate at run time such a
function, then fork the compiler to compile it in a dynamically
loadable library, load it dynamically and call it.
Besides, shared libraries are not supported by standard C++, which is the topic
which is to use a map of functions, or just a simple array. It's on a par with
using a variable where you need a variable. And actually it is exactly that,