public inbox for gcc-bugs@sourceware.org
help / color / mirror / Atom feed
* [Bug c++/15629] New: Function overloading doesn't happen when I use friend function templates in class templates.
@ 2004-05-25 3:05 ywhu at nmi dot iii dot org dot tw
2004-05-25 12:50 ` [Bug c++/15629] Function templates, overloads, and friend name injection bangerth at dealii dot org
` (2 more replies)
0 siblings, 3 replies; 4+ messages in thread
From: ywhu at nmi dot iii dot org dot tw @ 2004-05-25 3:05 UTC (permalink / raw)
To: gcc-bugs
Hi,
When I use friend function templates in a class template, the function
overloading doesn't happend.
The following is the source.
==============================================================
#include <iostream>
template<int a, int b>
class T;
template<int a, int b>
void func(T<a, b> const * const t)
{
std::cerr << "T<a, b>" << std::endl;
}
template<int a, int b>
class T
{
private:
friend void func<a, b>(T<a, b> const * const t);
friend void func<a>(T<a, 3> const * const t);
public:
void ttt() const;
};
template<int a>
void
func(T<a, 3> const * const t)
{
std::cerr << "T<a, 3>" << std::endl;
}
template<int a, int b>
void
T<a, b>::ttt() const
{
func(this);
}
int
main()
{
T<2, 3> t;
t.ttt();
return 0;
}
==============================================================
The error messages from gcc-3.2 is as following:
==============================================================
eee.cpp: In member function `void T<a, b>::ttt() const [with int a =
2, int b =
3]':
eee.cpp:52: instantiated from here
eee.cpp:44: call of overloaded `func(const T<2, 3>* const)' is
ambiguous
eee.cpp:8: candidates are: void func(const T<a, b>*) [with int a = 2,
int b =
3]
eee.cpp:29: void func(const T<a, 3>*) [with int a = 2]
eee.cpp:8: void func(const T<a, b>*) [with int a = 2,
int b =
3]
eee.cpp:29: void func(const T<a, 3>*) [with int a = 2]
==============================================================
However, when I use gcc-3.2, gcc-3.3, gcc-3.4 to compile my code, the
result is strange.
Here is my result:
1) gcc-3.2: can _not_ compile, the error message is copied and pasted
above.
2) gcc-3.3: can compile, but the result is
T<a, b>
[but I think it should be T<a, 3>]
3) gcc-3.4: can compile, but the result is
T<a, b>
[but I think it should be T<a, 3>]
< NOTE >
When I use 'struct' rather than 'class', and remove the 'friend'
declarations,
the function overloading works fine !
=============================================================
Question 2:
=============================================================
I added one more friend function declaration, and now, even gcc-3.3
doesn't compile my code.
The source code is as following:
==============================================================
#include <iostream>
template<int a, int b>
class T;
template<int a, int b>
void func(T<a, b> const * const t)
{
std::cerr << "T<a, b>" << std::endl;
}
template<int a, int b>
class T
{
private:
friend void func<a, b>(T<a, b> const * const t);
friend void func<a>(T<a, 3> const * const t);
friend void func<b>(T<3, b> const * const t); <-- add this -->
public:
void ttt() const;
};
template<int a>
void
func(T<a, 3> const * const t)
{
std::cerr << "T<a, 3>" << std::endl;
}
template<int b> <-- add this definition -->
void
func(T<3, b> const * const t)
{
std::cerr << "T<3, b>" << std::endl;
}
template<int a, int b>
void
T<a, b>::ttt() const
{
func(this);
}
int
main()
{
T<2, 3> t;
t.ttt();
return 0;
}
==============================================================
I can _not_ compile the code using gcc-3.2, and the error message for
gcc-3.2 is
like the one I posted above:
==============================================================
eee.cpp: In instantiation of `T<2, 3>':
eee.cpp:50: instantiated from here
eee.cpp:19: ambiguous template specialization `func<3>' for `void
func(const
T<3, 3>*)'
eee.cpp: In member function `void T<a, b>::ttt() const [with int a =
2, int b =
3]':
eee.cpp:52: instantiated from here
eee.cpp:44: call of overloaded `func(const T<2, 3>* const)' is
ambiguous
eee.cpp:8: candidates are: void func(const T<a, b>*) [with int a = 2,
int b =
3]
eee.cpp:29: void func(const T<a, 3>*) [with int a = 2]
eee.cpp:8: void func(const T<a, b>*) [with int a = 2,
int b =
3]
eee.cpp:29: void func(const T<a, 3>*) [with int a = 2]
==============================================================
Again, the following is the result when I compile it using gcc-3.2,
gcc-3.3 and gcc-3.4:
1) gcc-3.2: can _not_ compile, the error message posted above.
2) gcc-3.3: can _not_ compile, the error message just like the one
posted for gcc-3.2.
3) gcc-3.4: can compile, but the result is
T<a, b>
[but I think it should be T<a, 3>]
==============================================================
My environment:
1) Debian unstable
2) gcc-3.4.0 (Debian 20040516)
3) gcc-3.3.3 (Debian 20040422)
4) gcc-3.2.3
5) Command line options: none
6)
--
Summary: Function overloading doesn't happen when I use friend
function templates in class templates.
Product: gcc
Version: 3.3.3
Status: UNCONFIRMED
Severity: critical
Priority: P2
Component: c++
AssignedTo: unassigned at gcc dot gnu dot org
ReportedBy: ywhu at nmi dot iii dot org dot tw
CC: gcc-bugs at gcc dot gnu dot org
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=15629
^ permalink raw reply [flat|nested] 4+ messages in thread
* [Bug c++/15629] Function templates, overloads, and friend name injection
2004-05-25 3:05 [Bug c++/15629] New: Function overloading doesn't happen when I use friend function templates in class templates ywhu at nmi dot iii dot org dot tw
@ 2004-05-25 12:50 ` bangerth at dealii dot org
2004-05-26 17:13 ` pinskia at gcc dot gnu dot org
2004-05-26 18:43 ` [Bug c++/15629] [3.3/3.4/3.5 Regressions] " giovannibajo at libero dot it
2 siblings, 0 replies; 4+ messages in thread
From: bangerth at dealii dot org @ 2004-05-25 12:50 UTC (permalink / raw)
To: gcc-bugs
------- Additional Comments From bangerth at dealii dot org 2004-05-24 15:19 -------
OK, something is really screwed up here. Take this:
-----------------
#include <iostream>
#define PRINT std::cerr << __PRETTY_FUNCTION__ << std::endl
template<int a, int b> class T;
template<int a, int b> void func(T<a, b> * t) { PRINT; }
template<int a> void func(T<a, 3> * t) { PRINT; }
template<int a, int b> struct T {
friend void func<a, b>(T<a, b> * t);
friend void func<a> (T<a, 3> * t);
void foo();
};
template<int a, int b> void T<a, b>::foo() {
func((T<2,3>*)0);
}
int main() {
func((T<2,3>*)0);
T<2,3>().foo();
}
-----------------------
Note that the call to func in main() is the same as the one in foo(), so
it should really yield the same result. Alas, with gcc3.4, we get:
g/x> /home/bangerth/bin/gcc-3.4-pre/bin/c++ x.cc ; ./a.out
void func(T<a, 3>*) [with int a = 2]
void func(T<a, b>*) [with int a = 2, int b = 3]
On the other hand, if we revert the order of the two calls in main(), we get
a different result, namely a call to the general T<a,b> template as in the
second line above. My inclination is to say that this is due to the fact that
we only instantiate T<2,3> in the second call in main(), since the cast
to (T<2,3>*)0 does not require instantiation of the template. Now, how that
can affect the result I don't know -- presumably it has something to do with
injecting the friend functions into the global namespace. This explains
why reverting the calls in main() changes the result.
What evades me, however, is why injecting the names should make any
difference? Note that if I remove the friend declarations altogether,
then we get two calls to the <a,3> template, irrespective of the call
order in main(). I tend to think that this is what we should get in all
cases, but would like to have a second opinion...
W.
--
What |Removed |Added
----------------------------------------------------------------------------
Summary|Function overloading doesn't|Function templates,
|happen when I use friend |overloads, and friend name
|function templates in class |injection
|templates. |
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=15629
^ permalink raw reply [flat|nested] 4+ messages in thread
* [Bug c++/15629] Function templates, overloads, and friend name injection
2004-05-25 3:05 [Bug c++/15629] New: Function overloading doesn't happen when I use friend function templates in class templates ywhu at nmi dot iii dot org dot tw
2004-05-25 12:50 ` [Bug c++/15629] Function templates, overloads, and friend name injection bangerth at dealii dot org
@ 2004-05-26 17:13 ` pinskia at gcc dot gnu dot org
2004-05-26 18:43 ` [Bug c++/15629] [3.3/3.4/3.5 Regressions] " giovannibajo at libero dot it
2 siblings, 0 replies; 4+ messages in thread
From: pinskia at gcc dot gnu dot org @ 2004-05-26 17:13 UTC (permalink / raw)
To: gcc-bugs
--
What |Removed |Added
----------------------------------------------------------------------------
Severity|critical |normal
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=15629
^ permalink raw reply [flat|nested] 4+ messages in thread
* [Bug c++/15629] [3.3/3.4/3.5 Regressions] Function templates, overloads, and friend name injection
2004-05-25 3:05 [Bug c++/15629] New: Function overloading doesn't happen when I use friend function templates in class templates ywhu at nmi dot iii dot org dot tw
2004-05-25 12:50 ` [Bug c++/15629] Function templates, overloads, and friend name injection bangerth at dealii dot org
2004-05-26 17:13 ` pinskia at gcc dot gnu dot org
@ 2004-05-26 18:43 ` giovannibajo at libero dot it
2 siblings, 0 replies; 4+ messages in thread
From: giovannibajo at libero dot it @ 2004-05-26 18:43 UTC (permalink / raw)
To: gcc-bugs
------- Additional Comments From giovannibajo at libero dot it 2004-05-26 11:59 -------
Confirmed as a regression. The reduced code in comment #1 by Wolfgang emits the
following with GCC 2.95 (and EDG):
void func<2>(T<2,3> *)
void func<2>(T<2,3> *)
which is the correct behaviour. 3.0 - 3.2 even rejects this code, while from
3.3 we have the wrong-code problem (the wrong specialization is chosen).
--
What |Removed |Added
----------------------------------------------------------------------------
Severity|normal |critical
Status|UNCONFIRMED |NEW
Ever Confirmed| |1
Keywords| |wrong-code
Known to fail| |3.0.4 3.2.3 3.3.3 3.4.0
| |3.5.0
Known to work| |2.95.3
Last reconfirmed|0000-00-00 00:00:00 |2004-05-26 11:59:41
date| |
Summary|Function templates, |[3.3/3.4/3.5 Regressions]
|overloads, and friend name |Function templates,
|injection |overloads, and friend name
| |injection
Target Milestone|--- |3.4.1
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=15629
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2004-05-26 11:59 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2004-05-25 3:05 [Bug c++/15629] New: Function overloading doesn't happen when I use friend function templates in class templates ywhu at nmi dot iii dot org dot tw
2004-05-25 12:50 ` [Bug c++/15629] Function templates, overloads, and friend name injection bangerth at dealii dot org
2004-05-26 17:13 ` pinskia at gcc dot gnu dot org
2004-05-26 18:43 ` [Bug c++/15629] [3.3/3.4/3.5 Regressions] " giovannibajo at libero dot it
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).