如何定义operator[][]??

converse

prc的代码是有问题的

liubinbj

原帖由 converse 于 2006-7-20 12:34 发表
prc的代码是有问题的

没检查他的代码，倒找到另外一个

1. 
   
2. #include <string.h>
   
3. 
   
4. //
   
5. // Definition and Declaration of Container2DRow class
   
6. // if you do not like templates for any reason you can
   
7. // create two version of this class double and int that
   
8. // should be enough for 99% of applications   
   
9. 
   
10. template <class T>
    
11. class Container2DRow
    
12. {
    
13. public:
    
14.     T& operator [] (int j);
    
15.     const T& operator [] (int j) const;
    
16.     T **m_ppMatrix;
    
17.     int i; //ROW (Y coord)
    
18.     int m_nXSize;
    
19. };
    
20. ///Class container
    
21. 
    
22. template<class T>
    
23. const T& Container2DRow<T>::operator [] (int j) const
    
24. {
    
25. //   ASSERT(j>=0 && j<m_nXSize);
    
26.     return m_ppMatrix[i][j];
    
27. }
    
28. 
    
29. template<class T>
    
30. T& Container2DRow<T>::operator [] (int j)
    
31. {
    
32. //   ASSERT(j>=0 && j<m_nXSize);
    
33.     return m_ppMatrix[i][j];
    
34. }
    
35. //
    
36. // Defenition of CMatrix class
    
37. //
    
38. template <class T>
    
39. class CMatrix  
    
40. {
    
41. public:
    
42.     //Helper class for [][] indexing, it is not neccesarily
    
43.     // to agragated by CMatrix it could be just a friend
    
44.     Container2DRow<T> row;
    
45. 
    
46. private:
    
47.     int m_nXSize;
    
48.     int m_nYSize;
    
49.     int m_nMemorySize;
    
50.     T **m_ppMatrix;
    
51. 
    
52.     bool m_bCreated;
    
53. public:
    
54.     //Constructor & Copy Constructor
    
55.     CMatrix(int nYSize, int nXSize);
    
56.     CMatrix(const CMatrix& matrix);
    
57. 
    
58.     //operator = returns reference in order to enable
    
59.     //expressions like this a=b=c=d;  
    
60.     //a=b       a.operator=(b)
    
61.     //a=b+c     a.operator=(b.operator+(c));
    
62.     //a=b-c     a.operator=(b.operator-(c));
    
63.     CMatrix& operator= (const CMatrix& matrix);
    
64.     CMatrix  operator+ (const T& item);
    
65.     CMatrix  operator- (const T& item);
    
66. 
    
67.     //Indexing //Y(row) X(col)
    
68.     T& operator()(int i, int j);   // i - row
    
69.     //operator  [] returns object of type  Container2DRow
    
70.     //with have operator [] overloaded and know how to access
    
71.     //matrix data
    
72.     Container2DRow<T> operator [] (int i);
    
73.     const    Container2DRow<T> operator [] (int i) const;
    
74. 
    
75.     //Helper functions, you can expand this section to do
    
76.     //LU decomposition, determinant evaluation and so on,  
    
77.     T SumAll();
    
78.     //Get Size
    
79.     int GetXSize();
    
80.     int GetYSize();
    
81.     T GetMinValue();
    
82.     T GetMaxValue();
    
83.     virtual ~CMatrix();
    
84. };
    
85. template<class T>
    
86. CMatrix<T>::CMatrix(int nYSize, int nXSize)
    
87. {
    
88.     m_bCreated = false;
    
89. //   ASSERT(nXSize>0 && nYSize>0);
    
90. 
    
91. 
    
92.     m_nXSize = nXSize;
    
93.     m_nYSize = nYSize;
    
94.     m_nMemorySize = m_nYSize*m_nXSize*sizeof(T);
    
95. 
    
96.     m_ppMatrix    = new T* [m_nYSize];
    
97.     m_ppMatrix[0] = new T  [m_nYSize*m_nXSize];
    
98. 
    
99.     for (int i=1; i<m_nYSize; i++)
    
100.         m_ppMatrix[i] = m_ppMatrix[0]+i*m_nXSize;
     
101. 
     
102.     memset(m_ppMatrix[0], 0, m_nMemorySize);
     
103.     m_bCreated = true;
     
104.     row.m_ppMatrix = m_ppMatrix;
     
105.     row.m_nXSize   = m_nXSize;
     
106. }
     
107. 
     
108. template<class T>
     
109. CMatrix<T>::CMatrix(const CMatrix& matrix)
     
110. {
     
111.     m_nXSize = matrix.m_nXSize;
     
112.     m_nYSize = matrix.m_nYSize;
     
113.     m_nMemorySize = m_nYSize*m_nXSize*sizeof(T);
     
114. 
     
115.     m_ppMatrix    = new T* [m_nYSize];
     
116.   //  ASSERT(m_ppMatrix!=NULL);
     
117. 
     
118.     m_ppMatrix[0] = new T  [m_nYSize*m_nXSize];
     
119.   //  ASSERT(m_ppMatrix[0]!=NULL);
     
120. 
     
121.     for (int i=1; i<m_nYSize; i++)
     
122.         m_ppMatrix[i] = m_ppMatrix[0]+i*m_nXSize;
     
123. 
     
124.     memcpy(m_ppMatrix[0],matrix.m_ppMatrix[0], m_nMemorySize);
     
125. 
     
126.     m_bCreated = true;
     
127. }
     
128. 
     
129. 
     
130. template<class T>
     
131. CMatrix<T>& CMatrix<T>::operator= (const CMatrix& matrix)
     
132. {
     
133.     if (this == &matrix) return *this;
     
134. 
     
135.   //  ASSERT(m_nXSize == matrix.m_nXSize &&
     
136.    //     m_nYSize == matrix.m_nYSize);
     
137.     memcpy(m_ppMatrix[0],matrix.m_ppMatrix[0], m_nMemorySize);
     
138. 
     
139.     return *this;
     
140. }
     
141. template<class T>
     
142. T CMatrix<T>::GetMinValue()
     
143. {
     
144.     T minValue = m_ppMatrix[0][0];
     
145.     int i,j;
     
146. 
     
147.     for (i=0; i<m_nYSize; i++)
     
148.         for (j=0; j<m_nXSize; j++)
     
149.         {
     
150.             if(m_ppMatrix[i][j]<minValue)
     
151.                 minValue = m_ppMatrix[i][j];
     
152.         }
     
153.         return minValue;
     
154. }
     
155. 
     
156. template<class T>
     
157. T CMatrix<T>::GetMaxValue()
     
158. {
     
159.     T maxValue = m_ppMatrix[0][0];
     
160.     int i,j;
     
161. 
     
162.     for (i=0; i<m_nYSize; i++)
     
163.         for (j=0; j<m_nXSize; j++)
     
164.         {
     
165.             if(m_ppMatrix[i][j]>maxValue)
     
166.                 maxValue = m_ppMatrix[i][j];
     
167.         }
     
168.         return maxValue;
     
169. }
     
170. 
     
171. template<class T>
     
172. CMatrix<T> CMatrix<T>::operator+ (const T& item)
     
173. {
     
174.     int i, j;
     
175. 
     
176.     CMatrix<T> mtrx(m_nYSize, m_nXSize);
     
177.     for (i=0; i<m_nYSize; i++)
     
178.         for (j=0; j<m_nXSize; j++)
     
179.         {
     
180.             mtrx.m_ppMatrix[i][j] = m_ppMatrix[i][j]+item ;
     
181.         }
     
182.         return mtrx;
     
183. }
     
184. 
     
185. template<class T>
     
186. CMatrix<T> CMatrix<T>::operator- (const T& item)
     
187. {
     
188.     int i, j;
     
189. 
     
190.     CMatrix<T> mtrx(m_nYSize, m_nXSize);
     
191.     for (i=0; i<m_nYSize; i++)
     
192.         for (j=0; j<m_nXSize; j++)
     
193.         {
     
194.             mtrx.m_ppMatrix[i][j] = m_ppMatrix[i][j]-item ;
     
195.         }
     
196.         return mtrx;
     
197. }
     
198. 
     
199. template<class T>
     
200. CMatrix<T>::~CMatrix()
     
201. {
     
202.     if (m_bCreated)
     
203.     {
     
204.         delete [] m_ppMatrix[0];
     
205.         delete [] m_ppMatrix;
     
206.     }
     
207. }
     
208. 
     
209. template<class T>
     
210. int CMatrix<T>::GetXSize()
     
211. {
     
212.     return m_nXSize;
     
213. }
     
214. 
     
215. template<class T>
     
216. T CMatrix<T>::SumAll()
     
217. {
     
218.     T sum = 0;
     
219.     int i, j;
     
220. 
     
221.     for (i=0; i<m_nYSize; i++)
     
222.         for (j=0; j<m_nXSize; j++)
     
223.         {
     
224.             sum += m_ppMatrix[i][j];
     
225.         }
     
226.         return sum;
     
227. }
     
228. 
     
229. template<class T>
     
230. int CMatrix<T>::GetYSize()
     
231. {
     
232.     return m_nYSize;
     
233. }
     
234. template<class T>        //Y(row) X(col)      
     
235. T& CMatrix<T>::operator()(int i, int j)
     
236. {
     
237. //   ASSERT(i>=0 && i<m_nYSize &&
     
238.   //      j>=0 && j<m_nXSize);
     
239. 
     
240.     return m_ppMatrix[i][j];
     
241. }
     
242. 
     
243. //Fancy Indexing
     
244. template<class T>
     
245. Container2DRow<T> CMatrix<T>::operator [] (int i)
     
246. {
     
247.   //  ASSERT(i>=0 && i<m_nYSize);
     
248.     row.i = i;
     
249.     return row;
     
250. }
     
251. 
     
252. template<class T>
     
253. const Container2DRow<T> CMatrix<T>::operator [] (int i) const
     
254. {
     
255.   //  ASSERT(i>=0 && i<m_nYSize);
     
256.     row.i = i;
     
257.     return row;
     
258. }
     
259. 
     
260. #include <stdio.h>
     
261. #include <stdlib.h>
     
262. main()
     
263. {
     
264.         CMatrix<int> a(20,20);
     
265.         a[10][10]=1;
     
266.         printf("%d\n",a[10][10]);
     
267. }
     
268. 
     

复制代码