Re: function template explicit specialization not chosen
On 2012-04-19 06:53, ??? ??? wrote:
in the code below
++++++++++++++++++++++++++++++ example-1 ++++++++++++++++++++++++++++++
++++++++
struct dummy { };
template<typename T> int hash (T);
template<typename T> int hash (T t) { return t; } // (1)
template<> int hash (dummy const&) { return 0; } // (2)
int main ()
{
dummy a;
dummy const&b = a;
hash(b); // expect (2) called
}
-------------------------------------------------------------------------------
my compiler seems to select the primary function template and that
caused a
compiler error of not being able to convert dummy to int. comeau
online test
compiler also generates the same error. In either case, the
specialization is
not chosen.
This behaviour is to be expected (see below).
If I comment out (1) as in the next example
++++++++++++++++++++++++++++++ example-2 ++++++++++++++++++++++++++++++
++++++++
struct dummy { };
template<typename T> int hash (T);
// template<typename T> int hash (T t) { return t; } // (1)
template<> int hash (dummy const&) { return 0; } // (2)
int main ()
{
dummy a;
dummy const&b = a;
hash(b); // expect (2) called
return 0;
}
-------------------------------------------------------------------------------
g++ then says undefined reference and this means it still selected the
primary template. but comeau online this time compiles just fine and this
seems to suggest it used the specialization.
I think you are misinterpreting Comeau here: The compiler does *not*
link (see the corresponding remark somewhere on the web page), and
odr-using a function without definition does not require a diagnostic.
In other words: The fact, that Comeau seemingly accepts the code does
not proof that it selects the second form. In fact, such behaviour would
be very astonishing: The outcome of overload resolution does not depend
on whether a function (template) definition exists or not.
My question is :
(1) What does the standard (c++11) say about the call to hash with b,
should T
be deduced to be dummy const&, or should it be dummy const?
It won't be deduced to be dummy const&, that is for sure. The rules for
selection of function templates in this context is uniformly described
by 14.8.2.1 [temp.deduct.call]. The function parameter type P here is
not a reference type, therefore we need to consider p2:
"If P is not a reference type: [..] If A is a cv-qualified type, the top
level cv-qualifiers of A???s type are ignored for type deduction."
So even though the argument type A is a cv-qualified type (The type is
'dummy const'), this is irrelevant here. As a rule of thumb one should
remember that a function template that looks like using "by-value"
arguments, will have this way, unless you provide explicit template
parameters that would change that.
(2) Is the specialization in the candidate function set at all?
I'm not sure that I understand you correctly: There won't happen any
overload resolution between 'int hash(dummy)' and 'int hash(const
dummy&). There does only exist a single function template, the compiler
deduces the parameter types by the process described in
[temp.deduct.call] and this ends in a deduced form of int
hash<dummy>(dummy). There does not exist an explicit specialization of
that form, therefore the primary form is instantiated. This clearly
demonstrates that you would need to provide a specialization of this form
template <> int hash (dummy) { return 0; }
to get the compiler find the wanted specialization.
(3) For the difference between g++ and comeau as in example-2, which
one is more
standard compliant?
I don't see any evidence that both compiler differ here.
HTH & Greetings from Bremen,
Daniel Kr??gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]