请教大神关于类模板和重载运算符的问题

lijialijialijia

我首先重载了一个加号运算符 程序运行起来没问题 但是按同样的方法重载一个输出运算符就报错 这是为什么？？

1. #include<iostream>
   
2. #include<string>
   
3. 
   
4. //  在类定义的前面声明模板函数
   
5. template<class  T>
   
6. void  Show_A( T & a);
   
7. 
   
8. template<class T>
   
9. T  operator+( T &a1 , T &a2);
   
10. 
    
11. template<class T>                                                                             //声明这条语句后 就报错
    
12. std::ostream & operator<<(std::ostream & os , const T & a1);
    
13. 
    
14. 
    
15. template<class  T>
    
16. class  A
    
17. {
    
18. private:
    
19.     T  my_x;
    
20.     T  my_y;
    
21. public:
    
22. 
    
23.     A(T x=0 , T y=0)    :   my_x(x) , my_y(y)       {  std::cout<<"**********构造函数**********\n"; }
    
24.     ~A()                                            {  std::cout<<"**********析构函数**********\n"; }
    
25. 
    
26.     A(const A & a);                                  //  复制构造
    
27.     A & operator=(const A & a);                      //  重载赋值运算符
    
28. 
    
29. //  在类里面再次声明友元函数  其参数是类模板类型
    
30.     friend void Show_A< A<T> >( A<T> & a );
    
31. 
    
32.     friend  A<T>  operator+< A<T> >( A<T> & a1 , A<T> & a2);
    
33. 
    
34.     friend  std::ostream & operator<<< A<T> >(std::ostream & os , A<T> &a1);
    
35. 
    
36. 
    
37. 
    
38. 
    
39. };
    
40. 
    
41. 
    
42. int main()
    
43. {
    
44.     A<double>  a1(11.5 , 15.5);
    
45. 
    
46.     Show_A(a1);
    
47. 
    
48. 
    
49. 
    
50. 
    
51. 
    
52.     return 0;
    
53. }
    
54. 
    
55. template<class T>
    
56. std::ostream & operator<<(std::ostream & os , T a1)
    
57. {
    
58.     os<<"( "<<a1.my_x<<" , "<<a1.my_y<<"! )\n";
    
59. 
    
60.     return os;
    
61. }
    
62. 
    
63. template<class T>
    
64. T  operator+( T &a1 , T &a2)
    
65. {
    
66.     T temp;
    
67. 
    
68.     temp.my_x = a1.my_x+a2.my_x;
    
69.     temp.my_y = a1.my_y+a2.my_y;
    
70. 
    
71.     return temp;
    
72. }
    
73. 
    
74. //  定义函数模板
    
75. template<class  T>
    
76. void Show_A(T & a)
    
77. {
    
78.     std::cout<<"( "<<a.my_x<<" , "<<a.my_y<<"! )\n";
    
79. 
    
80. }
    
81. 
    
82. 
    
83. template<class T>
    
84. A<T> & A<T>::operator=(const A & a)
    
85. {
    
86.     my_x = a.my_x;
    
87.     my_y = a.my_y;
    
88. 
    
89.     std::cout<<"**********重载赋值运算符**********\n";
    
90.     return *this;
    
91. }
    
92. 
    
93. template<class T>
    
94. A<T>::A(const A & a)              //  复制构造
    
95. {
    
96.     my_x = a.my_x;
    
97.     my_y = a.my_y;
    
98. 
    
99.     std::cout<<"**********复制构造函数**********\n";
    
100. }
     

复制代码

请大神帮忙看看

Croper

首先，“<<”和“>>”本质上是位运算符,
其之所以能作为流输出输入运算符，是因为在istream和ostream中对其已经进行了重载：

1. template<class _Elem,
   
2.         class _Traits> inline
   
3.         basic_istream<_Elem, _Traits>& operator>>(
   
4.                 basic_istream<_Elem, _Traits>& _Istr, _Elem *_Str)
   
5.         {        // extract NTBS
   
6.         typedef basic_istream<_Elem, _Traits> _Myis;
   
7.         typedef ctype<_Elem> _Ctype;
   
8.         ios_base::iostate _State = ios_base::goodbit;
   
9.         _Elem *_Str0 = _Str;
   
10.         const typename _Myis::sentry _Ok(_Istr);
    
11. 
    
12.         if (_Ok)
    
13.                 {        // state okay, extract characters
    
14.                 const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Istr.getloc());
    
15. 
    
16.                 _TRY_IO_BEGIN
    
17.                 streamsize _Count = 0 < _Istr.width() ? _Istr.width()
    
18.                         : (numeric_limits<streamsize>::max)();
    
19.                 typename _Myis::int_type _Meta = _Istr.rdbuf()->sgetc();
    
20.                 _Elem _Ch;
    
21.                 for (; 0 < --_Count; _Meta = _Istr.rdbuf()->snextc())
    
22.                         if (_Traits::eq_int_type(_Traits::eof(), _Meta))
    
23.                                 {        // end of file, quit
    
24.                                 _State |= ios_base::eofbit;
    
25.                                 break;
    
26.                                 }
    
27.                         else if (_Ctype_fac.is(_Ctype::space,
    
28.                                 _Ch = _Traits::to_char_type(_Meta))
    
29.                                         || _Ch == _Elem())
    
30.                                 break;        // whitespace or nul, quit
    
31.                         else
    
32.                                 *_Str++ = _Traits::to_char_type(_Meta);        // add it to string
    
33.                 _CATCH_IO_(_Istr)
    
34.                 }
    
35. 
    
36.         *_Str = _Elem();        // add terminating null character
    
37.         _Istr.width(0);
    
38.         _Istr.setstate(_Str == _Str0 ? _State | ios_base::failbit : _State);
    
39.         return (_Istr);
    
40.         }
    

复制代码

1. template<class _Traits> inline
   
2.         basic_ostream<char, _Traits>& operator<<(
   
3.                 basic_ostream<char, _Traits>& _Ostr,
   
4.                 const char *_Val)
   
5.         {        // insert NTBS into char stream
   
6.         typedef char _Elem;
   
7.         typedef basic_ostream<_Elem, _Traits> _Myos;
   
8.         ios_base::iostate _State = ios_base::goodbit;
   
9.         streamsize _Count = (streamsize)_Traits::length(_Val);        // may overflow
   
10.         streamsize _Pad = _Ostr.width() <= 0 || _Ostr.width() <= _Count
    
11.                 ? 0 : _Ostr.width() - _Count;
    
12.         const typename _Myos::sentry _Ok(_Ostr);
    
13. 
    
14.         if (!_Ok)
    
15.                 _State |= ios_base::badbit;
    
16.         else
    
17.                 {        // state okay, insert
    
18.                 _TRY_IO_BEGIN
    
19.                 if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
    
20.                         for (; 0 < _Pad; --_Pad)        // pad on left
    
21.                                 if (_Traits::eq_int_type(_Traits::eof(),
    
22.                                         _Ostr.rdbuf()->sputc(_Ostr.fill())))
    
23.                                         {        // insertion failed, quit
    
24.                                         _State |= ios_base::badbit;
    
25.                                         break;
    
26.                                         }
    
27. 
    
28.                 if (_State == ios_base::goodbit
    
29.                         && _Ostr.rdbuf()->sputn(_Val, _Count) != _Count)
    
30.                         _State |= ios_base::badbit;
    
31. 
    
32.                 if (_State == ios_base::goodbit)
    
33.                         for (; 0 < _Pad; --_Pad)        // pad on right
    
34.                                 if (_Traits::eq_int_type(_Traits::eof(),
    
35.                                         _Ostr.rdbuf()->sputc(_Ostr.fill())))
    
36.                                         {        // insertion failed, quit
    
37.                                         _State |= ios_base::badbit;
    
38.                                         break;
    
39.                                         }
    
40.                 _Ostr.width(0);
    
41.                 _CATCH_IO_(_Ostr)
    
42.                 }
    
43. 
    
44.         _Ostr.setstate(_State);
    
45.         return (_Ostr);
    
46.         }

复制代码

而你用不同的方式再次重载了这个符号，对于同一个运算，编译器能够找到不止一个能匹配的重载函数，就会出现定义不明确的错误