矩阵类的实现，运算符重载

技术含量不多，主要是自己收藏，记载着这里，以后用的时候再看看。

//File matrix.h
#ifndef MATRIX_H
#define MATRIX_H

#include <iostream>
#include <string>
using namespace std;

template<typename T>
class Matrix
{
//private:
public:
	int row,col;                                      //行、列
	T *element;                                        //数组
public:
	Matrix(int r = 1,int c = 1);                       //构造函数
	Matrix(int r, int c, T* initval);                  //构造函数
	Matrix(const Matrix<T>&);                          //拷贝构造函数
	~Matrix(){delete element;}                         //析构函数
	int Rowsize()const{return row;}                    //行长
	int Colsize()const{return col;}                    //列长
	T& operator()(int i,int j)const;                   //取元素
	Matrix<T>&operator=(const Matrix<T>&);             //赋值
	Matrix<T>operator+()const;                         //一元加
	Matrix<T>operator+(const Matrix<T>&);              //二元加
	Matrix<T>operator-()const;                         //一元减
	Matrix<T>operator-(const Matrix<T>&)const;         //二元减
	Matrix<T>operator*(const Matrix<T>&)const;         //乘法
	Matrix<T>transpose();                              //转置
	friend ostream& operator<<(ostream& out, const Matrix<T>&);
};

//考虑到矩阵操作中可能出现异常，定义两个异常类，分别表示下标越界和行、列不匹配的异常

class Bounds_error                                          //下标越界异常
{
public:
	Bounds_error(char* s):str(s){}
	void display()
	{cout<<str<<endl;}
private:
	string str;
};

class RCdismatch                                           //行列不匹配异常
{
public:
	RCdismatch(char* s):str(s){}
	void display()
	{cout<<str<<endl;}
private:
	string str;
};

#endif

//File Matrix.cpp  是类Matrix的实现文件

#include <iomanip>
#include "matrix.h"
using namespace std;

//
//各成员函数的实现
template<typename T>
Matrix<T>::Matrix(int r, int c)//构造函数
{
	row = r;
	col = c;
	element = new T[r*c];
}

//
//测试的时候总是发现这个函数不对，调试总是没找出问题
///这是怎么回事？？？怎么回事？？？？？？
template<typename T>
Matrix<T>::Matrix(int r, int c, T* initval)//构造函数
{
	row = r;
	col = c;
	int size = r*c;
	element = new T[size];
	for (int i=0;i<size;i++)
		element[i] = *(initval + i);
}

template<typename T>
Matrix<T>::Matrix(const Matrix<T>& m)  //拷贝构造函数
{
	row = m.row;
	col = m.col;
	int size = row*col;
	element = new T[size];
	for (int i=0;i<size;i++)
		element[i] = m.element[i];
}


//圆括号()重载为举证的下标操作，对下标i和j(0<=i<row,0<=j<col)
//输出矩阵的第i行第j列元素，它在一维数组中的位置是i*col+j
template<typename T>
T& Matrix<T>::operator()(int i,int j)const
{
	if(i < 0 || i > row - 1 || j < 0 || j > col - 1)
		throw Bounds_error("下标越界!");//异常
	return element[i*col+j];
}

//赋值运算符重载
template<typename T>
Matrix<T>& Matrix<T>::operator=(const Matrix<T>& m)
{
	if(row != m.row || col != m.col)
		throw RCdismatch("行、列不匹配，不能赋值!");
	int size = row * col;
	for(int i=0;i<size;i++)
		element[i]=m.element[i];
	return *this;
}

//一元加运算符重载
template<typename T>
Matrix<T> Matrix<T>::operator+()const
{

}

//二元加重载
template<typename T>
Matrix<T> Matrix<T>::operator+(const Matrix<T>& m)
{
	if(row != m.row || col != m.col)
		throw RCdismatch("行、列不匹配，不能赋值!");
	int size = row * col;
	for(int i=0;i<size;i++)
		element[i] += m.element[i];
	return this;
}

//一元减
template<typename T>
Matrix<T> Matrix<T>::operator-()const
{

}

//二元减
template<typename T>        
Matrix<T> Matrix<T>::operator-(const Matrix<T>& m)const
{
	if(row != m.row || col != m.col)
		throw RCdismatch("行、列不匹配，不能赋值!");
	int size = row * col;
	for(int i=0;i<size;i++)
		element[i] -= m.element[i];
	return this;
}

//乘法,矩阵(*this)乘以矩阵m
template<typename T>
Matrix<T> Matrix<T>::operator*(const Matrix<T>& m)const
{
	if(col != m.row)
		throw RCdismatch("行、列不匹配，不能赋值!");
	Matrix<T> w(row,m.col);
//	//这段是我自己写的
// 	int sum,k;
// 	for (int i = 0; i < row; i ++)
// 	{
// 		for (int j = 0; j < m.col; j ++)
// 		{
// 			sum = 0;
// 			for (k = 0; k < col; k ++)
// 			{
// 				sum +=(*this)(i,k)*m(k,j);
// 			}
// 			w(i,j) = sum;
// 		}
// 	}
	int r = 0;
	for (int i = 0; i < row; i ++)
	{
		for (int j = 0; j < m.col; j ++)
		{
			int p = i * col;//矩阵*this第i行第一个元素的位置
			int q = j;//矩阵第j列第一个元素的位置
			T sum = element[p]*m.element[q];
			for (int k = 1; k < col; k ++)
			{
				p++;
				q+=m.col;
				sum+=element[p]*m.element[q];
			}
			w.element[r++] = sum;

		}
	}
	return w;
}

//转置
template<typename T>
Matrix<T> Matrix<T>::transpose()
{
	Matrix<T>m(col,row);//矩阵m
	for(int i = 0; i < row; i ++)
	{
		for(int j = 0; j < col; j ++)
		{
			m(j,i) = (*this)(i,j);
		}
	}
	return m;
}

//输出
template<typename T>
ostream& operator<<(ostream& out, const Matrix<T>& m)
{
	for (int i = 0; i < m.row; i ++)
	{
		for (int j = 0; j < m.col; j ++)
			cout << setw(5)<<m(i,j);
		cout<<endl;
	}
	return out;
}

//测试矩阵函数的程序
//#include "matrix.h"
#include "Matrix.cpp"
using namespace std;

int main()
{
	int data1[12] = {5,7,8,2,-2,4,1,1,1,2,3,4};
	int data2[20] = {4,-2,3,3,9,4,3,8,-1,2,2,3,5,2,7,1,0,6,3,4};
	Matrix<int> A(3,4,data1);
	Matrix<int> B(4,5,data2);
	cout<<A.transpose();
	cout<<"=============="<<endl;
	cout<<B.transpose();
	cout<<"=============="<<endl;
	try
	{
		cout<<A*B<<endl;
	}
	catch (RCdismatch& e)
	{
		e.display();
		cout<<endl;
	}
	catch (Bounds_error& e)
	{
		e.display();
		cout<<endl;
	}
	return 0;
}

调试的时候发现构造函数总是不对，唉，怎么都找不出问题。