C++实验1 CMatrix类设计与实现

最新推荐文章于 2021-11-02 12:41:26 发布

原创最新推荐文章于 2021-11-02 12:41:26 发布 · 262 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#c++

C++ 专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了CMatrix类的设计与实现，包括构造函数（如默认构造、带参数和从文件读取）、析构函数、内存管理、运算符重载（算术、关系和下标操作）、友元函数以及输入输出重载。通过实例展示了如何使用该类进行矩阵操作和错误处理。

CMatrix类设计与实现

实验基本内容

CMatrix(): 不带参数的构造函数；
CMatrix(int nRow, int nCol, double pData=NULL) : 带行、列及数据指针等参数的构造函数,并且参数带默认值；
CMatrix(const char strPath): 带文件路径参数的构造函数；
CMatrix(const CMatrix& m): 拷贝构造函数
此外会用列表初始化成员变量：CMatrix(): m_nRow(0), m_nCol(0), m_pData(NULL);
bool Create(int nRow, int nCol, double *pData=NULL): 先删除原有空间，根据传入行列创建空间，如果pData不为空要将pData的内容拷贝到m_pData中。
二、析构函数
~CMatrix(): 调用Release();
Release(): 将内存释放，并将行列设置为0；
三、运算符重载
算术运算符重载：+, -, +=, -=
关系运算符重载：>, <, ==
下标操作符：[], ()
强制类型转换: double
赋值运算符：=，尤其注意当m1=m1特殊情况的处理
四、友元函数
输入和输出运输符：<<, >>
五、作业提交方式
写完请发表博客，上传博客链接

源码实现：

1.main.cpp

#include <iostream>
 /* run this program using the console pauser or add your own getch, system("pause")*/
#include <stdio.h>
#include "CMatrix.h"
#include "CMatrix.cpp"
#include <direct.h>
using namespace std;
int main(int argc, char** argv) {
	double pData[10] = { 2,3,4,5 };
	CMatrix m3("1.txt");
	CMatrix m1, m2(2, 5, pData),  m4(m2);
	
	cout << "输入矩阵行 列 数值:" << endl;
	cin >> m1;
	m2.Set(1, 3, 10);
	cout <<"m1="<< m1 <<"m2="<< m2 <<"m3="<< m3 <<"m4="<< m4;
	m4 = m3;
	m4[2] = m4 + 1;
	if (m4 == m3)
	{
		cout << "Error !" << endl;
	}
	m4 += m3;
	cout <<"\nafter:\n"<<endl;
	cout <<"m1="<< m1 <<"m2="<< m2 <<"m3="<< m3 <<"m4="<< m4;
	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);
	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) 
{
	/*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;
	//cout << *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));
		return true;
	}
	return false;
}
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 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;
}
// 对CMatrix的cin,cout
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;
}