Re: Run-time template list definition / Run-time variable type definition
Victor,
thanks for your answer... I found out that I was not able to do a
non-templated base class because I required some templated method from
processFoo. Maybe, my design was poor.
I did in an other way. I created a templated function which is similar
to the following:
8<-------------------------
template<class T>
int OverallProcessFoo(T t, parameters) {
Foo<T> * myFoo = new Foo<T>(parameters);
processFoo(myFoo);
return EXIT_SUCCESS;
}
8<-------------------------
Might not be the cleanest but it does the job if I can call
OverallProcessFoo at the same time I know the outcome of condition1.
Regards,
PY
Victor Bazarov previously wrote the following e-mail:
Pierre Yves wrote:
Hi there,
Sorry for the double subject but I feel they are related. I'm not
pretty sure there would be an answer but I reckon there must be a way
to make it work.
I would like to write the following bit of code:
8<----------------------------
Foo<> * myFoo = NULL; // Foo is a templated class.
if (condition1) {
myFoo = new Foo<double>(parameters);
} else {
myFoo = new Foo<long>(parameters);
}
processFoo(myFoo);
8<----------------------------
This version is obviously illegal. Have you any ideas for an
alternative? i.e. declaring the template list of my templated class at
run time?
You either have a template wrapper around your 'condition1' and
'processFoo' (IOW, make 'processFoo' a template), or create a base
class for all Foo, like so
class FooBase { ... };
template<class T> class Foo : public FooBase { ... };
and then declare 'myFoo' to be a pointer to base:
FooBase * myFoo( condition1 ?
new Foo<double>(parameters) :
new Foo<long>(parameters) );
processFoo(myFoo);
Of course, 'processFoo' would need to be refactored.
I'm looking for a way to do some run-time polymorphism at run-time
with templates. Can I define the template class is derivated from an
other class (similar to an interface in java) or the template will
raise conflicts? Is there a nicer solution?
Not sure what your doubt is about here. Run-time polymorphism and
templates are _orthogonal_ (except that you cannot define a template
member function and declare it virtual at the same time).
V