«

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

On Fri, 03 Oct 2003 01:51:55 +0900, Marc Schellens
<> wrote:

>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

> On Fri, 03 Oct 2003 01:51:55 +0900, Marc Schellens
> <> wrote:
>
>
>>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

Thanks Tom,

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

Any suggestions for that?
thanks,
marc

On Fri, 03 Oct 2003 19:09:10 +0900, Marc Schellens
<> wrote:

>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

tom_usenet wrote:
> On Fri, 03 Oct 2003 19:09:10 +0900, Marc Schellens
> <> wrote:
>
>
>>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

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