Re: template function specialisation
On 2/28/2014 12:45 PM, Tobias M??ller wrote:
Victor Bazarov <v.bazarov@comcast.invalid> wrote:
On 2/28/2014 8:36 AM, peter koch wrote:
Den fredag den 28. februar 2014 13.37.32 UTC+1 skrev Victor Bazarov:
On 2/28/2014 4:15 AM, peter koch wrote:
I have a problem specializing a template function. Is it me or is it Microsoft?
I suspect it's you.
imagine:
template<typename T1,typename T2>
struct dummy {};
template<typename T>
void func() { }
template<>
void func<int>() { }
template<typename T1,typename T2>
void func<dummy<T1,T2>>() {}
For the second specialization I get
error : 'func' : illegal use of explicit template arguments
The information at
http://msdn.microsoft.com/en-us/library/e338tex6.aspx does not give
me an explanation I understand. It talks about partial specialization
of functions but is this it? I know how to work my way out of it, but
the above notation is more elegant to me.
You need to make up your mind about 'func'. It's either a template of
one argument, in which case you can put a single argument between the
angle brackets following the name of that function, like you did with
func< dummy<...> >
^^^^^^^^^^ That's the argument of 'func' template and it's a
*single* one.
, or it's a template of two arguments as you claim in the beginning of
the declaration:
template<typename T1, typename T2>
void...
Perhaps you misread my code?
f has one template argument. The two-argument template you quoted above
is the definition of a struct.
In your code, there are two correct declarations (and definitions since
there is the compound statement, albeit empty, right after the closing
parenthesis) of the 'func' template. One is
template<typename T>
void func() { }
and the other
template<>
void func<int>() { }
The latter declares (and defines) a [full] specialization of the former.
The former *is* a template of 1 argument.
Right after the specialization you have a declaration that is improper,
and the compiler has told you about that. On one hand, it's a template
of two arguments - since it starts with
template<typename T1, typename T2> ...
On the other hand, it's a template of only one argument, because you only
supply one such argument in the angle brackets after the name.
I also think that you have misread or misunderstood his original post.
<shrug> Whatever you call it. The question was "is it me, or
Microsoft," and it's not Microsoft.
The syntax did look like an attempt to declare a partial specialization,
but if the OP cared to parse himself what he had written it would be
obvious why it won't work. Not that it's not allowed, but that it was
simply illogical.
Now, imagine that the class template on which Peter tried to specialize
the function had only one template argument. The parsing of it would
probably not lead to the same error.
template<class T> class tt {};
template<class T> void foo() { std::cout << "original\n"; }
template<class U> void foo< tt<U> > () { std::cout << "special\n"; }
int main() {
foo<int>();
foo<tt<int>>();
}
Microsoft says "function template has already been defined" trying to
compile the second declaration of 'foo' (starting with the
'template<class U>'). IOW, there is no conflict between the number of
template arguments of the declaration and the angle brackets, but the
function declaration is treated as the same (because it's not a
specialization and has the same template arguments -- one type).
In that case Peter might be more puzzled, but then the answer would
inevitably be that partial specializations are not allowed. Same for
trying to specialize for T* or T& etc.
> It
is a partial specialization and partial specializations _can_ have more
parameters than the template that they are specializing on.
:-)
It isn't a partial specialization because there can be no partial
specializations of function templates. And, yes, since you've mentioned
it, partial specializations *of class templates* can have a different
number of arguments than then original.
> It's just that
partial specializations of _function_ templates are not allowed.
In part the reason they aren't allowed is that there is no easy way to
declare them. For classes it's simple, the template-id cannot be
overloaded. Function templates are allowed to be overloaded, so with
overloading of function templates allowed it's difficult to distinguish
whether what the compiler is parsing is a new template or a partial
specialization of the existing one. I am guessing, of course. I have
no experience writing C++ parsers.
V
--
I do not respond to top-posted replies, please don't ask