Run-time template list definition / Run-time variable type definition

[Pierre Yves]

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?

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?

Thanks for your help,
PY

 

[Victor Bazarov]

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

 

[Pierre Yves]

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: