Bug 15629 - [3.3/3.4/4.0 Regressions] Function templates, overloads, and friend name injection

Attachment

Description

Type

Created

Size

Actions

Create a New Attachment (proposed patch, testcase, etc.)

View All

Bug 15629 depends on:

Show dependency tree
Show dependency graph

Bug 15629 blocks:

Description:

Last confirmed: 2004-05-26 11:59

Opened: 2004-05-24 08:18

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)

------- Comment #1 From Wolfgang Bangerth 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.

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).

GCC Bugzilla Bug 15629

[3.3/3.4/4.0 Regressions] Function templates, overloads, and friend name injection

Last modified: 2004-10-30 21:11:40

Known to work:
Known to fail: