实用矩阵类（Matrix）(带测试)

  1 #ifndef MATRIX_H
  2 #define MATRIX_H
  3 
  4 #include <iostream>
  5 #include <functional>
  6 #include <algorithm>
  7 
  8 using namespace std;
  9 
 10 template <size_t Rows,size_t Cols,typename ElemType = double>
 11 class Matrix
 12 {
 13 public:
 14     Matrix();        //默认构造函数
 15     template<typename InputIterator>
 16     Matrix(InputIterator begin, InputIterator end);    //用2迭代器构造
 17     ~Matrix();    //析构函数
 18 
 19     ElemType & at(size_t row, size_t col);    //获取某个元素(引用)
 20     const ElemType & at(size_t row, size_t col) const;
 21     
 22     size_t numRows() const;        //获得行数、列数
 23     size_t numCols() const;
 24     size_t size() const;        //返回总元素数
 25 
 26     //多维矩阵
 27     class MutableReference;
 28     class ImmutableReference;
 29     MutableReference operator[] (size_t row);
 30     ImmutableReference operator[] (size_t row) const;
 31 
 32     typedef ElemType* iterator; //将元素类型指针定义为迭代器
 33     typedef const ElemType* const_iterator;
 34 
 35     iterator begin();
 36     iterator end();
 37     const_iterator begin() const;
 38     const_iterator end() const;
 39 
 40     iterator row_begin(size_t row);
 41     iterator row_end(size_t row);
 42     const_iterator row_begin(size_t row) const;
 43     const_iterator row_end(size_t row) const;
 44     
 45     Matrix& operator+= (const Matrix& rhs);
 46     Matrix& operator-= (const Matrix& rhs);
 47     Matrix& operator*= (const ElemType& scalar);
 48     Matrix& operator/= (const ElemType& scalar);
 49 
 50     //打印矩阵
 51     void printMatrix(void) const;
 52 private:
 53     ElemType elems[Rows*Cols];        //矩阵元素的数组
 54 
 55 };
 56 //两矩阵相加
 57 template <size_t M,size_t N,typename T>
 58 const Matrix<M, N, T> operator+ (const Matrix<M, N, T> &lhs, const Matrix<M, N, T> &rhs);
 59 //两矩阵相减
 60 template <size_t M, size_t N, typename T>
 61 const Matrix<M, N, T> operator- (const Matrix<M, N, T> &lhs, const Matrix<M, N, T> &rhs);
 62 //矩阵数乘(右乘)
 63 template <size_t M, size_t N, typename T>
 64 const Matrix<M, N, T> operator* (const Matrix<M, N, T> &lhs, const T& scalar);
 65 //矩阵数乘(左乘)
 66 template <size_t M, size_t N, typename T>
 67 const Matrix<M, N, T> operator* (const T& scalar, const Matrix<M, N, T> &rhs);
 68 //矩阵除以一个数
 69 template <size_t M, size_t N, typename T>
 70 const Matrix<M, N, T> operator/ (const Matrix<M, N, T>& lhs,const T& scalar);
 71 //一元运算的加减  相当于添加符号
 72 template <size_t M, size_t N, typename T>
 73 const Matrix<M, N, T> operator+ (const Matrix<M, N, T>& operand);
 74 template <size_t M, size_t N, typename T>
 75 const Matrix<M, N, T> operator- (const Matrix<M, N, T>& operand);
 76 //2矩阵相乘
 77 template <size_t M, size_t N, size_t P, typename T>
 78 const Matrix<M, P, T> operator*(const Matrix<M, N, T>& lhs,const Matrix<N, P, T>& rhs);
 79 //矩阵的比较操作
 80 template <size_t M, size_t N, typename T>
 81 bool operator== (const Matrix<M, N, T>& lhs,const Matrix<M, N, T>& rhs);
 82 
 83 template <size_t M, size_t N, typename T>
 84 bool operator!= (const Matrix<M, N, T>& lhs,const Matrix<M, N, T>& rhs);
 85 
 86 template <size_t M, size_t N, typename T>
 87 bool operator<  (const Matrix<M, N, T>& lhs,const Matrix<M, N, T>& rhs);
 88 
 89 template <size_t M, size_t N, typename T>
 90 bool operator<= (const Matrix<M, N, T>& lhs,const Matrix<M, N, T>& rhs);
 91 
 92 template <size_t M, size_t N, typename T>
 93 bool operator>= (const Matrix<M, N, T>& lhs,const Matrix<M, N, T>& rhs);
 94 
 95 template <size_t M, size_t N, typename T>
 96 bool operator>  (const Matrix<M, N, T>& lhs,const Matrix<M, N, T>& rhs);
 97 //是否为单位矩阵
 98 template <size_t M, typename T>
 99 Matrix<M, M, T> Identity();
100 //矩阵转置
101 template <size_t M, size_t N, typename T>
102 const Matrix<N, M, T> Transpose(const Matrix<M, N, T>& m);
103 
104 
105 //////////////////////////////////////////////////////////////////////////
106 /************************************************************************/
107 /*
108     函数的实现部分
109 */
110 /************************************************************************/
111 //默认构造函数
112 template <size_t M, size_t N, typename T>
113 Matrix<M, N, T>::Matrix() 
114 {
115 }
116 //迭代器构造函数
117 template <size_t M, size_t N, typename T>
118 template <typename InputIterator>
119 Matrix<M, N, T>::Matrix(InputIterator rangeBegin, InputIterator rangeEnd) 
120 {
121     std::copy(rangeBegin, rangeEnd, begin());
122 }
123 //析构函数
124 template <size_t M, size_t N, typename T>
125 Matrix<M, N, T>::~Matrix()
126 {
127 }
128 //得到row，col处元素(引用) 常量版本
129 template <size_t M, size_t N, typename T>
130 const T& Matrix<M, N, T>::at(size_t row, size_t col) const 
131 {
132     return *(begin() + row * numCols() + col);
133 }
134 //得到row，col处元素(引用) 非常量版本
135 template <size_t M, size_t N, typename T>
136 T& Matrix<M, N, T>::at(size_t row, size_t col) 
137 {
138     return const_cast<T&>(static_cast<const Matrix<M, N, T>*>(this)->at(row, col));
139 }
140 //得到行数
141 template<size_t M,size_t N,typename T>
142 size_t Matrix<M, N, T>::numRows() const
143 {
144     return M;
145 }
146 template<size_t M,size_t N,typename T>
147 size_t Matrix<M, N, T>::numCols() const
148 {
149     return N;
150 }
151 
152 template<size_t M,size_t N,typename T>
153 size_t Matrix<M,N,T>::size() const
154 {
155     return M*N;
156 }
157 //迭代器返回首地址指针 //注意返回是迭代器类型
158 template<size_t M,size_t N,typename T>
159 typename Matrix<M, N, T>::iterator Matrix<M,N,T>::begin()
160 {
161     return elems;
162 }
163 //迭代器返回首地址指针的常量版本
164 template<size_t M, size_t N, typename T>
165 typename Matrix<M, N, T>::const_iterator Matrix<M, N, T>::begin() const
166 {
167     return elems;
168 }
169 //尾迭代器获取
170 template<size_t M, size_t N, typename T>
171 typename Matrix<M, N, T>::iterator Matrix<M, N, T>::end()
172 {
173     return begin()+size();
174 }
175 //尾迭代器获取（常量版本）
176 template<size_t M, size_t N, typename T>
177 typename Matrix<M, N, T>::const_iterator Matrix<M, N, T>::end() const
178 {
179     return begin() + size();
180 }
181 //行迭代器(跳过指定元素获取)
182 template<size_t M,size_t N,typename T>
183 typename Matrix<M, N, T>::iterator Matrix<M, N, T>::row_begin(size_t row)
184 {
185     return begin() + row*numCols();
186 }
187 //行迭代器(跳过指定元素获取) 常量版本
188 template <size_t M, size_t N, typename T>
189 typename Matrix<M, N, T>::const_iterator Matrix<M, N, T>::row_begin(size_t row) const
190 {
191     return begin() + row*numCols();
192 }
193 //获得行尾迭代器
194 template<size_t M,size_t N,typename T>
195 typename Matrix<M, N, T>::iterator Matrix<M, N, T>::row_end(size_t row)
196 {
197     return row_begin(row) + N;
198 }
199 //获得行尾迭代器 const版本
200 template<size_t M, size_t N, typename T>
201 typename Matrix<M, N, T>::const_iterator Matrix<M, N, T>::row_end(size_t row) const
202 {
203     return row_begin(row) + N;
204 }
205 /************************************************************************/
206 /*
207     方括号[]操作返回引用的实现（非const版本）
208 */
209 /************************************************************************/
210 template <size_t M,size_t N,typename T>
211 class Matrix<M, N, T>::MutableReference
212 {
213 public:
214     T& operator[] (size_t col)
215     {
216         return parent->at(row, col);
217     }
218 private:
219     //私有构造函数  是获得此类实例的为例方法(有元类Matrix可以访问)
220     MutableReference(Matrix* owner, size_t row) :parent(owner), row(row)
221     {
222 
223     }
224     friend class Matrix;
225     const size_t row;
226     Matrix *const parent;
227 };
228 /************************************************************************/
229 /*
230 方括号[]操作返回引用的实现（const版本）
231 */
232 /************************************************************************/
233 template <size_t M, size_t N, typename T>
234 class Matrix<M, N, T>::ImmutableReference
235 {
236 public:
237     const T& operator[] (size_t col) const
238     {
239         return parent->at(row, col);
240     }
241 private:
242     //私有构造函数  是获得此类实例的为例方法(有元类Matrix可以访问)
243     ImmutableReference(const Matrix* owner, size_t row) :parent(owner), row(row)
244     {
245 
246     }
247     friend class Matrix;
248     const size_t row;
249     const Matrix *const parent;
250 };
251 //方括号返回引用的真真实现(用了上面的类)
252 template<size_t M,size_t N,typename T>
253 typename Matrix<M, N, T>::MutableReference Matrix<M, N, T>::operator [] (size_t row)
254 {
255     return MutableReference(this, row);
256 }
257 template<size_t M, size_t N, typename T>
258 typename Matrix<M, N, T>::ImmutableReference Matrix<M, N, T>::operator [] (size_t row) const
259 {
260     return ImmutableReference(this, row);
261 }
262 /************************************************************************/
263 /*
264     复合运算符实现
265 */
266 /************************************************************************/
267 template <size_t M, size_t N, typename T>
268 Matrix<M, N, T>& Matrix<M, N, T>::operator+= (const Matrix<M, N, T>& rhs) 
269 {
270     std::transform(begin(), end(),  // First input range is lhs
271         rhs.begin(),     // Start of second input range is rhs
272         begin(),         // Overwrite lhs
273         std::plus<T>()); // Using addition
274     return *this;
275 }
276 
277 template <size_t M, size_t N, typename T>
278 Matrix<M, N, T>& Matrix<M, N, T>::operator-= (const Matrix<M, N, T>& rhs)
279 {
280     std::transform(begin(), end(),   // First input range is lhs
281         rhs.begin(),      // Start of second input range is rhs
282         begin(),          // Overwrite lhs
283         std::minus<T>()); // Using subtraction
284     return *this;
285 }
286 template <size_t M, size_t N, typename T>
287 Matrix<M, N, T>& Matrix<M, N, T>::operator*= (const T& scalar) 
288 {
289     std::transform(begin(), end(), // Input range is lhs
290         begin(),        // Output overwrites lhs
291         std::bind2nd(std::multiplies<T>(), scalar)); // Scalar mult.
292     return *this;
293 }
294 template <size_t M, size_t N, typename T>
295 Matrix<M, N, T>& Matrix<M, N, T>::operator/= (const T& scalar) 
296 {
297     std::transform(begin(), end(), // Input range is lhs
298         begin(),        // Output overwrites lhs
299         std::bind2nd(std::divides<T>(), scalar)); // Divide by scalar
300     return *this;
301 }
302 /************************************************************************/
303 /*
304     双目运算符实现
305 */
306 /************************************************************************/
307 template <size_t M, size_t N, typename T>
308 const Matrix<M, N, T> operator+ (const Matrix<M, N, T>& lhs,const Matrix<M, N, T>& rhs) 
309 {
310     return Matrix<M, N, T>(lhs) += rhs;        //用到了复合运算符(成员函数)
311 }
312 template <size_t M, size_t N, typename T>
313 const Matrix<M, N, T> operator- (const Matrix<M, N, T>& lhs,const Matrix<M, N, T>& rhs) 
314 {
315     return Matrix<M, N, T>(lhs) -= rhs;
316 }
317 template <size_t M, size_t N, typename T>  //（右乘一个数）
318 const Matrix<M, N, T> operator* (const Matrix<M, N, T>& lhs,const T& scalar) 
319 {
320     return Matrix<M, N, T>(lhs) *= scalar;
321 }
322 template <size_t M, size_t N, typename T> //左乘一个数
323 const Matrix<M, N, T> operator* (const T& scalar,const Matrix<M, N, T>& rhs) 
324 {
325     return Matrix<M, N, T>(rhs) *= scalar;    
326 }
327 template <size_t M, size_t N, typename T>
328 const Matrix<M, N, T> operator/ (const Matrix<M, N, T>& lhs,const T& scalar) 
329 {
330     return Matrix<M, N, T>(lhs) /= scalar;
331 }
332 //一元运算符+
333 template <size_t M, size_t N, typename T>
334 const Matrix<M, N, T> operator+ (const Matrix<M, N, T>& operand) {
335     return operand;
336 }
337 //一元运算符-
338 template <size_t M, size_t N, typename T>
339 const Matrix<M, N, T> operator- (const Matrix<M, N, T>& operand) 
340 {
341     return Matrix<M, N, T>(operand) *= T(-1);
342 }
343 //2矩阵相乘
344 template <size_t M, size_t N, size_t P, typename T>
345 const Matrix<M, P, T> operator*(const Matrix<M, N, T>& one,const Matrix<N, P, T>& two) 
346 {
347     /* Create a result matrix of the right size and initialize it to zero. */
348     Matrix<M, P, T> result;
349     std::fill(result.begin(), result.end(), T(0));    //初始化结果变量
350 
351     /* Now go fill it in. */
352     for (size_t row = 0; row < result.numRows(); ++row)
353         for (size_t col = 0; col < result.numCols(); ++col)
354             for (size_t i = 0; i < N; ++i)
355                 result[row][col] += one[row][i] * two[i][col];
356 
357     return result;
358 }
359 //matrix1*=matrix运算实现
360 template <size_t M, typename T>
361 Matrix<M, M, T>& operator*= (Matrix<M, M, T>& lhs,const Matrix<M, M, T>& rhs) 
362 {
363     return lhs = lhs * rhs; // Nothing fancy here.
364 }
365 //比较运算符实现
366 template <size_t M, size_t N, typename T>
367 bool operator== (const Matrix<M, N, T>& lhs,const Matrix<M, N, T>& rhs) 
368 {
369     return std::equal(lhs.begin(), lhs.end(), rhs.begin());
370 }
371 template <size_t M, size_t N, typename T>
372 bool operator!= (const Matrix<M, N, T>& lhs,const Matrix<M, N, T>& rhs) 
373 {
374     return !(lhs == rhs); //用了==运算符
375 }
376 /* The less-than operator uses the std::mismatch algorithm to chase down
377 * the first element that differs in the two matrices, then returns whether
378 * the lhs element is less than the rhs element.  This is essentially a
379 * lexicographical comparison optimized on the assumption that the two
380 * sequences have the same size.
381 */
382 //小于运算符
383 template <size_t M, size_t N, typename T>
384 bool operator<  (const Matrix<M, N, T>& lhs,const Matrix<M, N, T>& rhs) 
385 {
386     /* Compute the mismatch. */
387     std::pair<typename Matrix<M, N, T>::const_iterator,
388         typename Matrix<M, N, T>::const_iterator> disagreement =
389         std::mismatch(lhs.begin(), lhs.end(), rhs.begin());
390 
391     /* lhs < rhs only if there is a mismatch and the lhs‘s element is
392     * lower than the rhs‘s element.
393     */
394     return disagreement.first != lhs.end() &&
395         *disagreement.first < *disagreement.second;
396 }
397 
398 /* The remaining relational operators are implemented in terms of <. */
399 template <size_t M, size_t N, typename T>
400 bool operator<= (const Matrix<M, N, T>& lhs, const Matrix<M, N, T>& rhs)
401 {
402     /* x <= y  iff  !(x > y)  iff  !(y < x) */
403     return !(rhs < lhs);
404 }
405 template <size_t M, size_t N, typename T>
406 bool operator>= (const Matrix<M, N, T>& lhs, const Matrix<M, N, T>& rhs)
407 {
408     /* x >= y  iff  !(y > x)  iff  !(x < y) */
409     return !(lhs < rhs);
410 }
411 template <size_t M, size_t N, typename T>
412 bool operator>(const Matrix<M, N, T>& lhs, const Matrix<M, N, T>& rhs)
413 {
414     /* x > y  iff  y < x */
415     return !(rhs < lhs);
416 }
417 
418 /* Transposition is reasonably straightforward. */ //转置
419 template <size_t M, size_t N, typename T>
420 const Matrix<N, M, T> Transpose(const Matrix<M, N, T>& m)
421 {
422     Matrix<N, M, T> result;
423     for (size_t row = 0; row < m.numRows(); ++row)
424         for (size_t col = 0; col < m.numCols(); ++col)
425             result[col][row] = m[row][col];
426     return result;
427 }
428 
429 /* Identity matrix just fills in the diagonal. */
430 template <size_t M, typename T> Matrix<M, M, T> Identity()
431 {
432     Matrix<M, M, T> result;
433     for (size_t row = 0; row < result.numRows(); ++row)
434         for (size_t col = 0; col < result.numCols(); ++col)
435             result[row][col] = (row == col ? T(1) : T(0));
436     return result;
437 }
438 template <size_t M,size_t N,typename T>
439 void Matrix<M, N, T>::printMatrix(void) const
440 {
441     for (size_t i = 0; i < this->numRows();++i)
442     {
443         for (size_t j = 0; j < this->numCols();++j)
444         {
445             cout << this->at(i, j)<<" ";
446         }
447         cout << endl;
448     }
449 }
450 
455 #endif

 1 #include <iostream>
 2 #include <vector>
 3 #include "matrix.h"
 4 
 5 using namespace std;
 6 
 7 
 8 void testMatrixClass();
 9 
10 int main()
11 {
12     testMatrixClass();
13     
14     return 0;
15 }
16 void testMatrixClass()
17 {
18     vector<int>  vec1,vec2;
19     for (int i = 0; i < 6;++i)
20     {
21         vec1.push_back(i);
22     }
23     for (int i = 0; i < 12; ++i)
24     {
25         vec2.push_back(i+1);
26     }
27     vector<int>::iterator itBegin = vec1.begin();
28     vector<int>::iterator itEnd = vec1.end();
29 
30 
31     Matrix<2, 3, int>m_matrix1(itBegin,itEnd );    //用迭代器构造矩阵对象
32     Matrix<3, 4, int>m_matrix2(vec2.begin(),vec2.end());
33     cout << "---------Matrix 1 = :-----------------" << endl;
34     m_matrix1.printMatrix();
35     cout << "---------Matrix 2 = :-----------------" << endl;
36     m_matrix2.printMatrix();
37     cout << "-----matrix1(1,1) (从0开始)= " << m_matrix1.at(1, 1) << endl;
38     cout << "---matrix1‘s size = " << m_matrix1.size() << " rows = " << m_matrix1.numRows()
39         << " cols = " << m_matrix1.numCols() << endl;
40     cout << "----matrix1 *3 = " <<  endl;
41     (m_matrix1 *= 3).printMatrix();
42     cout << "----matrix1 * matrix 2 = " << endl;
43     Matrix<2, 4, int> result;
44     result = m_matrix1*m_matrix2;
45     result.printMatrix();
46 
47 }