Template functions and overloading

[Bolin]

I am frustrated as I am trying to design a toy image library. I want
the user to write

mul(im, 2)

if s/he wants to multiply the image by 2, and

mul(im1, im2)

if s/he wants to multiply two images together. I would have like to
have two overloaded functions, the problem is that to be generic both
functions needs to have both arguments templated. Now I end up with
two functions having the same declaration, and that's bad.

Any idea to sort this mess out? I guess I have to have some mechanism
that could differentiate an image (by adding some special field or
typedef or inheritance from some class) from any other type during
precompilation, and do the if/else manually inside a single function.
But I am not sure how.

Thanks for you help,

B.

[Michael Kurz]

"Bolin" <ga*******@voil a.fr> schrieb im Newsbeitrag
news:93******** *************** ***@posting.goo gle.com...

I am frustrated as I am trying to design a toy image library. I want
the user to write

mul(im, 2)

if s/he wants to multiply the image by 2, and

mul(im1, im2)

if s/he wants to multiply two images together. I would have like to
have two overloaded functions, the problem is that to be generic both
functions needs to have both arguments templated. Now I end up with
two functions having the same declaration, and that's bad.

Any idea to sort this mess out? I guess I have to have some mechanism
that could differentiate an image (by adding some special field or
typedef or inheritance from some class) from any other type during
precompilation, and do the if/else manually inside a single function.
But I am not sure how.

If your class is a class template, where it is not allowed to specialize
member templates without specializing the class as well, I'd suggest to use
overloading, here is a small sample (using Andrei Alexandrescu's Loki):

<snip>
template<class T>
class CFoo{
// List all types you want to use with the numeric implementation.
typedef TYPELIST_4(int, unsigned int, float, double) NumericTypes_t;
public:
// actual mul template function
template<class T1, class T2>
T1 mul(T1 p1, T2 p2){
// switches by a dummy parameter between a numeric and a not
numeric implementation.
return mulSwitchByOlve rload(p1,p2, Loki::Int2Type<
Loki::TL::Index Of<NumericTypes _t, T2>::value >= 0>());
}
private:
template<class T1, class T2>
T1 mulSwitchByOlve rload(T1 pa1, T2 p2, Loki::Int2Type< true>){
printf("Mult by numeric...\n");
return T1();
}

template<class T1, class T2>
T1 mulSwitchByOlve rload(T1 pa1, T2 p2, Loki::Int2Type< false>){
printf("Mult not numeric...\n");
return T1();
}
</snip>

[Tom Widmer]

On 17 Oct 2004 18:10:58 -0700, ga*******@voila .fr (Bolin) wrote:

I am frustrated as I am trying to design a toy image library. I want
the user to write

mul(im, 2)

if s/he wants to multiply the image by 2, and

mul(im1, im2)

if s/he wants to multiply two images together. I would have like to
have two overloaded functions, the problem is that to be generic both
functions needs to have both arguments templated. Now I end up with
two functions having the same declaration, and that's bad.

Any idea to sort this mess out? I guess I have to have some mechanism
that could differentiate an image (by adding some special field or
typedef or inheritance from some class) from any other type during
precompilation , and do the if/else manually inside a single function.
But I am not sure how.

If you download and install boost, you can do something like this:

template <typename T1, typename T2>
typename boost::enable_i f<boost::is_num eric<T2>, T1>::type
mul(T1 const& t1, T2 t2)
{
//implement numeric version
}

template <typename T1, typename T2>
typename boost::enable_i f_c<!boost::is_ numeric<T2>::va lue, T1>::type
mul(T1 const& t1, T2 const& t2)
{
//implement image version
}

I think you'll need an up-to-date compiler to handle it though.

Tom

[Bolin]

Thanks for both your answers. The problem is that I cannot assume that
'non-image' types are numeric types. For example, I might have an
image of vectors, and the user could write

mul(vecim, scalar);
mul(vecim, vector); // say, element-wise multiplication
mul(vecim, matrix);
....

and all would call the 'non-image' version of mul. Actually this 'mul'
is expected to work whenever the self-multiplication of element of the
image with the second parameter is possible.
Tom Widmer <to********@hot mail.com> wrote in message news:<5u******* *************** **********@4ax. com>...

On 17 Oct 2004 18:10:58 -0700, ga*******@voila .fr (Bolin) wrote:
If you download and install boost, you can do something like this:

template <typename T1, typename T2>
typename boost::enable_i f<boost::is_num eric<T2>, T1>::type
mul(T1 const& t1, T2 t2)
{
//implement numeric version
}

template <typename T1, typename T2>
typename boost::enable_i f_c<!boost::is_ numeric<T2>::va lue, T1>::type
mul(T1 const& t1, T2 const& t2)
{
//implement image version
}

I think you'll need an up-to-date compiler to handle it though.

Tom

[Tom Widmer]

On 18 Oct 2004 07:23:19 -0700, ga*******@voila .fr (Bolin) wrote:

Thanks for both your answers. The problem is that I cannot assume that
'non-image' types are numeric types. For example, I might have an
image of vectors, and the user could write

mul(vecim, scalar);
mul(vecim, vector); // say, element-wise multiplication
mul(vecim, matrix);
...

and all would call the 'non-image' version of mul. Actually this 'mul'
is expected to work whenever the self-multiplication of element of the
image with the second parameter is possible.

You'll need some kind of traits class to dispatch to the correct
implementation - I assume you'll have 3 implementations of mul, to go
with the three cases above.

template <class T>
struct dimension_trait s
{
static int const dimensions =
dimension_trait s_helper<T, is_scalar<T>::v alue,
is_container<T> ::value>::dimen sions;
};

or something like that. Then you can use the enable_if technique, or
ordinary overloading. Alternatively you could redesign your interface
a bit, perhaps to use iterators for the vector case.

Tom

[Bolin]

Tom Widmer <to********@hot mail.com> wrote in message news:<tb******* *************** **********@4ax. com>...

template <class Image, class T>
void mul(Image const& im, T const& t)
{
//dispatch depending on whether T is an image or not.
mul(im, t, int_to_type<ima ge_traits<T>::i s_image>());
}
Thanks, that's what was needed. Works much better than my if/then.

That's the standard "old-style" way that dispatch is done using
overloading. The new way is to use enable_if.

Thanks for the tip.

B.