function vs. class partial specialization

[wkaras]

I tried a couple of compilers, and both gave errors compiling this:

template <bool fin, typename T>
T foo(T val);

template <typename T>
T foo<true, T>(T val) { return(val); }

But both gave no errors compiling this:

template <bool fin, typename T>
struct foo
{
T operator () (T val);
};

template <typename T>
struct foo<true, T>
{
T operator () (T val) { return(val); }
};
Does the Standard truly have different rules for partial specialization
for function templates vs. class templates? If so, why?

[Victor Bazarov]

wk****@yahoo.com wrote:

I tried a couple of compilers, and both gave errors compiling this:

template <bool fin, typename T>
T foo(T val);

template <typename T>
T foo<true, T>(T val) { return(val); }

But both gave no errors compiling this:

template <bool fin, typename T>
struct foo
{
T operator () (T val);
};

template <typename T>
struct foo<true, T>
{
T operator () (T val) { return(val); }
};
Does the Standard truly have different rules for partial specialization
for function templates vs. class templates? If so, why?

Yes, there are no partial specialisations of function templates. Why?
Ask in comp.std.c++, they own and discuss the rationale behind the C++
Standard. But if I need to make a guess, I'd say, "because it was not
necessary". The same result can be achieved by overloading or by just
defining another function template.

V
--
Please remove capital As from my address when replying by mail

[wkaras]

Victor Bazarov wrote:

wk****@yahoo.com wrote:

I tried a couple of compilers, and both gave errors compiling this:

template <bool fin, typename T>
T foo(T val);

template <typename T>
T foo<true, T>(T val) { return(val); }

But both gave no errors compiling this:

template <bool fin, typename T>
struct foo
{
T operator () (T val);
};

template <typename T>
struct foo<true, T>
{
T operator () (T val) { return(val); }
};
Does the Standard truly have different rules for partial specialization
for function templates vs. class templates? If so, why?

Yes, there are no partial specialisations of function templates. Why?
Ask in comp.std.c++, they own and discuss the rationale behind the C++
Standard. But if I need to make a guess, I'd say, "because it was not
necessary". The same result can be achieved by overloading or by just
defining another function template.

....

While necessity is always relative, partial specialization of functions
could
be useful:

template <unsigned A, unsigned B>
void bar(void) { return(foo< (A > B) >()); }

I doesn't occur to me why partial specialization would be considered
more
useful or important for classes as opposed to functions. Of course you
can get around it by defining the equivalent partialy specialized
classes with member functions with the same name. Just seems
like a pointless asymmetry between function and class templates,
though.

[Victor Bazarov]

On Thu, 09 Feb 2006 12:01:45 -0800, wkaras wrote:

Victor Bazarov wrote:

wk****@yahoo.com wrote:

> I tried a couple of compilers, and both gave errors compiling this:
>
> template <bool fin, typename T>
> T foo(T val);
>
> template <typename T>
> T foo<true, T>(T val) { return(val); }
>
> But both gave no errors compiling this:
>
> template <bool fin, typename T>
> struct foo
> {
> T operator () (T val);
> };
>
> template <typename T>
> struct foo<true, T>
> {
> T operator () (T val) { return(val); }
> };
>
>
> Does the Standard truly have different rules for partial specialization
> for function templates vs. class templates? If so, why?
Yes, there are no partial specialisations of function templates. Why?
Ask in comp.std.c++, they own and discuss the rationale behind the C++
Standard. But if I need to make a guess, I'd say, "because it was not
necessary". The same result can be achieved by overloading or by just
defining another function template.

...

While necessity is always relative, partial specialization of functions
could
be useful:

template <unsigned A, unsigned B>
void bar(void) { return(foo< (A > B) >()); }

I don't see any partial specialisation here. Did you mean to define some
'foo' template as well?
I doesn't occur to me why partial specialization would be considered
more
useful or important for classes as opposed to functions. Of course you
can get around it by defining the equivalent partialy specialized
classes with member functions with the same name. Just seems
like a pointless asymmetry between function and class templates,
though.

Asymetry is due to the different name resolution rules. For example, you
are not allowed to have two different classes with the same name. You are
allowed, however, to have two functions with the same name, but with
different arguments. Why not extend this *existing* asymetry onto
templates? Seems rather natural.

template<unsigned U1, unsigned U2> unsigned foo() { return U1+U2; }
template<unsigned U> unsigned foo() { return U; }
// the latter is instead of
// template<unsigned U> unsigned foo<U,U>() { return U; }
#include <iostream>
int main() {
std::cout << "foo<1,2>() is " << foo<1,2>() << std::endl;
std::cout << "foo<3>() is " << foo<3>() << std::endl;
}

Victor

[Marco Wahl]

> template<unsigned U1, unsigned U2> unsigned foo() { return U1+U2; }

template<unsigned U> unsigned foo() { return U; }
// the latter is instead of
// template<unsigned U> unsigned foo<U,U>() { return U; }
#include <iostream>
int main() {
std::cout << "foo<1,2>() is " << foo<1,2>() << std::endl;
std::cout << "foo<3>() is " << foo<3>() << std::endl;
}

At a first glance I thought the above piece of code is just an idea
for function-template overloading. But it indeed compiles and
produces the expected output. (At least with my environment.)

[Rolf Magnus]

Victor Bazarov wrote:

On Thu, 09 Feb 2006 12:01:45 -0800, wkaras wrote:

Victor Bazarov wrote:

wk****@yahoo.com wrote:
> I tried a couple of compilers, and both gave errors compiling this:
>
> template <bool fin, typename T>
> T foo(T val);
>
> template <typename T>
> T foo<true, T>(T val) { return(val); }
>
> But both gave no errors compiling this:
>
> template <bool fin, typename T>
> struct foo
> {
> T operator () (T val);
> };
>
> template <typename T>
> struct foo<true, T>
> {
> T operator () (T val) { return(val); }
> };
>
>
> Does the Standard truly have different rules for partial
> specialization
> for function templates vs. class templates? If so, why?

Yes, there are no partial specialisations of function templates. Why?
Ask in comp.std.c++, they own and discuss the rationale behind the C++
Standard. But if I need to make a guess, I'd say, "because it was not
necessary". The same result can be achieved by overloading or by just
defining another function template.

...

While necessity is always relative, partial specialization of functions
could
be useful:

template <unsigned A, unsigned B>
void bar(void) { return(foo< (A > B) >()); }

I don't see any partial specialisation here. Did you mean to define some
'foo' template as well?

I doesn't occur to me why partial specialization would be considered
more
useful or important for classes as opposed to functions. Of course you
can get around it by defining the equivalent partialy specialized
classes with member functions with the same name. Just seems
like a pointless asymmetry between function and class templates,
though.

Asymetry is due to the different name resolution rules. For example, you
are not allowed to have two different classes with the same name. You are
allowed, however, to have two functions with the same name, but with
different arguments. Why not extend this *existing* asymetry onto
templates? Seems rather natural.

I'd ask the opposite question: What harm would be done by treating class
templates and function templates equally regarding partial specialization?
That would seem more natural to me than adding an artificial inconsistency
just because there is another way for functions.

[Victor Bazarov]

Rolf Magnus wrote:

[..]
I'd ask the opposite question: What harm would be done by treating class
templates and function templates equally regarding partial specialization?
That would seem more natural to me than adding an artificial inconsistency
just because there is another way for functions.

Wouldn't 'comp.std.c++' be a better place to ask this question?

V
--
Please remove capital As from my address when replying by mail