Are default function parameters in allowed in function templates?

[BRG]

I know that default template arguments cannot be used in function
templates but are default function parameters legal?

That is, is this:
----------------------------------
#include <functional>

template<class T, class C> bool count(T x[], C cmp = std::less<T>())
{
for(int i = 0; i < 9; ++i)
if(cmp([i], x[i + 1]))
return true;
return false;
}
----------------------------------
legal C++ code?

count(x, std::less<int>( )); // compiles ok, but
count(x); // gives "could not deduce template argument for 'C'"

Brian Gladman

[BRG]

BRG wrote:

I know that default template arguments cannot be used in function
templates but are default function parameters legal?

That is, is this:
----------------------------------
#include <functional>

template<class T, class C> bool count(T x[], C cmp = std::less<T>())
{
for(int i = 0; i < 9; ++i)
if(cmp([i], x[i + 1]))
return true;
return false;
}
----------------------------------
legal C++ code?
int x[10] // - I should have added this line as well count(x, std::less<int>( )); // compiles ok, but
count(x); // gives "could not deduce template argument for 'C'"

Brian Gladman

[Andrey Tarasevich]

BRG wrote:

I know that default template arguments cannot be used in function
templates but are default function parameters legal?
...

They are legal, but they won't work the way you expect them to work.
Default arguments for function parameters are not used in template
argument deduction process.

--
Best regards,
Andrey Tarasevich

[BRG]

Andrey Tarasevich wrote:

BRG wrote:

I know that default template arguments cannot be used in function
templates but are default function parameters legal?
...

They are legal, but they won't work the way you expect them to work.
Default arguments for function parameters are not used in template
argument deduction process

Thanks for the explanation - but I am still puzzled. In:

------------------
template<class T, class C> bool count(T x[], C cmp = std::less<T>())
....
int x[10]
count(x);
....
------------------

the template argument T can be deduced to be 'int' from the first
function parameter x. I hence don't see why deduction is involved in
the second function parameter since this seems to be substitution (T =>
int) rather than a deduction.

I guess this is a quirk of C++. But it is a nuisance since I have to
work around it.

Thanks again for your help.

Brian Gladman

[Ulrich Achleitner]

On Tue, 04 Jan 2005 00:17:50 +0000, BRG <br*@nowhere.or g> wrote:

------------------
template<class T, class C> bool count(T x[], C cmp = std::less<T>())
...
int x[10]
count(x);

i would try this:

template<class T, class C = std::less<T> > bool count(T x[], C cmp = C());

(template parameters can have default values (i.e. data types), and you
avoid the possible type mismatch between the actual class passed in for
template parameter C and the class std::less<T>)

[Jonathan Turkanis]

Ulrich Achleitner wrote:

On Tue, 04 Jan 2005 00:17:50 +0000, BRG <br*@nowhere.or g> wrote:

------------------
template<class T, class C> bool count(T x[], C cmp = std::less<T>())
...
int x[10]
count(x);

i would try this:

template<class T, class C = std::less<T> > bool count(T x[], C cmp =
C());

(template parameters can have default values (i.e. data types), and
you avoid the possible type mismatch between the actual class passed
in for template parameter C and the class std::less<T>)

Actually, function template parameters currently cannot have defaults. This
should be corrected in the next version of the standard. See
http://www.open-std.org/jtc1/sc22/wg...fects.html#226.

Jonathan

[Ulrich Achleitner]

On Tue, 4 Jan 2005 02:24:13 -0700, Jonathan Turkanis
<te******@kanga roologic.com> wrote:

Actually, function template parameters currently cannot have defaults.
This
should be corrected in the next version of the standard. See
http://www.open-std.org/jtc1/sc22/wg...fects.html#226.

thanks for the hint and the link :)
ulrich

[BRG]

Jonathan Turkanis wrote:

Ulrich Achleitner wrote:

On Tue, 04 Jan 2005 00:17:50 +0000, BRG <br*@nowhere.or g> wrote:

------------------
template<cla ss T, class C> bool count(T x[], C cmp = std::less<T>())
...
int x[10]
count(x);

i would try this:

template<clas s T, class C = std::less<T> > bool count(T x[], C cmp =
C());

(template parameters can have default values (i.e. data types), and
you avoid the possible type mismatch between the actual class passed
in for template parameter C and the class std::less<T>)

Actually, function template parameters currently cannot have defaults. This
should be corrected in the next version of the standard. See
http://www.open-std.org/jtc1/sc22/wg...fects.html#226.

Yes, that was my understanding too, which is why I was trying the other
approach.

Brian Gladman

[Ulrich Achleitner]

On Tue, 04 Jan 2005 10:51:15 +0000, BRG <br*@nowhere.or g> wrote:

template<class T, class C> bool count(T x[], C cmp = std::less<T>())
this is never a correct place for a default _type_. in a function's
parameter list there can only be default _values_.
i would try this:

template<class T, class C = std::less<T> > bool count(T x[], C cmp =
C()); Actually, function template parameters currently cannot have defaults.

so, a valid version would be:
template<class T, class C> bool count(T x[], C cmp = C());
Yes, that was my understanding too, which is why I was trying the other
approach.

more you will not get with a template function, it seems.

[BRG]

Ulrich Achleitner wrote:

On Tue, 04 Jan 2005 10:51:15 +0000, BRG <br*@nowhere.or g> wrote:

> template<class T, class C> bool count(T x[], C cmp = std::less<T>())
this is never a correct place for a default _type_. in a function's
parameter list there can only be default _values_.

Yes, but std::less<T> and std::less<T>() are values, not types, aren't they?

I thought that these are actual instances (or components) of a type (a
structure) defined in <functional>.

i would try this:

template<class T, class C = std::less<T> > bool count(T x[], C cmp =
C());

Actually, function template parameters currently cannot have defaults.
so, a valid version would be:
template<class T, class C> bool count(T x[], C cmp = C());

I'll try this, thanks.
Yes, that was my understanding too, which is why I was trying the
other approach.

more you will not get with a template function, it seems.

At least until the new standard arrives :-)

Brian Gladman