Question

C++编程：矩阵类中的运算符重载 发到邮箱987354117@qq.com

设计一个矩阵类，要求矩阵类中重载运算符加（＋）和赋值（＝），主函数定义类对象并调用重载的运算符。

提示： (1) 本题考虑可加（即加与被加矩阵的行列数必须分别相等）和可赋值（等号左值和右值的行列数必须分别相等）情况，其他情况输出 “ program terminated! ”
(2) 要求分别输入矩阵 am 和 bm 的行列数，各矩阵元素，分别计算 cm=am+bm;am=bm; 并进行输出
(3) 定义相应的构造函数和析构函数
(4) 类中的成员变量应当有三个： int row,col; 分别表示矩阵的行数和列数，另外还需要定义一个一级指针m用来申请动态空间，存放 row*col 个整数

（ 5 ）程序最前面的文件包含提交到系统中请用下面代码：

#include <iostream>
using namespace std;
#include <stdlib.h>

但是在VC++环境下本地测试时,如果你的程序中用到了友元,则要将头文件用下面的代码(提交时再修改为上面的三行):

#include <iostream.h>
#include <stdlib.h>

即本地调试运行正确无误后,再将头文件部分改掉提交!

(6) 请根据提供的主函数，给出相应的类定义和函数定义。
int main()
{
int row_a,col_a,row_b,col_b;
cout<<"请输入am矩阵的行数和列数:";
cin>>row_a>>col_a;
Matrix am(row_a,col_a);
cout<<"请输入bm矩阵的行数和列数:";
cin>>row_b>>col_b;
Matrix bm(row_b,col_b),cm;
cout<<"am:"<<endl;
am.disp();
cout<<"bm:"<<endl;
bm.disp();
cm=am+bm;
cout<<"cm=am+bm:"<<endl;
cm.disp();
am=bm;
cout<<"am=bm:"<<endl;
am.disp();
return 0;
}

(7) 类的成员函数 disp 的代码如下：

void Matrix::disp()

{

for(int i=0;i<row;i++)

{

cout<<'\t';

for(int j=0;j<col;j++)

cout<<*(m+i*col+j)<<'\t';

cout<<endl;

}

}

（ 8 ）测试用例及结果（以下有 < 回车 > 字样的行内容为用户输入）：

第一个测试用例：

请输入am矩阵的行数和列数:

3 3< 回车 >
请输入该矩阵元素:

1 2 3 4 5 6 7 8 9< 回车 >
请输入bm矩阵的行数和列数:

3 3< 回车 >
请输入该矩阵元素:

9 8 7 6 5 4 3 2 1< 回车 >
am:
1 2 3
4 5 6
7 8 9
bm:
9 8 7
6 5 4
3 2 1
cm=am+bm:
10 10 10
10 10 10
10 10 10
am=bm:
9 8 7
6 5 4
3 2 1

Answer 1

#ifndef VECTOR_H_
#define VECTOR_H_
#include<iostream>
template<class Type>
class vector
{
public:
class iterator
{
public:
friend class vector<Type>;
iterator():curptr(NULL) {}
iterator(Type* cur):curptr(cur) {}
bool operator==(iterator temp) { return this->curptr==temp.curptr; }
bool operator!=(iterator temp) { return !(this->curptr==temp.curptr); }
iterator operator++() { curptr++; return *this; }
iterator operator++(int) { iterator temp=*this; curptr++; return temp; }
iterator operator+(int n)
{ for(int i=0;i<n;i++) curptr++; return *this; }
Type& operator*() { return *curptr; }
private:
Type* curptr;
};
vector():size(0),capacity(0) { elem=NULL; }
vector(int n);
vector(const vector<Type>& v);
vector<Type>& operator=(const vector<Type>& v);
void push_back(const Type& t);
void pop_back() { size--; }
void insert(iterator pos,const Type& t);
void erase(iterator pos);
void erase(iterator pos1,iterator pos2);
void clear() { size=0; }
bool IsEmputy() { return size==0; }
bool IsFull() { return size==capacity; }
void reserve(int n);
iterator begin() { return elem; }
iterator end() { return elem+size; }
Type& operator[](int i) { return elem[i]; }
~vector() { delete []elem; }
private:
Type* elem;
int size,capacity;
};
#endif
template<class Type>
vector<Type>::vector(int n)
{
size=capacity=n;
elem=new Type[capacity];
for(int i=0;i<size;i++) elem[i]=0;
}
template<class Type>
vector<Type>::vector(const vector<Type>& v)
{
size=v.size; capacity=v.capacity;
elem=new Type[capacity];
for(int i=0;i<size;i++) elem[i]=v.elem[i];
}
template<class Type>
vector<Type>& vector<Type>::operator=(const vector<Type>& v)
{
if(this==&v) return *this;
if(capacity!=v.capacity)
{
delete []elem;
capacity=v.capacity;
elem=new Type[capacity];
}
size=v.size;
for(int i=0;i<size;i++) elem[i]=v.elem[i];
return *this;
}
template<class Type>
void vector<Type>::reserve(int n)
{
Type* temp=elem;
elem=new Type[n];
int m=n>size?size:n;
size=m; capacity=n;
for(int i=0;i<m;i++) elem[i]=temp[i];
delete []temp;
}
template<class Type>
void vector<Type>::push_back(const Type& t)
{
if(IsFull())
{
if(capacity==0) reserve(2);
else reserve(2*capacity);
}
elem[size++]=t;
}
template<class Type>
void vector<Type>::insert(vector<Type>::iterator pos,const Type& t)
{
int n=0;
for(Type* p=elem;p<=pos.curptr;p++) n++;
if(IsFull())
{
if(capacity==0) reserve(2);
else reserve(2*capacity);
}
Type* temp=elem;
for(int j=1;j<n;j++) temp++;
for(Type* i=elem+size;i!=temp;i--)
*i=*(i-1);
*temp=t;
size++;
}
template<class Type>
void vector<Type>::erase(vector<Type>::iterator pos)
{
Type* temp=pos.curptr;
for(Type* i=temp;i<elem+size-2;i++)
*i=*(i+1);
size--;
}
template<class Type>
void vector<Type>::erase(vector<Type>::iterator pos1,vector<Type>::iterator pos2)
{
Type* p=pos1.curptr;
Type* q=pos2.curptr;
for(Type* i=q;i<elem+size;i++)
{
*p=*i; p++;
}
for(p=pos1.curptr;p<pos2.curptr;p++) size--;
}

这上面是自己写的容器

#include"vector.h"
#include<cstdlib>
template<class Type>class Sparse;
template<class Type>
class Term
{
public:
friend class Sparse<Type>;
Term() {}
Term(int r,int c,const Type& v);
friend std::istream& operator>>(std::istream& is,Term<Type>& t);
public:
int row,col;
Type value;
int no;
};
template<class Type>
Term<Type>::Term(int r,int c,const Type& v)
{
row=r; col=c; value=v; no=0;
}
template<class Type>
std::istream& operator>>(std::istream& is,Term<Type>& t)
{
std::cout<<"row ,col and value:\n";
is>>t.row>>t.col>>t.value;
return is;
}
/*
*/
//
template<class Type>
class Sparse
{
public:
friend class Term<Type>;
Sparse() {}
Sparse(const Sparse<Type>& s);
void sort();
friend std::istream& operator>>(std::istream& is,Sparse<Type>& s);
friend std::ostream& operator<<(std::ostream& os,Sparse<Type>& s);
friend Sparse<Type> operator+(Sparse<Type>& s1,Sparse<Type>& s2);
friend Sparse<Type> operator*(Sparse<Type>& s1,Sparse<Type>& s2);
Sparse<Type> transpose();
private:
int rows,cols;
int terms;
vector<Term<Type> > vec;
};

//
template<class Type>
void Sparse<Type>::sort()
{
for(int i=0;i<terms;i++) vec[i].no=vec[i].row*cols+vec[i].col;
Term<Type> temp;
int flag=1;
for(i=1;i<terms&&flag;i++)
{
flag=0;
for(int j=0;j<terms-i;j++)
{
if(vec[j].no>vec[j+1].no)
{
flag=1; temp=vec[j];
vec[j]=vec[j+1]; vec[j+1]=temp;
}
}
}
}
template<class Type>
std::istream& operator>>(std::istream& is,Sparse<Type>& s)
{
std::cout<<"please input rows,cols and terms:\n";
is>>s.rows>>s.cols>>s.terms;
Term<Type> temp;
for(int i=0;i<s.terms;i++)
{
is>>temp; s.vec.push_back(temp);
}
return is;
}
template<class Type>
std::ostream& operator<<(std::ostream& os,Sparse<Type>& s)
{
s.sort(); int m=0;
Type* temp=new Type[s.cols+1];
while(m<s.terms)
{
for(int i=1;i<=s.rows;i++)
{
for(int k=1;k<=s.cols;k++) temp[k]=0;
if(s.vec[m].row==i)
{
temp[s.vec[m].col]=s.vec[m].value;
m++;
}
for(k=1;k<=s.cols;k++) std::cout<<temp[k]<<'\t';
std::cout<<std::endl;
}
}
delete []temp;
return os;
}
template<class Type>
Sparse<Type>::Sparse(const Sparse<Type>& s)
{
rows=s.rows; cols=s.cols;
terms=s.terms;
vec=s.vec;
}
template<class Type>
Sparse<Type> Sparse<Type>::transpose()
{
Sparse<Type> s;
Term<Type> temp;
for(int i=0;i<terms;i++)
{
temp.row=vec[i].col;
temp.col=vec[i].row;
temp.value=vec[i].value;
s.vec.push_back(temp);
}
s.rows=cols; s.cols=rows; s.terms=terms;
return s;
}
template<class Type>
Sparse<Type> operator+(Sparse<Type>& s1,Sparse<Type>& s2)
{
Sparse<Type> s; s.terms=0;
s.rows=s1.rows; s.cols=s1.cols;
int m1=0,m2=0;
s1.sort(); s2.sort();
if(s1.rows==s2.rows && s1.cols==s2.cols)
{
std::cout<<"sdfas";
while(m1<s1.terms && m2<s2.terms)
{
if(s1.vec[m1].no<s2.vec[m2].no)
{
s.vec.push_back(s1.vec[m1]);
m1++; s.terms++;
}
else if(s1.vec[m1].no>s2.vec[m2].no)
{
s.vec.push_back(s2.vec[m2]);
m2++; s.terms++;
}
else
{
Type value=s1.vec[m1].value+s2.vec[m2].value;
if(value)
{
s.vec.push_back(Term<Type>(s1.vec[m1].row,s1.vec[m1].col,value));
m1++; m2++; s.terms++;
}
}
}
while(m1<s1.terms)
{
s.vec.push_back(s1.vec[m1]); m1++; s.terms++;
}
while(m2<s2.terms)
{
s.vec.push_back(s2.vec[m2]); m2++; s.terms++;
}
}
return s;
}
/*
template<class Type>
Sparse<Type> operator*(Sparse<Type>& s1,Sparse<Type>& s2)
{
Sparse<Type> s; s.rows=s1.rows;
s.cols=s2.cols; s.terms=0;
s1.sort();
Sparse<Type> s22=s2.transpose();
s22.sort();
int m1=0,m2=0;
if(s1.cols==s2.rows)
{
while(m1<s1.terms && m2<s22.terms)
{
if(s1.vec[m1].row<s2.vec[m2].row) m1++;
else if(s1.vec[m1].row>s2.vec[m2].row) m2++;
else
{
}
}
}
}
*/

下面是用自己写的容器vector实现的，如果你要用系统的容器，差不多的。

Answer 2

哇哦 你这问题好深奥 我是根本看不懂