Re: template function specialisation
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.
Perhaps you're not aware that you're allowed to declare function
templates with the same name but with different number of arguments, and
they are *not* specializations of one another, they are simply
overloaded templates. For instance,
#include <iostream>
template<typename T>
void func()
{
std::cout << "func<> of ONE arg\n";
}
template<>
void func<int>()
{
std::cout << "func<> of 'int'\n";
}
template<typename T1, typename T2>
void func()
{
std::cout << "func<> of two args\n";
}
int main()
{
func<char>();
func<std::ostream*, double>();
func<int>();
}
What is it you're trying to accomplish?
Let us say I have a function. Mostly I would do one thing - say
stream
out the typename of the type. But for one particular template type -
think std::pair - I would like to do something else - say stream out the
typename of each type.
The real example is for accessing a GUI element, where I have a
generic functionality for most types but a different functionality for a
collection of elements (something similar to a std::vector). I just
wanted to simplify the example given.
Make your example more concrete. Does your function have an argument,
perhaps? If so, don't specify the template arguments (after the
function name), let the compiler figure them from the function arguments.
Also, what book are you reading on templates?
V
--
I do not respond to top-posted replies, please don't ask