各位大佬，帮忙看看。就是我的multi函数进入第一个for循环之后程序就崩了，不知道为什么。请各位帮忙看看，谢谢啦

[tang-coder]

#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
template<class T>
class arraylist
{
public:
arraylist(int intialcapacity=10);
arraylist(const arraylist<T>&);
~arraylist() {
delete [] element;
}
void changelength1d(T*& a,int oldlength,int newlength)
{
T* temp=new T[newlength];
int number=min(oldlength,newlength);
copy(a,a+number,temp);
delete [] a;
a=temp;
}
bool empty() const {return listsize==0;}
int size() const {return listsize;}
T& get(int theindex) const;
int indexof(const T& theelement) const;
void erase(int theindex);
void insert(int theindex,const T& theelement);
void output(ostream& out) const;
void clear()
{
listsize=0;
}
void reset(int newsize)
{
listsize=newsize;
if(listsize>arraylength)
{
arraylength=newsize;
delete [] element;
element=new T[arraylength];
}
}
void set(int theindex,const T& theelement);
void copymatrix(const arraylist<T>& terms);
class iterator
{
public:
typedef bidirectional_iterator_tag iterator_category;
typedef T value_type;
typedef ptrdiff_t difference_type;
typedef T* pointer;
typedef T& reference;
iterator(T* theposition=0){
position=theposition;
}
T& operator*() const {
return *position;
}
T* operator->() const {return &*position;}
iterator& operator++()
{
++position;return *this;
}
iterator operator++(int)
{
iterator old=*this;
++position;
return old;
}
iterator& operator--()
{
--position;return *this;
}
iterator operator--(int)
{
iterator old=*this;
--position;
return old;
}
iterator operator+(int n)
{
iterator old=*this;
return old+=n;
}
iterator& operator+=(int n)
{
position=position+n;
return *this;
}
iterator operator-(int n)
{
iterator old=*this;
return old-=n;
}
iterator& operator-=(int n)
{
position=position-n;
return *this;
}
bool operator!=(const iterator right) const
{
return position!=right.position;
}
bool operator==(const iterator right) const
{
return position==right.position;
}
protected:
T* position;
};
iterator begin() {return iterator(element);}
iterator end() {return iterator(element+listsize);}
protected:
T* element;
int arraylength;
int listsize;
};
template<class T>
arraylist<T>::arraylist(int initialcapacity)
{
if(initialcapacity<1)
return;
arraylength=initialcapacity;
element=new T[arraylength];
listsize=0;
}
template<class T>
arraylist<T>::arraylist(const arraylist<T>& thelist)
{
arraylength=thelist.arraylength;
listsize=thelist.listsize;
element=new T[arraylength];
copy(thelist.element,thelist.element+listsize,element);
}
template<class T>
void arraylist<T>::insert(int theindex,const T& theelement)
{
if(theindex<0||theindex>listsize)
return;
if(listsize==arraylength)
{
changelength1d(element,arraylength,2*arraylength);
arraylength*=2;
}
copy_backward(element+theindex,element+listsize,element+listsize+1);
element[theindex]=theelement;
listsize++;
}
template<class T>
void arraylist<T>::set(int theindex,const T& theelement)
{
element[theindex]=theelement;
listsize++;
}
template<class T>
void arraylist<T>::copymatrix(const arraylist<T>& thelist)
{
arraylength=thelist.arraylength;
listsize=thelist.listsize;
delete [] element;
element=new T[arraylength];
copy(thelist.element,thelist.element+listsize,element);
}
template<class T>
struct matrixterm
{
public:
int row;
int col;
T value;
};
template<class T>
class sparsematrix
{
public:
void transpose(sparsematrix<T> &b);
void add(sparsematrix<T> &b,sparsematrix<T> &c);
void multi(sparsematrix<T> &b,sparsematrix<T> &c);
int rows,cols;
arraylist<matrixterm<T> > terms;
};
template<class T>
void sparsematrix<T>::add(sparsematrix<T> &b,sparsematrix<T> &c)
{
if(rows!=b.rows||cols!=b.cols)
return;
c.rows=rows;
c.cols=cols;
c.terms.clear();
int csize=0;
typename arraylist<matrixterm<T> >::iterator it=terms.begin();
typename arraylist<matrixterm<T> >::iterator ib=b.terms.begin();
typename arraylist<matrixterm<T> >::iterator itend=terms.end();
typename arraylist<matrixterm<T> >::iterator ibend=b.terms.end();
while(it!=itend&&ib!=ibend)
{
int tindex=(*it).row*cols+(*it).col;
int bindex=(*ib).row*cols+(*ib).col;
if(tindex<bindex)
{
c.terms.insert(csize++,*it);
it++;
}
else
{
if(tindex==bindex)
{
if((*it).value+(*ib).value!=0)
{
matrixterm<T> mterm;
mterm.row=(*it).row;
mterm.col=(*it).col;
mterm.value=(*it).value+(*ib).value;
c.terms.insert(csize++,mterm);
}
it++;
ib++;
}
else
{
c.terms.insert(csize++,*ib);
ib++;
}
}
}
for(;it!=itend;it++)
c.terms.insert(csize++,*it);
for(;ib!=ibend;ib++)
c.terms.insert(csize++,*ib);
}
template<class T>
void sparsematrix<T>::transpose(sparsematrix<T> &b)
{
b.cols=rows;
b.rows=cols;
b.terms.reset(terms.size());
int* colsize=new int[cols+1];
int* rownext=new int[cols+1];
for(int i=1;i<=cols;i++)
colsize[i]=0;
for(typename arraylist<matrixterm<T> >::iterator i=terms.begin();i!=terms.end();i++)
colsize[(*i).col]++;
rownext[1]=0;
for(int i=2;i<=cols;i++)
rownext[i]=rownext[i-1]+colsize[i-1];
matrixterm<T> mterm;
for(typename arraylist<matrixterm<T> >::iterator i=terms.begin();i!=terms.end();i++)
{
int j=rownext[(*i).col]++;
mterm.row=(*i).col;
mterm.col=(*i).row;
mterm.value=(*i).value;
b.terms.set(j,mterm);
}
}
template<class T>
void sparsematrix<T>::multi(sparsematrix<T> &b,sparsematrix<T> &c)
{
c.rows=rows;
c.cols=b.rows;
int csize=0;

int** m=new int*[rows];
for(int i=0;i<rows;i++)
m[i]=new int[cols];
int** n=new int*[b.rows];
for(int i=0;i<b.rows;i++)
n[i]=new int[b.cols];
typename arraylist<matrixterm<T> >::iterator it=terms.begin();
typename arraylist<matrixterm<T> >::iterator ib=b.terms.begin();
for(int i=1;i<=rows;i++)
{
for(int j=1;j<=cols;j++)
{
if((i*cols+j)==((*it).row*cols+(*it).col))
{
m[i][j]=(*it).value;
if(it!=terms.end())
it++;
}
else
m[i][j]=0;
}
}
for(int i=1;i<=b.rows;i++)
{
for(int j=1;j<=b.cols;j++)
{
if((i*b.cols+j)==((*ib).row*b.cols+(*ib).col))
{
n[i][j]=(*ib).value;
if(ib!=b.terms.end())
ib++;
}
else
n[i][j]=0;
}

}

for(int i=1;i<=rows;i++)
{
for(int j=1;j<=b.cols;j++)
{
int sum=0;
for(int k=1;k<=cols;k++)
{
if(m[i][k]!=0&&n[j][k]!=0)
{
sum+=m[i][k]*n[j][k];
}
}
matrixterm<T> mterm;
mterm.row=i;
mterm.col=j;
mterm.value=sum;
c.terms.insert(csize++,mterm);
}
}
for(int i=0;i<rows;i++)
delete []m[i];
delete []m;
for(int i=0;i<b.rows;i++)
delete []n[i];
delete []n;
}
int main()
{
int row1,col1,row2,col2,n,num,p,asize,bsize;
sparsematrix<int> a;
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>num;
switch(num)
{
case(1):
{
sparsematrix<int> a1;
asize=0;
cin>>row1;
cin>>col1;
a1.rows=row1;
a1.cols=col1;
for(int i=1;i<=row1;i++)
{
for(int j=1;j<=col1;j++)
{
cin>>p;
if(p!=0)
{
matrixterm<int> mterm1;
mterm1.row=i;
mterm1.col=j;
mterm1.value=p;
a1.terms.insert(asize++,mterm1);
}
}
}
a.rows=a1.rows;
a.cols=a1.cols;
a.terms.copymatrix(a1.terms);
break;
}
case(2):
{
sparsematrix<int> b;
sparsematrix<int> d;
bsize=0;
cin>>row2;
cin>>col2;
b.rows=row2;
b.cols=col2;
for(int i=1;i<=row2;i++)
{
for(int j=1;j<=col2;j++)
{
cin>>p;
if(p!=0)
{

matrixterm<int> mterm2;
mterm2.row=i;
mterm2.col=j;
mterm2.value=p;
b.terms.insert(bsize++,mterm2);
}
}
}
if(a.cols!=b.rows)
{
a.rows=b.rows;
a.cols=b.cols;
cout<<-1<<endl;
a.terms.copymatrix(b.terms);
}
else
{
sparsematrix<int> b1;
b.transpose(b1);
a.multi(b1,d);
a.rows=d.rows;
a.cols=d.cols;
a.terms.copymatrix(d.terms);
}
break;
}
case(3):
{
sparsematrix<int> b;
sparsematrix<int> c;
bsize=0;
cin>>row2;
cin>>col2;
b.rows=row2;
b.cols=col2;
for(int i=1;i<=row2;i++)
{
for(int j=1;j<=col2;j++)
{
cin>>p;
if(p!=0)
{

matrixterm<int> mterm2;
mterm2.row=i;
mterm2.col=j;
mterm2.value=p;
b.terms.insert(bsize++,mterm2);
}
}
}
if(a.rows!=b.rows||a.cols!=b.cols)
{
a.rows=b.rows;
a.cols=b.cols;
cout<<-1<<endl;
a.terms.copymatrix(b.terms);
}
else
{
a.add(b,c);
a.rows=c.rows;
a.cols=c.cols;
a.terms.copymatrix(c.terms);
}
break;
}
case(4):
{
typename arraylist<matrixterm

[tang-coder]