引言：
无意间看到国外一个网站写的Matrix类，实现了加减乘除基本运算以及各自的const版本等等，功能还算比较完善，，于是记录下来，以备后用：
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 }
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
