template overload resolution

[hurcan solter]

given the code snippet;

template<typename T>
void foo(T,T){}

template<typename T1,typename T2>
void foo(T1*,T2*){}

int main( ) {

foo((int*)0,(int*)0);

}

Could anyone please explain me why the second template is not more
viable for overload resolution?
AFAIK each argument is matched with corresponding parameter. in that
case shouldnt T1* and T2* match better than T for (int*)? I assume T1
and T2 are disjoint aren't they? or must they be different types?

Thanks in advance.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

[Victor Bazarov]

hurcan solter wrote:

given the code snippet;

template<typename T>
void foo(T,T){}

template<typename T1,typename T2>
void foo(T1*,T2*){}

int main( ) {

foo((int*)0,(int*)0);

}

Could anyone please explain me why the second template is not more
viable for overload resolution?
AFAIK each argument is matched with corresponding parameter. in that
case shouldnt T1* and T2* match better than T for (int*)? I assume T1
and T2 are disjoint aren't they? or must they be different types?

A template with fewer arguments is considered more specialised than one
with more arguments, I guess. The more arguments a template has, the
more generic it is.

Those are just guesses, of course. I don't have time to look through
the Standard for confirmation.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[hurcan solter]

A template with fewer arguments is considered more specialised than one
with more arguments, I guess. The more arguments a template has, the
more generic it is.

Those are just guesses, of course. I don't have time to look through
the Standard for confirmation.

Well, in fact the call is ambiguous.it's unambiguous if i define
foo(T*,T*)
which suggests that,there is also a relation between argument that it
prevents from
one preferred over another.

[Hendrik Schober]

hurcan solter <hs*****@gmail.comwrote:

given the code snippet;

template<typename T>
void foo(T,T){}

template<typename T1,typename T2>
void foo(T1*,T2*){}

int main( ) {

foo((int*)0,(int*)0);

}

Could anyone please explain me why the second template is not more
viable for overload resolution?
[...]

From <http://www.comeaucomputing.com/tryitout/>:

Comeau C/C++ 4.3.9 (Mar 27 2007 17:24:47) for ONLINE_EVALUATION_BETA1
Copyright 1988-2007 Comeau Computing. All rights reserved.
MODE:strict errors C++ C++0x_extensions

"ComeauTest.c", line 9: error: more than one instance of overloaded
function "foo"
matches the argument list, the choices that match are:
function template "void foo(T, T)"
function template "void foo(T1 *, T2 *)"
The argument types that you used are: (int *, int *)
foo((int*)0,(int*)0);
^

1 error detected in the compilation of "ComeauTest.c".

Thanks in advance.

HTH,

Schobi

--
Sp******@gmx.de is never read
I'm HSchober at gmx dot de
"If there were some arcane way to remove the heads of every
newsgroup troll on the planet, I think it would elevate
humans to a whole new level of intelligence."
Rocky Frisco

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

[Victor Bazarov]

Hendrik Schober wrote:

hurcan solter <hs*****@gmail.comwrote:

>given the code snippet;

template<typename T>
void foo(T,T){}

template<typename T1,typename T2>
void foo(T1*,T2*){}

int main( ) {

foo((int*)0,(int*)0);

}

Could anyone please explain me why the second template is not more
viable for overload resolution?
[...]

From <http://www.comeaucomputing.com/tryitout/>:

Comeau C/C++ 4.3.9 (Mar 27 2007 17:24:47) for ONLINE_EVALUATION_BETA1
Copyright 1988-2007 Comeau Computing. All rights reserved.
MODE:strict errors C++ C++0x_extensions

"ComeauTest.c", line 9: error: more than one instance of overloaded
function "foo"
matches the argument list, the choices that match are:
function template "void foo(T, T)"
function template "void foo(T1 *, T2 *)"
The argument types that you used are: (int *, int *)
foo((int*)0,(int*)0);
^

1 error detected in the compilation of "ComeauTest.c".

> Thanks in advance.

HTH,

Schobi

Could you perhaps enlighten us how this explains *why* the second
template is *not* more viable?

Thanks!

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Hendrik Schober]

Victor Bazarov <v.********@comAcast.netwrote:

Hendrik Schober wrote:

hurcan solter <hs*****@gmail.comwrote:

given the code snippet;
>
template<typename T>
void foo(T,T){}
>
template<typename T1,typename T2>
void foo(T1*,T2*){}
>
int main( ) {
>
foo((int*)0,(int*)0);
>
}
>

[...]

From <http://www.comeaucomputing.com/tryitout/>:

Comeau C/C++ 4.3.9 (Mar 27 2007 17:24:47) for ONLINE_EVALUATION_BETA1
Copyright 1988-2007 Comeau Computing. All rights reserved.
MODE:strict errors C++ C++0x_extensions

"ComeauTest.c", line 9: error: more than one instance of overloaded
function "foo"
matches the argument list, the choices that match are:
function template "void foo(T, T)"
function template "void foo(T1 *, T2 *)"
The argument types that you used are: (int *, int *)
foo((int*)0,(int*)0);
^

1 error detected in the compilation of "ComeauTest.c".

Thanks in advance.

HTH,

Schobi

Could you perhaps enlighten us how this explains *why* the second
template is *not* more viable?

I don't think I can.
I /guessed/ neither specialization to be more viable.
I tried Comeau and found it agreeing with my guess.
So I posted Comeau's opinion on the matter. (When I
did this, my news server didn't have your reply yet,
so I wasn't trying to contradict you.)

Schobi

--
Sp******@gmx.de is never read
I'm HSchober at gmx dot de
"If there were some arcane way to remove the heads of every
newsgroup troll on the planet, I think it would elevate
humans to a whole new level of intelligence."
Rocky Frisco

[Victor Bazarov]

Hendrik Schober wrote:

Victor Bazarov <v.********@comAcast.netwrote:

>Hendrik Schober wrote:

>>hurcan solter <hs*****@gmail.comwrote:
given the code snippet;

template<typename T>
void foo(T,T){}

template<typename T1,typename T2>
void foo(T1*,T2*){}

int main( ) {

foo((int*)0,(int*)0);

}

[...]

>>>
From <http://www.comeaucomputing.com/tryitout/>:

Comeau C/C++ 4.3.9 (Mar 27 2007 17:24:47) for
ONLINE_EVALUATION_BETA1 Copyright 1988-2007 Comeau Computing. All
rights reserved. MODE:strict errors C++ C++0x_extensions

"ComeauTest.c", line 9: error: more than one instance of overloaded
function "foo"
matches the argument list, the choices that match are:
function template "void foo(T, T)"
function template "void foo(T1 *, T2 *)"
The argument types that you used are: (int *, int *)
foo((int*)0,(int*)0);
^

1 error detected in the compilation of "ComeauTest.c".

Thanks in advance.

HTH,

Schobi

Could you perhaps enlighten us how this explains *why* the second
template is *not* more viable?

I don't think I can.
I /guessed/ neither specialization to be more viable.
I tried Comeau and found it agreeing with my guess.
So I posted Comeau's opinion on the matter. (When I
did this, my news server didn't have your reply yet,
so I wasn't trying to contradict you.)

Please do contradict, I am all for a healthy discussion. Besides, my
answer was just a guess, I am not even sure it is correct unless it's
confirmed or proven wrong.

The reason I am asking is that it seems that your reply is essentially
giving the answer "because Comeau C++ says it is" to the 'why' question.
My understanding is that the OP had already found out that the second
function template was not more viable, you simply confirmed what the OP
already knew, *OR* I misunderstood something (which happens more often
as I grow older, unfortunately), and then I need to be shown the light.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Hendrik Schober]

Victor Bazarov <v.********@comAcast.netwrote:

Hendrik Schober wrote:

Victor Bazarov <v.********@comAcast.netwrote:

Hendrik Schober wrote:
hurcan solter <hs*****@gmail.comwrote:
given the code snippet;
>
template<typename T>
void foo(T,T){}
>
template<typename T1,typename T2>
void foo(T1*,T2*){}
>
int main( ) {
>
foo((int*)0,(int*)0);
>
}
>
[...]

From <http://www.comeaucomputing.com/tryitout/>:

Comeau C/C++ 4.3.9 (Mar 27 2007 17:24:47) for
ONLINE_EVALUATION_BETA1 Copyright 1988-2007 Comeau Computing. All
rights reserved. MODE:strict errors C++ C++0x_extensions

"ComeauTest.c", line 9: error: more than one instance of overloaded
function "foo"
matches the argument list, the choices that match are:
function template "void foo(T, T)"
function template "void foo(T1 *, T2 *)"
The argument types that you used are: (int *, int *)
foo((int*)0,(int*)0);
^

1 error detected in the compilation of "ComeauTest.c".

Thanks in advance.

HTH,

Schobi
>
Could you perhaps enlighten us how this explains *why* the second
template is *not* more viable?

I don't think I can.
I /guessed/ neither specialization to be more viable.

These aren't specializations, but overloaded
functions. (No partial specialization of
function templates. I know. Damn.)

I tried Comeau and found it agreeing with my guess.
So I posted Comeau's opinion on the matter. (When I
did this, my news server didn't have your reply yet,
so I wasn't trying to contradict you.)

Please do contradict, I am all for a healthy discussion. Besides, my
answer was just a guess, I am not even sure it is correct unless it's
confirmed or proven wrong.

My answer was just a guess, tooI wouldn't know chapter
and verse, but this

template<typename T>
void foo(T,T){}

template<typename T1,typename T2>
void foo(T1*,T2*){}

int main()
{
foo((int*)0,(int*)0);
}

looks to me as if neither overloaded version is
a better fit than the other -- which is why I
asked Comeau to confirm. .

The reason I am asking is that it seems that your reply is essentially
giving the answer "because Comeau C++ says it is" to the 'why' question.
My understanding is that the OP had already found out that the second
function template was not more viable, you simply confirmed what the OP
already knew, *OR* I misunderstood something (which happens more often
as I grow older, unfortunately), and then I need to be shown the light.

I'm sorry I wasn't making my opinion clearer. I
assumed that neither function template was a
better fit. I thought posting an error message
that says exactly that would make that clear. I
should probably have been more explicit, though.

V

Schobi

--
Sp******@gmx.de is never read
I'm HSchober at gmx dot de
"If there were some arcane way to remove the heads of every
newsgroup troll on the planet, I think it would elevate
humans to a whole new level of intelligence."
Rocky Frisco

[Craig Scott]

On Aug 1, 2:19 am, hurcan solter <[e-mail]:

template<typename T>
void foo(T,T){}

template<typename T1,typename T2>
void foo(T1*,T2*){}

int main( ) {

foo((int*)0,(int*)0);

}

Could anyone please explain me why the second template is not more
viable for overload resolution?
AFAIK each argument is matched with corresponding parameter. in that
case shouldnt T1* and T2* match better than T for (int*)? I assume T1
and T2 are disjoint aren't they? or must they be different types?

As far as the compiler is concerned, both can be matched equally well.
No conversions are involved in either case, so there is no reason for
the compiler to favour one over the other. You might be getting
confused with *class* partial specialization. Eg
#include <iostream>

template<typename T>
class Bar
{
public:
Bar() { std::cout << "(1)" << std::endl; }
};

template<typename T>
class Bar<T*>
{
public:
Bar() { std::cout << "(2)" << std::endl; }
};

int main()
{
Bar<int barInt; // Prints (1)
Bar<int* barIntPtr; // Prints (2)
}

--
Computational Modeling, CSIRO (CMIS)
Melbourne, Australia
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]