template specification

[Marc Schellens]

Just to make it sure:

it is not possibel in C++ to have a template specialization
for more than one type, right?

ie. I have several template type parameters like
string, int, long, char, float, double, complex.

The template for float and double is exactly the same,
the one for the integer types as well.
So I can make the default case for the integer types, but
I have to repeat the code for the floating type specialization, right?

thanks,
marc

 

[tom_usenet]

Just to make it sure:

it is not possibel in C++ to have a template specialization
for more than one type, right?
Right.


ie. I have several template type parameters like
string, int, long, char, float, double, complex.

The template for float and double is exactly the same,
the one for the integer types as well.
So I can make the default case for the integer types, but
I have to repeat the code for the floating type specialization, right?

Well, there are lots of ways you could share the code rather than
repeat it. Inheritence is one way. e.g.

template <class T>
class MyClassFloat
{
//...
};

template<>
class MyClass<float>: public FloatImpl<float> {};
template<>
class MyClass<double>: public FloatImpl<double> {};

Another way is to use indirection to the implementation through
traits, and bind float and double to the same traits.

Tom

 

[Marc Schellens]

Just to make it sure:

it is not possible in C++ to have a template specialization
for more than one type, right?

Right.


ie. I have several template type parameters like
string, int, long, char, float, double, complex.

The template for float and double is exactly the same,
the one for the integer types as well.
So I can make the default case for the integer types, but
I have to repeat the code for the floating type specialization, right?

Well, there are lots of ways you could share the code rather than
repeat it. Inheritence is one way. e.g.

template <class T>
class MyClassFloat
{
//...
};

template<>
class MyClass<float>: public FloatImpl<float> {};
template<>
class MyClass<double>: public FloatImpl<double> {};

Another way is to use indirection to the implementation through
traits, and bind float and double to the same traits.

Tom[/QUOTE]

Thanks Tom,

but I was not specific enough, sorry:
I meant a member function specialization.

Any suggestions for that?
thanks,
marc

 

[tom_usenet]

but I was not specific enough, sorry:
I meant a member function specialization.

Any suggestions for that?

template<class T, bool floatimpl, bool otherimpl>
struct memfunimplchooser
{
static void run(T t)
{
//default impl
}
}

template <class T>
struct memfunimplchooser<T, true, false>
{
static void run(T t)
{
//fp impl
}
};

//etc. other impls.


//and the actual function
template <class T>
void memfun(T t)
{
memfunimplchooser<T, is_float<T>::value,
is_something_else<T>::value>::run(t);
}

Tom

 

[Marc Schellens]

template<class T, bool floatimpl, bool otherimpl>
struct memfunimplchooser
{
static void run(T t)
{
//default impl
}
}

template <class T>
struct memfunimplchooser<T, true, false>
{
static void run(T t)
{
//fp impl
}
};

//etc. other impls.


//and the actual function
template <class T>
void memfun(T t)
{
memfunimplchooser<T, is_float<T>::value,
is_something_else<T>::value>::run(t);
}

Tom

A bit ugly I think.
But thank you very much for the suggestion,
marc