C++Talk.NET

Jordan Samuels · Guest

I am wondering if there is a way to use templates in a clever way to
provide an elegant to call multiple templatized functions with
multiple parameter types.

Imagine I have two arithmetic functions which can work on a variety of
primitive types, eg.

template<class T> T fun1(T x) { return x; }
template<> double fun1<double>(double x) { return x * 2.0; }

template<class T> T fun2(T x) { return 4 * x; }
template<> double fun2<double>(double x) { return x * 8.0; }

Assume I want to call these functions on ints, floats, and doubles (in
real life they would of course be more interesting; maybe I want to
test chip precision for these built-in types).

Now it's easy to call both for a fixed type, or one for a variety of
types:

void do_both_with_double(double x) {
cout << "fun1( (double) " << x << ") = " << fun1(x) << endl;
cout << "fun2( (double) " << x << ") = " << fun2(x) << endl;

}

void do_fun1_with_all(double x) {
cout << "fun1( (double) " << x << ") = " << fun1( x) << endl;
cout << "fun1( (float) " << x << ") = " << fun1((float)x) << endl;
cout << "fun1( (int) " << x << ") = " << fun1((int) x) << endl;
}

Then if I wanted to get ugly I could just create a do_fun2_with_all
and cut/paste the code, replacing "fun1" with "fun2". Or if I was
feeling very perverse I could use a macro.

Is there a clever way to do this with templates? Could
do_fun1_with_all become a templatized function that accepted the
template family fun1<> or fun2<> as a parameter. Something like:

template< template< class > Function >
void do_fun1_with_all(double x) {
cout << Function cout << Function // ..
}

I realize that this last snippet of code doesn't really make sense --
is there a way for it to or is this just not a possibility within C++?
I am admittedly naive about the full power of templates but from my
limited reading I see templates providing so much genericity it seems
"morally believable" that they'd be able to help here.

Thanks very much.

Jordan Samuels

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Francis Glassborow · Guest

In message <8e4648be.0401212302.4bba5a10 (AT) posting (DOT) google.com>, Jordan
Samuels <jordan (AT) madsam (DOT) com> writes

Christian Jaeger · Guest

If your compiler supports partial specialisations, you can do many
things, (see example below). - Whether thtat's clever or not - I leave
to you Smile

.

#include <iostream>

template<typename T,unsigned n> T fun(T const & x) {
std::cout << "fun with " << typeid(T).name() << 't';
return n*x;
}

template
template<typename T,unsigned k> struct DoIt:public DoIt<T,k-1>{
DoIt(T const & x):DoIt<T,k-1>(x){
std::cout << fun }
};

template
template<typename l, typename r, unsigned k> struct
DoIt<L:public DoIt<l,k>, public DoIt<r,k>{
DoIt(l const & x): DoIt<l, k >(x), DoIt<r,k >(x){}
};

int main(){

typedef L<int, L > types;
const unsigned k = 5;

DoIt<types,k> foo(10);
}

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Attila Feher · Guest

Jordan Samuels wrote: