【C++】CMatrix类的构造与创建

一、CMatrix类的代码实现

CMatrix.cpp

#include "CMatrix.h"
#include <fstream>
#include <assert.h>
#include<string.h>
CMatrix::CMatrix() : m_nRow(0), m_nCol(0), m_pData(0) // c++里初始化方式相当于括号内
{
	/*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; // this指向当前类
}
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));
		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;
}

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

二、main函数的实现

main.cpp

#include <iostream>
#include "ccomplex.h"
#include<stdio.h>
#include "cmatrix.h"

using namespace std;

int main()
{
    double pData[10] = {2,3,4,5};
    CMatrix m1,m2(2,5,pData),m3("./1.txt"), m4(m2); //测试多个构造器方法是否正确
    cin>>m1; //测试“>>”重载方法
    m2.Set(1,3,10);
    cout<<"----m1-----\n"<<m1<<"----m2-----\n"<<m2<<"----m3-----\n"<<m3<<"----m4-----\n"<<m4;
    m4=m3; //测试“=”重载方法
   m4[1]=m4+1; //测试“[]”重载方法
    if(m4==m3)
    {
        cout<<"Error!!!!!"<<endl;
    }
  	m4 += m3;
 	cout<<"sum of m4 = "<<double(m4)<<endl;//测试相减之后的m4总和
    bool result = (m4>m3);
    cout<<"m4 > m3 the Result is "<<result<<endl;//测试“>”重载结果
    return 0;
}

三、以上代码运行截图

四、一些重要函数的分析

bool Create(int nRow, int nCol, double *pData=NULL)的作用：先删除原有空间，根据传入行列创建空间，如果pData不为空要将pData的内容拷贝m_pData中。
Release(): 的作用：将内存释放，并将行列设置为0；

1.构造函数：

CMatrix();//不带参数的构造函数；
CMatrix(int nRow, int nCol, double *pData=NULL);//带行、列及数据指针等参数的构造函数,并且参数带默认值；
CMatrix(const char * strPath);//带文件路径参数的构造函数；
CMatrix(const CMatrix& m);//拷贝构造函数

构造函数形式为：类名(){}
可以有多个构造函数进行构造（可以重载）
程序在调用对象的时候会自动调用构造

2.析构函数

~CMatrix(): 

析构函数的形式为：~类名(){}
析构函数不可以有参数，因此不可以发生重载
程序在对象销毁前会自动调用析构函数，并且只会调用一次

3.运算符重载

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();

运算符重载形式为：operator+“运算符”
运算符重载，可以将类的运算规则自定义
算术运算符重载：+, -, +=, -=
关系运算符重载：>, <, ==
下标操作符：[], ()
强制类型转换: double
赋值运算符：=，尤其注意当m1=m1特殊情况的处理

4.友元函数

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

友元函数的形式为：friend+……
在类中声明友元函数使其可以访问类的私有数据
friend和operator同时使用可以让其他类对数据进行的操作符进行自定义
输入和输出运输符：<<, >>