经典数据结构之二维矩阵的基本运算

数组的数组即是矩阵，这篇文章就是很好的例子。往往我们会抱怨c++ std里面没有现成的矩阵运算库，其实，矩阵运算十分容易构造，不论是二维数组，还是经过打包的数组，甚至是vector等容易，都可以很轻易地做出扩展，满足我们复杂的要求。

具体代码如下所述:

.h文件

#ifndef CARRAY2D_HHH
#define CARRAY2D_HHH

#include <cassert>
#include "Array1D.h"

template<typename T>
class CArray2D{
private:
	// members;
	int m_nRow, m_nCol;
	CArray1D<T>* m_pArray;
public:
    // constructors;
	CArray2D(const int& row, const int& col);
	CArray2D(const CArray2D& array);
    ~CArray2D();

    // methods;	
	// row Size;
	int mRowSize() const;
	// col Size;
	int mColSize() const;
	// operator [];
	CArray1D<T>& operator[](int index) const;
	// operator +;
	CArray2D<T> operator+() const;
	CArray2D<T> operator+(const CArray2D<T>& array) const;
	// operator -;
	CArray2D<T> operator-() const;
	CArray2D<T> operator-(const CArray2D<T>& array) const;
    // operator *;
	CArray2D<T> operator*(const CArray2D<T>& array) const;
	// operator =;
	CArray2D<T>& operator=(const CArray2D<T>& array);
	// operator +=;
	CArray2D<T>& operator+=(const CArray2D<T>& array);
	// print;
	void print(std::ostream& out) const;
};

template<typename T>
CArray2D<T>::CArray2D(const int& row, const int& col):
    m_nRow(row), m_nCol(col){
	assert((row > 0) && (col > 0));
	m_pArray = new CArray1D<T>[row];
	for(int i = 0; i < row; i ++)
		m_pArray[i].mResize(m_nCol);
}

template<typename T>
CArray2D<T>::CArray2D(const CArray2D<T>& array):
    m_nRow(array.m_nRow), m_nCol(array.m_nCol){
		m_pArray = new CArray1D<T>[m_nRow];
		for(int i = 0; i < m_nRow; i ++){
			m_pArray[i] = array[i];
		}
}

template<typename T>
CArray2D<T>::~CArray2D(){
	delete [] m_pArray;
}

template<typename T>
int CArray2D<T>::mColSize() const{
	return m_nCol;
}

template<typename T>
int CArray2D<T>::mRowSize() const{
	return m_nRow;
}

template<typename T>
CArray1D<T>& CArray2D<T>::operator[](int index) const{
	assert(index >= 0) && index < m_nRow);
	return m_pArray[index];
}

template<typename T>
CArray2D<T>& CArray2D<T>::operator=(const CArray2D<T>& array){
	if(&array != this){
        delete [] m_pArray;
	    m_pArray = new CArray1D<T>[m_nRow];	
		m_nRow = array.m_nRow;
		m_nCol = array.m_nCol;

		for(int i = 0; i < m_nRow; i ++){
			m_pArray[i] = array[i];
		}
	}
	return *this;
}

template<typename T>
CArray2D<T> CArray2D<T>::operator+() const{
	CArray2D<T> tmp(m_nRow, m_nCol);
	for(int i = 0; i < m_nRow; i ++)
       tmp.m_pArray[i] = (+m_pArray[i]);
	return tmp;
}

template<typename T>
CArray2D<T> CArray2D<T>::operator+(const CArray2D<T>& array) const{
	assert((m_nRow == array.m_nRow) && (m_nCol == array.m_nCol));
	CArray2D<T> tmp(m_nRow, m_nCol);
	for(int i = 0; i < m_nRow; i ++)
		tmp.m_pArray[i] = this->m_pArray[i] + array.m_pArray[i];
    return tmp;
}

template<typename T>
CArray2D<T> CArray2D<T>::operator-() const{
	CArray2D<T> tmp(m_nRow, m_nCol);
	for(int i = 0; i < m_nRow; i ++)
       tmp.m_pArray[i] = (-m_pArray[i]);
	return tmp;
}


template<typename T>
CArray2D<T> CArray2D<T>::operator-(const CArray2D<T>& array) const{
	assert((m_nRow == array.m_nRow) && (m_nCol == array.m_nCol));
	CArray2D<T> tmp(m_nRow, m_nCol);
	for(int i = 0; i < m_nRow; i ++)
		tmp.m_pArray[i] = this->m_pArray[i] - array.m_pArray[i];
    return tmp;
}

template<typename T>
CArray2D<T> CArray2D<T>::operator*(const CArray2D<T>& array) const{
	assert(array.m_nCol == m_nRow);
	CArray2D<T> tmp(m_nRow, array.m_nCol);
	for(int i = 0; i < m_nRow; i ++){
		for(int j = 0; j < array.m_nCol; j ++){
			tmp.m_pArray[i][j] = 0;
			for(int k = 0; k < m_nCol; k ++)
				tmp.m_pArray[i][j] += m_pArray[i][k] * array.m_pArray[k][j];
		}
	}
    return tmp;
}

template<typename T>
void CArray2D<T>::print(std::ostream& out) const{
	for(int i = 0; i < m_nRow; i ++)
		m_pArray[i].print(out);
}
#endif