一个简单的Matrix实现

我们直接来看代码吧：

1. /*    Matrix.h    */
2. #pragma once
3. #include <iostream>
4. using namespace std;
5. //矩阵类
6. class Matrix
7. {
8. public:
9.     double * p;
10.     //矩阵宽度
11.     long width;
12.     //矩阵高度
13.     long height;
14. public:
15.     long getHeight();
16.     long getWidth();
17.     bool isVector();//如果是false，那就是一个数
18.     double Arg();//求行列式
19.     bool isPtv();//是否正定
20.     Matrix  T();//转置
21.     Matrix subMatrix(long offset);
22.     void Test();//测试函数
23.     /***********重载部分-Overloaded Part*****************/
24.     Matrix operator+(Matrix &);
25.     Matrix operator-(Matrix &);
26.     Matrix operator*(Matrix &);
27.     friend Matrix operator*(double alpha,Matrix &);//实数与矩阵相乘
28.     Matrix operator*(double alpha);//矩阵与实数相乘
29.     Matrix operator/(Matrix &);//实际是实数相除或矩阵和实数相除
30.     Matrix operator/(double sub);
31.     Matrix operator+=(Matrix &);
32.     Matrix operator-=(Matrix &);
33.     Matrix operator*=(double alpha);//矩阵与实数相乘
34.     friend Matrix  sqrt(Matrix m);//开方
35.     friend double abs(Matrix &);//取绝对值
36.     Matrix &operator=(Matrix &);
37.     double * operator[](long heightPos);//用于实现用[][]操作矩阵元素
38.     friend ostream & operator<<(ostream &,Matrix &) ;
39.     Matrix(void);//default constructor
40.     Matrix(long n);//单位矩阵
41.     Matrix(double * arrAddress,long arrWidth);//构造一维矩阵
42.     Matrix(double * arrAddress,long arrWidth,long arrHeight);
43.     Matrix(const Matrix &);//copy constructor
44.     ~Matrix(void);//default destructor
45.     /***********重载部分-Overloaded Part*****************/
46. };

下面是实现和测试的代码：

1. /*    Matrix.cpp    */
2. #include "Matrix.h"
3. #include <math.h>
4. #include <assert.h>
5. Matrix::Matrix(void)
6. {
7.     p=new double[1];
8.     width=0;
9.     height=0;
10. }
11. Matrix::Matrix(long n)
12. {
13.     height=width=n;
14.     p=new double[n*n];
15.     for(long i=0;i<n;i++){
16.         for(long j=0;j<n;j++){
17.             if(i==j) *(p+n*i+j)=1;
18.             else *(p+n*i+j)=0;
19.         }
20.     }
21. }
22. Matrix::Matrix(double * arrAddress,long arrWidth)
23. {
24.     long arrHeight=1;
25.     p=new double[arrWidth*arrHeight];
26.     for(long i=0;i<arrHeight;i++){
27.         for(long j=0;j<arrWidth;j++){
28.             *(p+arrWidth*i+j)=*(arrAddress+arrWidth*i+j);
29.         }
30.     }
31.     width=arrWidth;
32.     height=arrHeight;
33. }
34. Matrix::Matrix(double * arrAddress,long arrWidth,long arrHeight)
35. {
36.     p=new double[arrWidth*arrHeight];
37.     for(long i=0;i<arrHeight;i++){
38.         for(long j=0;j<arrWidth;j++){
39.             *(p+arrWidth*i+j)=*(arrAddress+arrWidth*i+j);
40.         }
41.     }
42.     width=arrWidth;
43.     height=arrHeight;
44. }
45. Matrix::Matrix(const Matrix & m)//copy constructor
46. {
47.     height=m.height;
48.     width=m.width;
49.     p=new double[height*width];
50.     for(long i=0;i<height;i++){
51.         for(long j=0;j<width;j++){
52.             *(p+width*i+j)=*(m.p+width*i+j);
53.         }
54.     }
55. }
56. long Matrix::getWidth(){
57.     return width;
58. }
59. long Matrix::getHeight(){
60.     return height;
61. }
62. bool Matrix::isVector()
63. {
64.     return !(width==1 && height==1);
65. }
66. Matrix Matrix::subMatrix(long offset)
67. {
68.     assert(height==width && offset<=width && offset>=0);
69.     double * t=new double[offset*offset];
70.     for(long i=0;i<offset;i++){
71.         for(long j=0;j<offset;j++){
72.             *(t+offset*i+j)=*(p+width*i+j);
73.         }
74.     }
75.     Matrix m(t,offset,offset);
76.     delete [] t;
77.     return m;
78. }
79. double Matrix::Arg()//矩阵的行列式
80. {
81.     assert(width==height);
82.     double result=1;
83.     double k;
84.     Matrix m=*this;
85.     for(long i=0;i<height-1;i++){//Gauss消去法，变换成上三角矩阵
86.         for(long j=i+1;j<height;j++){
87.             k=m[j][i]/m[i][i];
88.             m[j][i]=0;
89.             for(long n=i+1;n<width;n++){
90.                 m[j][n]=m[j][n]-k*m[i][n];
91.             }
92.         }
93.     }
94.     for(i=0;i<height;i++){
95.         for(long j=0;j<width;j++){
96.             if(i==j) result*=m[i][j];
97.         }
98.     }
99.     return result;
100. }
102. bool Matrix::isPtv()
103. {
104.     assert(width==height);//是方阵才可以计算
105.     bool result=true;
106.     Matrix m;
107.     for(long i=1;i<=height;i++){
108.         m=this->subMatrix(i);
109.         if(m.Arg()<=0){
110.             result=false;
111.             break;
112.         }
113.     }
114.     return result;
115. }
116. Matrix  Matrix::T()
117. {
118.     double * t=new double[width*height];
119.     for(long i=0;i<height;i++){
120.         for(long j=0;j<width;j++){
121.             *(t+height*j+i)=*(p+width*i+j);
122.         }
123.     }
124.     Matrix m(t,height,width);
125.     delete [] t;
126.     return m;
127. }
128. Matrix Matrix::operator +(Matrix &m1)
129. {
130.     assert(m1.height==height && m1.width==width);
131.     long tmpHeight=m1.height;
132.     long tmpWidth=m1.width;
133.     double * t=new double[tmpWidth*tmpHeight];
134.     for(long i=0;i<tmpHeight;i++){
135.         for(long j=0;j<tmpWidth;j++){
136.             *(t+tmpWidth*i+j)=*(m1.p+tmpWidth*i+j)+*(p+tmpWidth*i+j);
137.         }
138.     }
139.     Matrix m(t,tmpWidth,tmpHeight);
140.     delete [] t;
141.     return m;
142. }
143. Matrix Matrix::operator -(Matrix &m1)
144. {
145.     assert(m1.height==height && m1.width==width);
146.     long tmpHeight=m1.height;
147.     long tmpWidth=m1.width;
148.     double * t=new double[tmpWidth*tmpHeight];
149.     for(long i=0;i<tmpHeight;i++){
150.         for(long j=0;j<tmpWidth;j++){
151.             *(t+tmpWidth*i+j)=*(p+tmpWidth*i+j)-*(m1.p+tmpWidth*i+j);
152.         }
153.     }
154.     Matrix m(t,tmpWidth,tmpHeight);
155.     delete [] t;
156.     return m;
157. }
158. Matrix Matrix::operator *(Matrix &m1)
159. {
160.     if(!this->isVector() && m1.isVector()){//左为数,右为矩阵
161.         Matrix m;
162.         m=p[0]*m1;
163.         return m;
164.     }else if(this->isVector() && !m1.isVector()){//左为矩阵,右为数
165.         Matrix m;
166.         m=*this*m1[0][0];
167.         return m;
168.     }else if(!this->isVector() && m1.isVector()){//左右都为数
169.         double * t=new double[1];
170.         t[0]=p[0]*m1[0][0];
171.         Matrix m(t,1,1);
172.         delete [] t;
173.         return m;
174.     }else if(this->isVector() && m1.isVector() && width==m1.height){//左为矩阵,右为矩阵
175.         double sum;
176.         double * t=new double[height*m1.width];
177.         for(long i=0;i<height;i++){
178.             for(long j=0;j<m1.width;j++){
179.                 sum=0;
180.                 for(long k=0;k<width;k++){
181.                     sum+=(*(p+width*i+k))*(m1[k][j]);
182.                 }
183.                 *(t+m1.width*i+j)=sum;
184.             }
185.         }
186.         Matrix m(t,m1.width,height);
187.         delete [] t;
188.         return m;
189.     }else{
190.         assert(0);//未知运算
191.         return *this;
192.     }
193. }
194. Matrix operator*(double alpha,Matrix & m1)
195. {
196.     Matrix m=m1;
197.     for(long i=0;i<m.height;i++){
198.         for(long j=0;j<m.width;j++){
199.             m[i][j]=alpha*m1[i][j];
200.         }
201.     }
202.     return m;
203. }
204. Matrix Matrix::operator*(double alpha)
205. {
206.     return alpha*(*this);
207. }
208. Matrix Matrix::operator+=(Matrix & m)
209. {
210.     return *this+m;
211. }
212. Matrix Matrix::operator-=(Matrix & m)
213. {
214.     return *this-m;
215. }
216. Matrix Matrix::operator *=(double alpha)
217. {
218.     return *this*alpha;
219. }
220. Matrix sqrt(Matrix m)
221. {
222.     m[0][0]=sqrt(m[0][0]);
223.     return m;
224. }
225. double abs(Matrix & m)
226. {
227.     double sum=0;
228.     for(long i=0;i<m.height;i++){
229.         for(long j=0;j<m.width;j++){
230.             sum+=m[i][j]*m[i][j];
231.         }
232.     }
233.     return sqrt(sum);
234. }
235. Matrix Matrix::operator /(Matrix &m1)
236. {
237.     assert(m1.width==1 && m1.height==1);
238.     return *this/m1[0][0];
239. }
240. Matrix Matrix::operator /(double sub)
241. {
242.     Matrix m=*this;
243.     for(long i=0;i<height;i++){
244.         for(long j=0;j<width;j++){
245.             m[i][j]=*(p+width*i+j)/sub;
246.         }
247.     }
248.     return m;
249. }
250. Matrix & Matrix::operator =(Matrix & m)
251. {
252.     if(&m==this) return *this;
253.     height=m.height;
254.     width=m.width;
255.     delete [] p;
256.     p=new double[height*width];
257.     for(long i=0;i<height;i++){
258.         for(long j=0;j<width;j++){
259.             *(p+width*i+j)=*(m.p+width*i+j);
260.         }
261.     }
262.     return *this;
263. }
264. double * Matrix::operator [](long heightPos)
265. {
266.     assert(heightPos>=0 && heightPos<height);
267.     return p+width*heightPos;
268. }
269. ostream & operator<<(ostream & os,Matrix & m)
270. {
271.     os<<"Matrix:height="<<m.height<<endl;
272.     os<<"Matrix:width="<<m.width<<endl;
273.     for(long i=0;i<m.height;i++){
274.         for(long j=0;j<m.width;j++){
275.             os<<m[i][j]<<" "; 
276.         } 
277.         os<<endl;
278.     }
279.     return os;
280. }
281. Matrix::~Matrix(void)
282. {
283.     delete [] p;
284. }
285. void Matrix::Test(){
286.     double arr[4][4]={{1,1,1,1},{1,2,3,4},{1,3,6,10},{1,4,10,20}};
287.     Matrix m1,m(&arr[0][0],4,4),m2(&arr[0][0],4,4);
288.     m.isPtv();
289.     /*            
290.     cout<<"arranger="<<m.Arg()<<endl;
291.     cout<<m;*/
292. }
295. void main()
296. {
297.     Matrix obj;
298.     obj.Test();
299. }

我们可以从文件中发现Matrix常用的功能，比如SubMatrix()、乘法等等。另外，将Matrix的测试过程，包含在Matrix类本身——我觉得这种方式类似于“白盒”测试；如果包装成对象再测试，那就是“黑盒”：）