实验一：CMatrix类设计与实现

• 一 代码实现
• • 1.main.cpp
  • 2.CMatrix.h
  • 3.CMatrix.cpp
• 二 运行截图
• 三 总结
• • 1.构造函数
  • 2.析构函数
  • 3.运算符重载
  • 4.友元函数

一 代码实现

1.main.cpp

#include  < iostream>
#include <stdio.h>
#include "CMatrix.h"
 using namespace std;
 int main(int argc, char** argv) {
    
     double pData[10]={2,3,4,5};
     CMatrix m1,m2(2,5,pData), m3("d:\\1.txt"),m4(m2);
     cin>>m1;
     m2.Set(1,3,10);
     cout<<m1<<m2<<m3<<m4;
     m4=m3;
     m4[2]=m4+1;
     if(m4==m3)
     {
         cout<<"Error !"<<endl;
     }
     m4 += m3;
     cout<<"sum of m4 = "<<(double)m4<<endl;
     return 0;
 }

2.CMatrix.h

 #ifndef CMATRIX_H
#define CMATRIX_H
#include <iostream>
 using namespace std;
 class CMatrix
 {
     public:
         CMatrix();
             CMatrix(int nRow, int nCol, double* pData = NULL);
             CMatrix(const CMatrix & m);
             CMatrix(const char* strPath);
             ~CMatrix();
             bool Create(int nRow, int nCol, double* pData = NULL);
             void Set(int nRow, int nCol, double dVale);
             void Release();
             friend istream & operator>>(istream& is, CMatrix& m);
             friend ostream & operator<<(ostream & os, const CMatrix & m);
        
         CMatrix & operator=(const CMatrix & m);
             CMatrix & operator+=(const CMatrix & m);
         //  CMatrix& operator+(const CMatrix& m);
         //  CMatrix operator+(const CMatrix& m1,const CMatrix& m2);
             double& operator[](int nIndex);
             double& operator()(int nRow, int nCol);
             bool operator ==(const CMatrix & m);
             bool operator !=(const CMatrix & m);
        
         operator double();
        
         private:
             int m_nRow;
                 int m_nCol;
                double* m_pData;
             };
 CMatrix operator+(const CMatrix & m1, const CMatrix & m2);
 inline void CMatrix::Set(int nRow, int nCol, double dVal)
 {
         m_pData[nRow * m_nCol + nCol] = dVal;
     }
  #endif

3.CMatrix.cpp

#include "CMatrix.h"
 #include <fstream>
 #include <assert.h>
 CMatrix::CMatrix() : m_nRow(0), m_nCol(0), m_pData(0)
 {
	
 }
 CMatrix::CMatrix(int nRow, int nCol, double* pData) : m_pData(0)
 {
	     Create(nRow, nCol, pData);
	 }
  CMatrix::CMatrix(const CMatrix & m) : m_pData(0)
 {
	     *this = m;
	 }
 CMatrix::CMatrix(const char* strPath)
 {
	     m_pData = 0;
	     m_nRow = m_nCol = 0;
	     ifstream cin(strPath);
	     cin >> *this;
	 }
 CMatrix::~CMatrix()
 {
	     Release();
	 }
 bool CMatrix::Create(int nRow, int nCol, double* pData)
 {
	     Release();
	     m_pData = new double[nRow * nCol];
	     m_nRow = nRow;
	     m_nCol = nCol;
	     if (pData)
		 {
		         memcpy(m_pData, pData, nRow * nCol * sizeof(double));
		     }
	 }
 void CMatrix::Release()
 {
	     if (m_pData)
		 {
		         delete[]m_pData;
		         m_pData = NULL;
		     }
	 m_nRow = m_nCol = 0;
	 }
 CMatrix & CMatrix::operator=(const CMatrix & m)
 {
	     if (this != &m) {
		         Create(m.m_nRow, m.m_nCol, m.m_pData);
		
	}
	 return *this;
	 }
 CMatrix & CMatrix::operator+=(const CMatrix & m)
 {
	     assert(m_nRow == m.m_nRow && m_nCol == m.m_nCol);
	     for (int i = 0; i < m_nRow * m_nCol; i++)
		 {
		         m_pData[i] += m.m_pData[i];
		     }
	 return *this;
	 }
 //CMatrix& CMatrix::operator+(const CMatrix& m)
 //{
	 //  assert(m_nRow==m.m_nRow && m_nCol==m.m_nCol);
	 //  for(int i=0;i<m_nRow*m_nCol;i++)
	 //  {
	 //      m_pData[i]+=m.m_pData[i];
	 //  }
	 //  return *this;
	 //}
	 //CMatrix CMatrix::operator+(const CMatrix& m1,const CMatrix& m2)
	 //{
	 //  CMatrix m3(m1);
	 //  m3+=m2;
	 //  return m3;
	 //}
	 CMatrix operator+(const CMatrix & m1, const CMatrix & m2)
	 {
	     CMatrix m3(m1);
	     m3 += m2;
	     return m3;
	 }
 double& CMatrix::operator[](int nIndex)
 {
	     assert(nIndex < m_nRow * m_nCol);
	     return m_pData[nIndex];
	 }
 double& CMatrix::operator()(int nRow, int nCol)
 {
	     assert(nRow * m_nCol + nCol < m_nRow * m_nCol);
	     return m_pData[nRow * m_nCol + nCol];
	 }
 bool CMatrix::operator == (const CMatrix & m)
 {
	     if (!(m_nRow == m.m_nRow && m_nCol == m.m_nCol))
		 {
		         return false;
		     }
	 for (int i = 0; i < m_nRow * m_nCol; i++)
		 {
		         if (m_pData[i] != m.m_pData[i])
			 {
			             return false;
			         }
		 }
	     return true;
	 }
 bool CMatrix::operator !=(const CMatrix & m)
 {
	     return !((*this) == m);
	 }
 CMatrix::operator double()
 {
	     double dS = 0;
	     for (int i = 0; i < m_nRow * m_nCol; i++)
		 {
		         dS += m_pData[i];
		     }
	 return dS;
	 }
 istream & operator>>(istream& is, CMatrix& m)
 {
	     is >> m.m_nRow >> m.m_nCol;
	     m.Create(m.m_nRow, m.m_nCol);
	     for (int i = 0; i < m.m_nRow * m.m_nCol; i++)
		 {
		         is >> m.m_pData[i];
		     }
	 return is;
	 }
 ostream & operator<<(ostream & os, const CMatrix & m)
 {
	     os << m.m_nRow << " " << m.m_nCol << endl;
	     double* pData = m.m_pData;
	     for (int i = 0; i < m.m_nRow; i++)
		 {
		         for (int j = 0; j < m.m_nCol; j++)
			 {
			             os << *pData++ << " ";
			         }
		 os << endl;
		     }
	     return os;
	 }

二 运行截图

输入1 1 3
文件1.txt中内容也为 1 1 3

三 总结

1.构造函数

 		CMatrix();
        CMatrix(int nRow, int nCol, double* pData=NULL);
        CMatrix(const CMatrix& m);
        CMatrix(const char* strPath);

1.可以有多个构造函数进行构造（可以重载）
2.double* pData=NULL 无pData传入时默认进行赋值null

2.析构函数

 ~CMatrix();

1 析构函数不可以有参数，因此不可以发生重载
2.程序在对象销毁前会自动调用析构，无须手动调用，并且只会调用一次

3.运算符重载

 			 CMatrix & operator+=(const CMatrix & m);
             double& operator[](int nIndex);
             double& operator()(int nRow, int nCol);
             bool operator ==(const CMatrix & m);
             bool operator !=(const CMatrix & m);
             operator double();

1.运算符重载，可以将类的运算规则自定义
2 返回值用 类型+& 是为了避免做连续运算时候会出错.原因就是没加&你返回的不是地址而是被Copy了一个临时对象
3 转换函数默认返回类型为它本身

4.友元函数

 		friend istream & operator>>(istream& is, CMatrix& m);
        friend ostream & operator<<(ostream & os, const CMatrix & m);

1.在类中声明友元函数使其可以访问类的私有数据
2.friend和operator同时使用可以让其他类对数据进行的操作符进行自定义