类

我使用这个摸板类的程序

1. 180. #include <iostream>
   181. #include <utility>
   182. using namespace std;
   184. int main(){ 
   185.    pair<int,int> a;
   186.    a=make_pair(3,5);
   187.    pair<int,int> b(3,8);
   188.    pair<int,int> c(b);
   189.    cout<<a.first<<"   "<<a.second<<endl;
   190.    cout<<b.first<<"   "<<b.second<<endl;
   191.    cout<<c.first<<"   "<<c.second<<endl;
   192.    cout<<(a==b)<<endl;
   193.    cout<<(a!=b)<<endl;
   194.    cout<<(a<b)<<endl;
   195.    return 0;
   196.    
   197. } 
4. //utility standard header
5. #ifndef _UTILITY_
6. #define _UTILITY_
7. #include <iosfwd>
8. namespace std {
9.     //TEMPLATE STRUCT pair
10.     template<class T1, class T2> 
11.     struct pair  //其实与类是一样的,只不过默认访问权限是public
12.     {
13.         typedef T1 first_type;
14.         typedef T2 second_type;
15.         
16.         pair():first(T1()),second(T2())//默认构造函数
17.             {
18.             }
19.         
20.         pair(const T1& V1,const T2 &V2)
21.         : first(V1),second(V2)
22.             {
23.             }
24.             
25.             template< class U1, class U2>//拷贝构造函数
26.         pair(const pair<U1, U2> & x)
27.         :first(X.first) ,second(X.second)
28.             {
29.             }
30.             T1 first;
31.             T2 second;
32.     };
33.     
34.     //  pair TEMPLATE OPERATORS
35.     //注意operator==,operator<是实现其他的关键
36.     template<class T1, class T2>
37.     inline bool operator==(const pair<T1,T2>& X,
38.                                                  const pair<T1,T2>& Y)
39.     {
40.         return (X.first==Y.first && X.second ==Y.second);
41.     }
42.     
43.     temlate<class T1, class T2>
44.     inline bool operator!=(const pair<T1,T2>& X,
45.                                                  const pair<T1,T2>& Y)
46.     {
47.         return (!(X==Y));
48.     }
49.     
50.     temlate<class T1, class T2>
51.     inline bool operator<(const pair<T1,T2>& X,
52.                                                  const pair<T1,T2>& Y)
53.     {
54.         return  ( X.first <Y.first ||
55.                  (!(Y.first<X.first) && X.second<Y.second ));
56.     }
57.     
58.     temlate<class T1, class T2>
59.     inline bool operator>(const pair<T1,T2>& X,
60.                                                  const pair<T1,T2>& Y)
61.     {
62.         return  (Y<X);
63.     }
64.     
65.     temlate<class T1, class T2>
66.     inline bool operator<=(const pair<T1,T2>& X,
67.                                                  const pair<T1,T2>& Y)
68.     {
69.         return  (!(Y<X));
70.     }
71.     
72.     temlate<class T1, class T2>
73.     inline bool operator>=(const pair<T1,T2>& X,
74.                                                  const pair<T1,T2>& Y)
75.     {
76.         return  (!( X<Y));
77.     }
78.     
79.     template<class T1, class T2>  
80.     //注意 const修饰符不起作用
81.     inline pair<T1, T2> make_pair(const T1& X,const T2& Y)
82.     {
83.         return ( pair<T1, T2> (X, Y) );
84.     }
85.            //TEMPLATE OPERATORS
86.       namespace rel_ops
87.       {
88.         template<class T>
89.         inline bool operator!=(const T& X, cosnt T& Y)
90.         {
91.             return (!(X==Y) );
92.         }
93.         
94.         template<class T>
95.         inline bool operator>(const T& X, cosnt T& Y)
96.         {
97.             return (Y<X);
98.         }
99.         
100.         template<class T>
101.         inline bool operator<=(const T& X, cosnt T& Y)
102.         {
103.             return (!(Y<X) );
104.         }
105.         
106.         template<class T>
107.         inline bool operator>=(const T& X, cosnt T& Y)
108.         {
109.             return (!(X<Y) );
110.         }
111.         
112.     }      
113. }/* namespace std*/
114. #endif /*UTILITY*/

测试这个类的文件

115. //test <utility>
116. #include <assert.h>
117. #include <iostream>
118. #include "utility.h"
119. using namespace std;
121. typedef pair<int, char> Pair_ic;
122. Pair_ic p0;
124. class Int
125. {
126.     public:
127.         Int(int v):val(v)
128.         {
129.         }
130.         
131.         bool operator==(Int x) const
132.         {
133.             return (val==x.val);
134.         }
135.         bool operator<(Int x) const
136.         {
137.             return (val<x.val);
138.         }
139.         
140.         private:
141.             int val;
142. };
144. //TEST <utility>
145. int main()
146. {
147.     Pair_ic p1=p0;
148.     Pair_ic p2(3,'a');
149.     
150.     //TEST pair
151.     assert(p1.first==0);
152.     assert(p1.second==0);
153.     assert(p2.first==3);
154.     assert(p2.second=='a');
155.     assert(p2==make_pair( ( Pair_ic::first_type) 3,
156.                                                 ( Pair_ic::second_type) 'a') );
157.     assert(p2 < make_pair( (Pair_ic::first_type) 4,
158.                              (Pair_ic::second_type) 'b') );
159.   assert(p2 < make_pair( (Pair_ic::first_type) 3,
160.                          (Pair_ic::second_type) 'b') );
161.   assert(p1 != p2);
162.   assert(p2 > p1);
163.   assert(p2 <=p2);
164.   assert(p2>=p2);
165.    //TEST rel_ops
166.    using namespace std::rel_ops;
167.     Int a(2), b(3);
168.     assert(a==a);
169.    //   assert(a<b);
170.     assert(a != b);
171.     assert(b > a);
172.     assert(a <= b);
173.     assert(b >= a);
174.     cout<<"Success testing <utility>"<<endl;
175.     return 0;
176.                                                                                                             
177. }