一.代码实现
1.1 CMatrix代码实现
main.cpp
#include <iostream>
#include "CComplex.h"
#include <stdio.h>
#include "CMatrix.h"
using namespace std;
int main(int argc, char** argv) {
//初始化,调用CMatrix()
CMatrix m;
cin >> m;
cout << "m = " << m << endl;
double pData[10] = { 1,2,3,4,5 };
CMatrix m1(2, 5, pData);
CMatrix m2("1.txt");
cout << "m2 = \n" << m2 << endl;
CMatrix m3(m1);
CMatrix m4;
//指向等一个地方
m4 = m1;
//第0行第1列改为20
m1.Set(0, 1, 20);
//此处m1,m4相同
cout << "m3 = \n" << m3 << endl;
cout << "m1 = \n" << m1 << endl;
cout << "m4 = \n" << m4 << endl;
m4 = m4;
cout << "new m4 = \n" << m4 << endl;
//[]重载,[0,1]不允许带多个参数
cout << "m4[8] = " << m4[8] << endl;
//()重载,()允许带多个参数
m4(1, 1) = 10;
cout << "m4(1,1) = " << m4(1, 1) << endl;
if (m4 == m1) {
cout << "Error!" << endl;
}
//+重载
CMatrix m5;
m5 = m1 + m4;
cout << "m5 = \n" << m5 << endl;
//double重载
double d = m5;
cout << "sum of m5 = " << d << endl;
return 0;
}
CMatrix.h
#pragma once
#ifndef CMATRIX_H
#define CMATRIX_H
#include <iostream>
using namespace std;
class CMatrix {
public:
//不带参数的构造函数
CMatrix();
//如果nRow=0有默认值则之后的都得有默认值
//若都默认值为0,相当于无参数,则会与上一个构造函数CMatrix();产生歧义,不知道调用哪一个
//带行、列及数据指针等参数的构造函数, 并且参数带默认值
CMatrix(int nRow, int nCol, double* pData = NULL);
//拷贝构造函数
CMatrix(const CMatrix& m);
//带文件路径参数的构造函数
CMatrix(const char* strPath);
//析构函数名应与类名相同,只是在函数名前面加一个位取反符,以区别于构造函数。
//它不能带任何参数,也没有返回值(包括void类型)。由于没有函数参数,因此它不能被重载,只能有一个析构函数。
//如果用户没有编写析构函数,编译系统会自动生成一个缺省的析构函数(即使自定义了析构函数,编译器也总是会为我们合成一个析构函数,并且如果自定义了析构函数,编译器在执行时会先调用自定义的析构函数再调用合成的析构函数),它也不进行任何操作。所以许多简单的类中没有用显示的析构函数。
//当对象的生命周期结束时,撤销类对象时候会自动调用析构函数。
//1.对象在生命期结束,撤销类对象时会自动调用析构函数。
//2.如果用new运算动态地建立一个对象,那用delete运算符释放该对象时,才会调用析构函数。
~CMatrix();
bool Create(int nRow, int nCol, double* pData = NULL);
void Set(int nRow, int nCol, double dVal);
//隐式内联函数,不声明
//void CMatrix::Set(int nRow, int nCol, double dVal) {
// m_pData[nRow * m_nCol + nCol] = dVal;
//}
void Release();
//赋予特权,特殊声明,friend加了之后为全局函数不是成员函数,类里面定义的所有对象都可以调用,所以可以访问下面的private私有变量
//输出输入流运算符重载,原本输出输入流只能针对基础的数据类型,比如char,int,double,指针,重载后使其能够读取自己定义的类
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 // !CMATRIX_H
CMatrix.cpp
#include "CMatrix.h"
#include <fstream>
#include <assert.h>
//这种初始化方式提高效率,顺序与成员变量原来的顺序一样,可同时与下面的初始化方式共用
CMatrix::CMatrix() :m_nRow(0), m_nCol(0), m_pData(NULL){
//先申请空间完之后才赋值
//m_nRow = 0;
//m_nCol = 0;
//m_pData = NULL;
}
CMatrix::CMatrix(int nRow, int nCol, double* pData) : m_pData(NULL) {
//因为Create中有Release(),如果不初始化会因为不是NULL直接delete
Create(nRow, nCol, pData);
}
//拷贝构造函数
CMatrix::CMatrix(const CMatrix& m) : m_pData(NULL) {
*this = m;
}
//方法1:
//CMatrix::CMatrix(const CMatrix& m) : {
// m_nRow = 0;
// m_nCol = 0;
// m_pData = NULL;
// Create(m_nRow, m_nCol, m_pData);
//}
//方法2:构造该函数,用另一个构造函数去构造
//CMatrix::CMatrix(const CMatrix& m) : CMatrix(m.m_nRow,m.m_nCol,m.m_pData) {
//
//}
CMatrix::CMatrix(const char* strPath) {
m_pData = NULL;
m_nRow = m_nCol = 0;
ifstream is(strPath);
is >> *this;
}
CMatrix::~CMatrix() {
Release();
}
bool CMatrix::Create(int nRow, int nCol, double* pData) {
Release();
m_nRow = nRow;
m_nCol = nCol;
//新建空间存储数据
m_pData = new double[nRow * nCol];
//当nRow*nCol数据过大时,m_pData分配空间不足,此时m_pData就会为空
if (m_pData != NULL) {
if (pData!=NULL) {
//void *memcpy(void *destin, void *source, unsigned n);
//作用是:以source指向的地址为起点,将连续的n个字节数据,复制到以destin指向的地址为起点的内存中。
//函数有三个参数,第一个是目标地址,第二个是源地址,第三个是数据长度。
memcpy(m_pData, pData, nRow * nCol * sizeof(double));
}
}
else {
return false;
}
return true;
}
//delete之后赋值为空,delete指针之后只是释放了空间,指针依旧存在且指向原来的地址,此时对该指针的操作都将十分容易报错
void CMatrix::Release() {
if (m_pData!=NULL) {
delete []m_pData;
m_pData = NULL;
}
m_nRow = m_nCol = 0;
}
CMatrix& CMatrix::operator=(const CMatrix& m) {
//判断如果等号左右相同,直接返回,否则会是空,因为Create开头是Release
//等号运算符重载该有的判断
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);
}
//前面无double但是有返回值,因为这是强制类型转换,已经知道返回值就是double
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) {
//m.Release();后面Create开始就有 此处可以省略
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;
//上面的方法效率更高
//os << m.m_nRow << "" << m.m_nCol << endl;
//for (int i = 0; i < m.m_nRow; i++) {
// for (int j = 0; j < m.m_nCol; j++) {
// os << m.m_pData[i * m.m_nCol + j] << " ";
// }
// os << endl;
//}
//return os;
}
二.运行截图
三. 函数
1.1 构造函数
在实际应用中,通常需要给每个类定义构造函数。如果我们不提供构造和析构,编译器会提供编译器提供的构造函数和析构函数是空实现。
构造函数:主要作用在于创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无须手动调用。
析构函数:主要作用在于对象销毁前系统自动调用,执行一些清理工作
构造函数语法:类名(){}
1.构造函数,没有返回值也不写void
2. 函数名称和类名相同
3. 构造函数可以有参数,因此可以发生重载
4. 程序在调用对象时候会自动调用构造,无须手动调用,并且只会调用一次
1.2 析构函数
析构函数语法:~类名(){}
析构函数,没有返回值也不写void
函数名称与类名相同,在名称前加上符号~
析构函数不可以有参数,因此不可以发生重载
程序在对象销毁前会自动调用析构,无须手动调用,并且只会调用一次
构造函数的分类:
两种分类方式:
有参分: 有参构造和无参构造(默认构造)
按类型分: 普通构造和拷贝构造(const Person &p)
拷贝构造函数调用时机:
使用一个已经创建完毕的对象来初始化一个新对象
值传递的方式来给函数参数传值
以值的方式返回局部对象
默认情况下,C++编译器至少给一个类添加3个函数:
默认构造函数(无参,函数体为空)
默认析构函数(无参,函数体为空)
默认拷贝函数,对属性进行值拷贝
CMatrix(int nRow,int nCol,double pData=NULL);该构造函数为带默认参数的构造,在建立对象的时候可省去pData的实参,*pData的默认值为NULL。
1.3 运算符重载
对已有德运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型
本次实验中主要对:
算术运算符重载:+, -, +=, -=,
关系运算符重载:>, <, ==
下标操作符:[], ()
强制类型转换: double
赋值运算符:=,尤其当m1=m1的时候要特殊情况的处理:如果m1=m1,直接返回this如果不是就先Create(m.m_nRow, m.m_nCol, m.m_pData),再返回this。
CMatrix & CMatrix:: operator = (const CMatrix &m)表示一个运算符重载函数,在理解时可将operator和运算符(如operator=)视为一个函数名。
this是指向自身对象的指针,*this是自身对象。也就是说return *this返回的是当前对象的克隆或者本身(若返回类型为A, 则是克隆, 若返回类型为A&, 则是本身 )。return this返回当前对象的地址(指向当前对象的指针)。
CMatrix:: operator double()函数无需指明返回类型,double作为一个运算符,该函数用于double运算符重载
1.4 友元函数
//赋予特权,特殊声明,friend加了之后为全局函数不是成员函数,类里面定义的所有对象都可以调用,所以可以访问下面的private私有变量
//输出输入流运算符重载,原本输出输入流只能针对基础的数据类型,比如char,int,double,指针,重载后使其能够读取自己定义的类
friend istream& operator>>(istream& is, CMatrix& m);
friend ostream& operator<<(ostream& os, const CMatrix& m);
实现类之间数据共享时,减少系统开销,提高效率