[Bug c++/15629] New: Function overloading doesn't happen when I use friend function templates in class templates.

[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]

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

[Bug c++/15629] Function templates, overloads, and friend name injection

[bangerth at dealii dot org]

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

[Bug c++/15629] Function templates, overloads, and friend name injection

[pinskia at gcc dot gnu dot org]

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
           Severity|critical                    |normal


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=15629

[Bug c++/15629] [3.3/3.4/3.5 Regressions] Function templates, overloads, and friend name injection

[giovannibajo at libero dot it]

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