重载输入输出运算符的小问题&稀疏矩阵的相乘

最新推荐文章于 2024-10-09 08:36:38 发布
最新推荐文章于 2024-10-09 08:36:38 发布
阅读量122 收藏
点赞数 1
分类专栏： bug 文章标签： 矩阵 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nkhth/article/details/121126155
版权

``

#include<iostream>
#include<ostream>
using namespace std;

template<class T>
class SparseMatrix;

template<class T>
class Term {
	friend SparseMatrix<T>;
public:
	Term(int i, int j, T val) { row = i, col = j, value = val; }
	Term() {}
private:
	int row, col;
	T value;
};

template<class T>
class SparseMatrix {
	//friend ostream& operator<<(ostream&, const SparseMatrix<T>&);
	//friend istream& operator>>(istream&, SparseMatrix<T>&);
public:
	SparseMatrix(int maxterms);
	SparseMatrix(int maxterms, int col, int row);
	//~SparseMatrix();
	void Add(const SparseMatrix<T>&, SparseMatrix<T>&);
	void Append(const Term<T>&);
	void Transposition(SparseMatrix<T>& b);
	void Multiplication(const SparseMatrix<T>&, SparseMatrix<T>&);
	void Output();
private:
	int rows, columns;
	int terms;
	Term<T>* a;
	int Maxterms;
};

template<class T>
void SparseMatrix<T>::Output() {
	cout << "rows=" << rows << " columns=" << columns << " terms=" << terms << endl;
	for (int i = 0; i < terms; i++)
		cout << "a(" << a[i].row << "," << a[i].col << ")=" << a[i].value << endl;
}

/*template<class T>
ostream& operator<<(ostream& out, const SparseMatrix<T>& a) {
	out << "rows=" << a.rows << " columns=" << a.columns << "terms= " << a.terms;
	for (int i = 0; i < a.terms; i++)
		out << "a(" << a.a[i].row << "," << a.a[i].col << ")=" << a.a[i].value << endl;
	return out;
}*/

template<class T>
SparseMatrix<T>::SparseMatrix(int maxterms) {
	if (maxterms <= 0)cout << "wrong";
	Maxterms = maxterms;
	a = new Term<T>[Maxterms];
	terms = 0;
	rows = columns = 0;
}

template<class T>
SparseMatrix<T>::SparseMatrix(int maxterms, int col, int row) {
	if (maxterms <= 0)cout << "wrong";
	Maxterms = maxterms;
	a = new Term<T>[Maxterms];
	terms = 0;
	rows = row, columns = col;
}

template<class T>
void SparseMatrix<T>::Add(const SparseMatrix<T>& x, SparseMatrix<T>& a) {
	int ct = 0, cx = 0;
	a.rows = max(this->rows, x.rows);
	a.columns = max(this->columns, x.columns);
	while (ct < this->terms && cx < x.terms) {
		//计算二者行主次序编号
		int indt = a[ct].row * a.columns + a[ct].col;
		int indx = x.a[cx].row * a.columns + x.a[cx].col;
		//矩阵相加
		if (indt == indx) {
			if (a[ct].value + x.a[cx].value) {
				Term<T> t;
				t.col = a[ct].col;
				t.row = a[ct].row;
				t.value = a[ct].value + x.a[cx].value;
				a.Append(t);
			}
			ct++, cx++;
		}
		else if (indt < indx) {
			a.Append(a[ct++]);
		}
		else {
			a.Append(x.a[cx++]);
		}
	}
	while (ct < this->terms)a.Append(a[ct++]);
	while (cx < x.terms)a.Append(x.a[cx++]);
}

template<class T>
void SparseMatrix<T>::Append(const Term<T>& x) {
	a[terms++] = x;
	rows = max(x.row, rows);
	columns = max(x.col, columns);
}

template<class T>
void SparseMatrix<T>::Transposition(SparseMatrix<T>& b) {
	b.rows = columns;
	b.columns = rows;
	b.terms = terms;

	int* Colsize, * Rownext;
	Colsize = new int[columns + 1];
	Rownext = new int[columns + 1];

	for (int i = 1; i <= columns; i++)Colsize[i] = 0;
	for (int i = 0; i < terms; i++)Colsize[a[i].col]++;
	Rownext[1] = 0;
	for (int i = 2; i <= columns; i++)Rownext[i] = Rownext[i - 1] + Colsize[i - 1];

	for (int i = 0; i < terms; i++) {
		int j = Rownext[a[i].col]++;
		b.a[j].col = a[i].row;
		b.a[j].row = a[i].col;
		b.a[j].value = a[j].value;
	}
}

template<class T>
void SparseMatrix<T>::Multiplication(const SparseMatrix<T>& b, SparseMatrix<T>& c) {
	if (columns != b.rows) {
		cout << "wrong";
		return;
	}

	c.rows = rows;
	c.columns = b.columns;
	c.terms = 0;
	//初始化结果矩阵

	int* rownext, * rownextb;
	int* rowsize, * rowsizeb;
	rownext = new int[rows + 1];
	rownextb = new int[b.rows + 1];
	rowsize = new int[rows + 1];
	rowsizeb = new int[b.rows + 1];
	for (int i = 1; i <= rows; i++)rowsize[i] = 0;
	for (int i = 0; i < terms; i++)rowsize[a[i].row]++;
	rownext[1] = 0;
	for (int i = 2; i <= rows; i++)rownext[i] = rownext[i - 1] + rowsize[i - 1];
	for (int i = 1; i <= b.rows; i++)rowsizeb[i] = 0;
	for (int i = 0; i < b.terms; i++)rowsizeb[b.a[i].row]++;
	rownextb[1] = 0;
	for (int i = 2; i <= b.rows; i++)rownextb[i] = rownextb[i - 1] + rowsizeb[i - 1];
	//计算*this和b矩阵中每行第一个非零元素在一维数组a中的位置

	int* temp = new int[b.columns + 1];//临时存储数据
	for (int i = 1; i <= c.rows; i++) {//遍历第一个矩阵的每一行

		for (int i = 1; i <= b.columns; i++)temp[i] = 0;//每次循环都清零

		int p;
		if (i < c.rows)p = rownext[i + 1];
		else p = terms;

		for (int j = rownext[i]; j < p; j++) {//处理第一个矩阵中第i行的每一个非零元素,结果为最终矩阵的第i行
			int coll;
			if (a[j].col < b.rows)coll = rownextb[a[j].col + 1];
			else coll = b.terms;

			for (int k = rownextb[a[j].col]; k < coll; k++) {//遍历第一个非零元素对应列的第二个矩阵的行
				int pos = b.a[k].col;
				temp[pos] += a[j].value * b.a[k].value;
			}
		}

		for (int t = 1; t <= b.columns; t++)
			if (temp[t]) {
				Term<T> x;
				x.col = t, x.row = i;
				x.value = temp[t];
				c.Append(x);
			}
	}

}

int main() {
	SparseMatrix<int> a(100), b(100), c(100);
	int am, an, bm, bn, terms;
	cin >> am >> an >> terms;
	int i, j, value;
	for (int t = 0; t < terms; t++) {
		cin >> i >> j >> value;
		Term<int> x(i, j, value);
		a.Append(x);
	}
	cin >> bm >> bn >> terms;
	for (int t = 0; t < terms; t++) {
		cin >> i >> j >> value;
		Term<int> x(i, j, value);
		b.Append(x);
	}

	//cout<<a<<b<<c;
	a.Multiplication(b, c);
	a.Output();
	b.Output();
	c.Output();
}

源代码如上，实现的功能是稀疏矩阵的相乘，但是一直给我报错，错误报在输出运算符的重载，但是自己看了半天也没看出来啥错，没办法，只能另写output把作业给交了。
事后再看，最终发现了问题，改进代码如下：

#include<iostream>
#include<ostream>
using namespace std;

template<class T>
class SparseMatrix;

template<class T>
class Term {
	friend SparseMatrix<T>;
	template<class TT>friend ostream& operator<<(ostream&, const SparseMatrix<TT>&);
public:
	Term(int i, int j, T val) { row = i, col = j, value = val; }
	Term() {}
private:
	int row, col;
	T value;
};

template<class T>
class SparseMatrix {
	template<class TT>friend ostream& operator<<(ostream&, const SparseMatrix<TT>&);
	//friend istream& operator>>(istream&, SparseMatrix<T>&);
public:
	SparseMatrix(int maxterms);
	SparseMatrix(int maxterms, int col, int row);
	//~SparseMatrix();
	void Add(const SparseMatrix<T>&, SparseMatrix<T>&);
	void Append(const Term<T>&);
	void Transposition(SparseMatrix<T>& b);
	void Multiplication(const SparseMatrix<T>&, SparseMatrix<T>&);
private:
	int rows, columns;
	int terms;
	Term<T>* a;
	int Maxterms;
};

template<class T>
ostream& operator<<(ostream& out, const SparseMatrix<T>& a) {
	out << "rows=" << a.rows << " columns=" << a.columns << "terms= " << a.terms;
	for (int i = 0; i < a.terms; i++)
		out << "a(" << a.a[i].row << "," << a.a[i].col << ")=" << a.a[i].value << endl;
	return out;
}

template<class T>
SparseMatrix<T>::SparseMatrix(int maxterms) {
	if (maxterms <= 0)cout << "wrong";
	Maxterms = maxterms;
	a = new Term<T>[Maxterms];
	terms = 0;
	rows = columns = 0;
}

template<class T>
SparseMatrix<T>::SparseMatrix(int maxterms, int col, int row) {
	if (maxterms <= 0)cout << "wrong";
	Maxterms = maxterms;
	a = new Term<T>[Maxterms];
	terms = 0;
	rows = row, columns = col;
}

template<class T>
void SparseMatrix<T>::Add(const SparseMatrix<T>& x, SparseMatrix<T>& a) {
	int ct = 0, cx = 0;
	a.rows = max(this->rows, x.rows);
	a.columns = max(this->columns, x.columns);
	while (ct < this->terms && cx < x.terms) {
		//计算二者行主次序编号
		int indt = a[ct].row * a.columns + a[ct].col;
		int indx = x.a[cx].row * a.columns + x.a[cx].col;
		//矩阵相加
		if (indt == indx) {
			if (a[ct].value + x.a[cx].value) {
				Term<T> t;
				t.col = a[ct].col;
				t.row = a[ct].row;
				t.value = a[ct].value + x.a[cx].value;
				a.Append(t);
			}
			ct++, cx++;
		}
		else if (indt < indx) {
			a.Append(a[ct++]);
		}
		else {
			a.Append(x.a[cx++]);
		}
	}
	while (ct < this->terms)a.Append(a[ct++]);
	while (cx < x.terms)a.Append(x.a[cx++]);
}

template<class T>
void SparseMatrix<T>::Append(const Term<T>& x) {
	a[terms++] = x;
	rows = max(x.row, rows);
	columns = max(x.col, columns);
}

template<class T>
void SparseMatrix<T>::Transposition(SparseMatrix<T>& b) {
	b.rows = columns;
	b.columns = rows;
	b.terms = terms;

	int* Colsize, * Rownext;
	Colsize = new int[columns + 1];
	Rownext = new int[columns + 1];

	for (int i = 1; i <= columns; i++)Colsize[i] = 0;
	for (int i = 0; i < terms; i++)Colsize[a[i].col]++;
	Rownext[1] = 0;
	for (int i = 2; i <= columns; i++)Rownext[i] = Rownext[i - 1] + Colsize[i - 1];

	for (int i = 0; i < terms; i++) {
		int j = Rownext[a[i].col]++;
		b.a[j].col = a[i].row;
		b.a[j].row = a[i].col;
		b.a[j].value = a[j].value;
	}
}

template<class T>
void SparseMatrix<T>::Multiplication(const SparseMatrix<T>& b, SparseMatrix<T>& c) {
	if (columns != b.rows) {
		cout << "wrong";
		return;
	}

	c.rows = rows;
	c.columns = b.columns;
	c.terms = 0;
	//初始化结果矩阵

	int* rownext, * rownextb;
	int* rowsize, * rowsizeb;
	rownext = new int[rows + 1];
	rownextb = new int[b.rows + 1];
	rowsize = new int[rows + 1];
	rowsizeb = new int[b.rows + 1];
	for (int i = 1; i <= rows; i++)rowsize[i] = 0;
	for (int i = 0; i < terms; i++)rowsize[a[i].row]++;
	rownext[1] = 0;
	for (int i = 2; i <= rows; i++)rownext[i] = rownext[i - 1] + rowsize[i - 1];
	for (int i = 1; i <= b.rows; i++)rowsizeb[i] = 0;
	for (int i = 0; i < b.terms; i++)rowsizeb[b.a[i].row]++;
	rownextb[1] = 0;
	for (int i = 2; i <= b.rows; i++)rownextb[i] = rownextb[i - 1] + rowsizeb[i - 1];
	//计算*this和b矩阵中每行第一个非零元素在一维数组a中的位置

	int* temp = new int[b.columns + 1];//临时存储数据
	for (int i = 1; i <= c.rows; i++) {//遍历第一个矩阵的每一行

		for (int i = 1; i <= b.columns; i++)temp[i] = 0;//每次循环都清零

		int p;
		if (i < c.rows)p = rownext[i + 1];
		else p = terms;

		for (int j = rownext[i]; j < p; j++) {//处理第一个矩阵中第i行的每一个非零元素,结果为最终矩阵的第i行
			int coll;
			if (a[j].col < b.rows)coll = rownextb[a[j].col + 1];
			else coll = b.terms;

			for (int k = rownextb[a[j].col]; k < coll; k++) {//遍历第一个非零元素对应列的第二个矩阵的行
				int pos = b.a[k].col;
				temp[pos] += a[j].value * b.a[k].value;
			}
		}

		for (int t = 1; t <= b.columns; t++)
			if (temp[t]) {
				Term<T> x;
				x.col = t, x.row = i;
				x.value = temp[t];
				c.Append(x);
			}
	}

}

int main() {
	SparseMatrix<int> a(100), b(100), c(100);
	int am, an, bm, bn, terms;
	cin >> am >> an >> terms;
	int i, j, value;
	for (int t = 0; t < terms; t++) {
		cin >> i >> j >> value;
		Term<int> x(i, j, value);
		a.Append(x);
	}
	cin >> bm >> bn >> terms;
	for (int t = 0; t < terms; t++) {
		cin >> i >> j >> value;
		Term<int> x(i, j, value);
		b.Append(x);
	}

	a.Multiplication(b, c);
	cout << a << b << c;
}

对比两次的代码，有几个改动
1.重载输出运算符在类内的声明将模板类改成了与类所用模板类不同的名称，应该是因为如果都用class T的话，编译器会混淆。
2.忘记把重载函数声明为Term类的友元，无法访问其私有成员。

翩若惊鸿_
关注
专栏目录
C++小例子——02 矩阵类myMatrix
meiguanhua的博客
06-19 1302
再来一个矩阵类myVector，这是最普遍意义上的矩阵，并不是特殊的对称矩阵、对角矩阵、稀疏矩阵……。成员函数只有四个，即行维数、列维数、总体元素数目、还有double指针用于动态申请释放内存来存储矩阵。构造函数可用行数列数和元素值构造（矩阵中元素都是同一个值），也可用另一个矩阵来做复制构造（Copy constructor），析构函数中释放内存空间。重载赋值符=，用于两矩阵间的赋值操作，重载操作符()用于引用矩阵的(i,j)位置的元素，重载输入流>>用于从键盘给矩阵赋值，重载输出流>>用于输出矩阵……
Problem H: 稀疏矩阵的表示和运算
Usher_Ou的博客
05-04 2644
Problem H: 稀疏矩阵的表示和运算 Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 155  Solved: 49 [Submit][Status][Web Board] Description 如果一个矩阵中，0元素占据了矩阵的大部分，那么这个矩阵称为“稀疏矩阵”。对于稀疏矩阵，传统的二维数组存储方式，会使用大量的内存来存
稀疏矩阵及其转置
Reyes Yang's Utopia
10-23 1973
  *************************************************SparseMatrix.h***********************************************#include using namespace std;const int maxNum=100;template class Trituple{publ
稀疏矩阵的基本运算
zutuan5的专栏
11-19 849
<br />#include <stdio.h> #define M 4 #define N 4 typedef int ElemType; #define MaxSize 100 //矩阵中非零元素最多个数 #include"D:/三元组.cpp" int value(TSMatrix c,int i,int j) //返回指定位置元素的值 { int k=0; while (k<c.nums && (c.data[k].r!=i || c.dat
priority_queue的重载运算符原理
QiaoRuoZhuo的专栏
03-02 2058
#include using namespace std; (记得包含头文件噢)   1.  priority_queue在STL内部定义的原型是：       template                     class Sequence=vector ,                     classCompare=less > （主要，要一个空格，否则编译器会当做右
稀疏矩阵课程设计实验报告
07-11
- **输出**：同样通过重载`运算符，将稀疏矩阵的非零元素输出到输出流中。 - **转置**：利用矩阵的性质，转置操作可以将原矩阵的行变成列，列变成行。在稀疏矩阵中，只需要改变三元组的行和列即可完成转置。 - **...
稀疏矩阵的C++实现--课程设计
06-29
此外，为了便于输出和调试，还需要重载`运算符，以便用C++的流式输出轻松打印稀疏矩阵。 ```cpp friend ostream& operator(ostream& os, const SparseMatrix& A) { // ...输出矩阵的非零元素... } ``` 在课程设计...
数据结构稀疏矩阵实验报告
11-14
总的来说，这个实验报告详细介绍了如何使用三元组单链表存储稀疏矩阵，并通过重载运算符实现了基本的矩阵运算，包括输入输出、转置、加法、减法、乘法以及求逆。通过这些操作，可以高效地处理和操作大规模的稀疏矩阵...
MultSMatrix中的矩阵相乘操作代码
09-19
在MultSMatrix库中，矩阵相乘通常是通过矩阵运算符...在这个例子中，`operator*`是一个重载运算符，用于将当前矩阵A与另一个矩阵B相乘。注意，这只是基本的概念，实际的实现可能会根据矩阵的特性（如稀疏性）进行优化。
三元组表示的稀疏矩阵的加法和乘法
热门推荐
雪夕阳
08-13 1万+
#include  #include  //函数结果状态码 #define OK        1 #define ERROR     0 #define OVERFLOW -1  //Status是函数的类型，其值是函数结果状态代码 typedef int Status; // ----- 稀疏矩阵的三元组顺序表存储表示 ----- #define MAXSIZE 100            
稀疏矩阵的运算
凡尘
04-26 3782
内容 假设两个稀疏矩阵A和B，他们均为m行n列，要求表写求矩阵的加法即：C=A+B的算法（C矩阵存储A与B相加的结果） 分析 利用一维数组来存储，一维数组顺序存放非零元素的行号、列号和数值，行号-1表示结束，然后进行矩阵加法运算时依次扫描矩阵A和B的行列值，并以行优先。当行列相同的时候，将第三个元素的值相加和以及行列号三个元素存入结果数组C中；不相同时，将A或B的三个元素直接存入结果数组...
稀疏矩阵的存储以及转置、加法、乘法操作实现
Curya的博客
09-09 3498
稀疏矩阵的存储以及转置、加法、乘法操作实现
稀疏矩阵的输入与输出
air的专栏
12-04 5204
 #include#include#define LEN sizeof(struct juzhen)#define NULL 0struct juzhen{    int h,l;    int num;    struct juzhen*next;    struct juzhen*below;};int n,hmax,lmax;struct juzhen*creat(void){   
矩阵消元的LU分解——解法及为什么这样做
全机房最蒟蒻的博客
10-06 796
逐步分析矩阵的LU分解如何计算，并举例描述了为什么选择LU分解能够简化计算
python 实现graph matrix图矩阵算法
最新发布
luthane的博客
10-09 490
Graph Matrix（图矩阵）算法主要用于表示和处理图结构中的数据，尤其是在计算机科学和数学中。图矩阵通常指的是图的邻接矩阵（Adjacency Matrix），它是一种用矩阵表示图中顶点之间相邻关系的方法。邻接矩阵邻接矩阵是一个二维数组（或矩阵），其行和列都表示图中的顶点。对于无向图，如果顶点i和顶点j之间存在边，则矩阵中对应位置（i, j）和（j, i）的元素都为1（或边的权重，如果图是有权重的）。对于有向图，则只有从顶点i到顶点j的边存在时，（i, j）位置的元素才为1（或权重）。
以矩阵的视角解多元一次方程组——矩阵消元
全机房最蒟蒻的博客
10-01 1000
由普通消元方法引入到矩阵消元
重载输入输出运算符
05-27
重载输入输出运算符是C++中的一个重要特性，可以让自定义的类支持像标准库中的类一样使用输入输出运算符。重载输入运算符可以让用户从标准输入流中读取数据并初始化对象的属性，而重载输出运算符则可以让用户将对象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值