 Boost :

From: Marco (mrcekets_at_[hidden])
Date: 2007-04-16 10:33:23

I gave a glance to the papers about variadic templates and I didn't see
examples using a construct such as f(args)... where args is a function
parameter pack; so I guess that the following code it's illegal:

template< typename T >
T max( T x )
{
return x;
}

template< typename T, typename... Args >
// where are_same<T, Args...>
T max( T x, T y, Args... args )
{
return std::max( x, max( y, args... ) );
}

// #1
template< typename T, typename... Args >
// where are_same<T, Args...>
T max_abs( T x, T y, Args... args )
{
// this is the (probably) illegal construct:
return max( abs(x), abs(y), abs(args)... );
// I'd like that "abs(args)..." expands to "abs(arg1), ... ,abs(argN)"
}

What's the rationale behind such a design choice ?

I admit that a simple workaround exists:

// #2
template< typename T >
T max_abs( T x )
{
return abs(x);
}

template< typename T, typename... Args >
// where are_same<T, Args...>
T max_abs( T x, T y, Args... args )
{
return std::max(abs(x), max_abs(y, args...) );
}

anyway version #1 is more straightforward, and maybe it's possible to make
up examples more complex than mine.

Another question: given the following functions:

// #1
template< typename T >
void f(T ) {}

// #2
template< typename T, typename... Args >
void f(T, Args... ) {}

the function call f(1,2) is it ambiguous ?
if it isn't, which is the function called ?
#1 because it's more specialized ? (only a guess)

Kind Regards,
Marco

```--
Using Opera's revolutionary e-mail client: http://www.opera.com/mail/
```