Elegant way of making template arguments dependent on user input?

[Thomas Pajor]

Hey everybody,
I got into serious trouble with template programming. I have a class
which uses three template arguments, say
template<typena me Atype, typename Btype, typename Ctype>
class some_class {
};
and I want to make the values of these template arguments dependent on
the input of the program as shown by the following pseudocode:
if (input_for_Atyp e == "a")
firsttype := first_A;
else if (input_for_Atyp e == "b")
firsttype := second_A;
//...

if (input_for_Btyp e == "1")
secondtype := first_B;
else if (input_for_Btyp e == "2")
secondtype := second_B;
//...

// analogous for Ctype

// instanciate correct version of "some_class "
some_class<firs ttype, secondtype, thirdtypeinstan ce_of_class;

// Begin doing stuff with the class
instance_of_cla ss.do_something ();
//...
// End
I hope you get the idea.

The number of choices for each template argument is limited of course,
so a canonical solution would be to write out each possible combination
of the template arguments. This is really ugly, since in my case there
are already 24 possible combinations (2*4*3) for the template arguments,
and there will most likely be more in the future. Also the code would be
redundant, as the part between "Begin doing stuff" and "end" is always
the same for each of the combinations.

My question is whether there is a more elegant way to solve my problem.

I have already tried to do the following. For each of the template
arguments write a function which decides (dependant on the input) the
type of its related template, like this:
template<typena me Atype, typename Btype, typename Ctype>
inline void run() {
some_class<Atyp e, BType, Ctypeinstance_o f_class();
// do the stuff... code is only written once!
}

template<typena me Atype, typename Btype>
inline void choose_C() {
if (input_for_Ctyp e == 1)
run<Atype, Btype, first_C>();
else if (input_for_Ctyp e == 2)
run<Atype, Btype, second_C>();
// ...
}

template<typena me Atype>
inline void choose_B() {
if (input_for_Btyp e == 1)
choose_C<Atype, first_B>();
else if (input_for_Btyp e == 2)
choose_C<Atype, second_B>();
//...
}

inline void choose_A() {
if (input_for_Atyp e == 1)
choose_B<first_ A>();
else
choose_B<second _A>();
}

int main() {
choose_A();
}
Unfortunately this won't work in my case, since the value of the Atype
template also depends on "input_for_Ctyp e". In fact, the method choose_A
looks like this:
inline void choose_A() {
if (input_for_Atyp e == 1 || input_for_Ctype == 1)
choose_B<first_ A>();
else
choose_B<second _A>();
}
Now, it is crucial for input_for_Ctype == 1 to use first_A as the Atype,
since it defines some member variables which aren't available in
second_A. Unfortunately my C++ compiler seems to compile the code in the
run method for Atype = second_A and Ctype = first_C as well, though this
path is never taken in the program. This is leading to errors that
second_A won't have the requested members. Declaring all functions
inline as shown above didn't help.
I hope this wasn't too much at once, but the situation seems to be
rather complex. If there are any questions to the problem just feel free
to ask them and I will try to explain it in more detail.
Is there any solution for this or is it just impossible in C++? Of
course an alternative would be to do it with class inheritance and
virtual methods, but this is no option, since performance is most
important (I'm testing algorithms on huge datasets, taking hours of time
already). "Googling" on this problem didn't really reveal anything of use.
Greets and thanks in advance,
Thomas

PS: Maybe this is of use:

# gcc -v
Using built-in specs.
Target: x86_64-suse-linux
Configured with: ../configure --enable-threads=posix --prefix=/usr
--with-local-prefix=/usr/local --infodir=/usr/share/info
--mandir=/usr/share/man --libdir=/usr/lib64 --libexecdir=/usr/lib64
--enable-languages=c,c++ ,objc,fortran,j ava,ada --enable-checking=releas e
--with-gxx-include-dir=/usr/include/c++/4.1.0 --enable-ssp
--disable-libssp --enable-java-awt=gtk --enable-gtk-cairo
--disable-libjava-multilib --with-slibdir=/lib64 --with-system-zlib
--enable-shared --enable-__cxa_atexit --enable-libstdcxx-allocator=new
--without-system-libunwind --with-cpu=generic --host=x86_64-suse-linux
Thread model: posix
gcc version 4.1.0 (SUSE Linux)
# uname -a
Linux compute6 2.6.16.13-4-smp #1 SMP Wed May 3 04:53:23 UTC 2006 x86_64
x86_64 x86_64 GNU/Linux

[Gianni Mariani]

Thomas Pajor wrote:
....

Is there any solution for this or is it just impossible in C++? Of
course an alternative would be to do it with class inheritance and
virtual methods, but this is no option, since performance is most
important (I'm testing algorithms on huge datasets, taking hours of time
already). "Googling" on this problem didn't really reveal anything of use.

You really need to check to see if performance is an issue before you go
spending an effort on it.

If it is user input, you need to instantiate every case possible of your
template. To make it selectable, a base class or a pointer to a
function with the same signature is needed, I prefer an abstract base class.

The most extensible system (no switch or if's) is a generalized factory
system like the one in Austria C++.

Once all classes have been registered with the factory you can simply

Base * p = at::FactoryRegi ster< Base, Key >( Key( A, B, C ) )();

Any way you look at it, you need to instantiate all the possible types
you care about.

[=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=]

On 2007-10-09 23:12, Thomas Pajor wrote:

Hey everybody,
I got into serious trouble with template programming. I have a class
which uses three template arguments, say
template<typena me Atype, typename Btype, typename Ctype>
class some_class {
};
and I want to make the values of these template arguments dependent on
the input of the program as shown by the following pseudocode:

Templates are a compile-time construct. You can not use any information
that is not known at compile-time when instantiating them.

--
Erik Wikström

[Thomas Pajor]

Erik Wikström wrote:

Templates are a compile-time construct. You can not use any information
that is not known at compile-time when instantiating them.

I'm well aware of this, but I thought the compiler could use the limited
amount of available choices for each template argument to generate all
neccessary versions of the class and instanciate the correct one
depending on the user input.

Basically I was looking for a way to shorten code like this
if (input_choice_A == 1) {
if (input_choice_B == 1) {
some_class<firs tA,firstBinstan ce();
// redundant code
} else {
some_class<firs tA,secondBinsta nce();
// redundant code
}
} else {
if (input_choice_B == 1) {
some_class<seco ndA,firstBinsta nce();
// redundant code
} else {
some_class<seco ndA,secondBinst ance();
// redundant code
}
}
Of course, instead of inserting the redundant code each time, you could
write a templated function like this:
template<typena me Atype, typename Btype>
void run(some_class< Atype, Btype&instance) {
// Redundant code here only once
}
So it seems to be technically possible to make template values dependent
on user input. But - and this is what really concerns me - I'd need to
define each combination of template arguments manually, which is a LOT
in my case. It would be much shorter (and easier maintainable) if I
could define them in a way as illustrated here
if (input_choice_A == 1)
typedef firstA first_argument; // I know this won't be visible from
outside the if construct
else
typedef secondA first_argument;

if (input_choice_B == 1)
typedef firstB second_argument ;
else
typedef secondB second_argument ;
And then just instanciate the class with
some_class<firs t_argument, second_argument instance();
The advantage of such a technique becomes more and more obvious the more
combinations for the template arguments there are.
Regards,
Thomas