Re: Automatic conversion of arguments in template functions
Meph wrote:
I know the following is supposed to work because struct AAA has a
constructor taking an int.
#include<iostream>
struct AAA {
AAA(int n): value(n) {}
int value;
};
bool operator==(const AAA& p, const AAA& q)
{
return p.value==q.value;
}
int main()
{
AAA x(1);
std::cout<<(1==x)<<std::endl;
return 0;
}
Can anyone tell me the part of the standard that disallows the
templated version of the above, like so:
#include<iostream>
template<class T>
struct AAA {
AAA(int n): value(n) {}
int value;
};
template<class T>
bool operator==(const AAA<T>& p, const AAA<T>& q)
{
return p.value==q.value;
}
int main()
{
AAA<int> x(1);
std::cout<<(1==x)<<std::endl;
return 0;
}
Why isn't a compiler required to convert 1==x to AAA<int>(1)==x, as in
the non-template case?
Section 14 of the Standard deals with templates. IIRC 14.8 deals
with deducing template arguments from a function call (in your case
operator== is that function). In that clause the Standard says that
no conversions are considered (you'd have to read it to find the
exact spot where it says that). The reason is that with templates
the set of types fitting the conversion is unlimited. The compiler
cannot arbitrarily decide that 'AAA<int>' is the right one because
I can create another specialisation of 'AAA' that might be better
fit, for example if I have the operator==(int, AAA<mytype>) defined
for it.
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask