how to release memory in the use of orthogonal list

EDN Admin · Oct 3, 2011

HI
Anyone can help me to debug the following c++ code. when the sub program iteratively, the memory is going up. In the program, orthogonal list is used.

The main.cpp
#include <iostream> 
#include "stdlib.h" 
#include "stdio.h" 
#include "string.h" 
#include "Sparsematrix.h" 
#include "math.h"
 
void testt() 
{ 
int *Maxa, *Mht ; 
int ip, idf, Neq, Nwk; 
int i, j, k, l, kk; 
 
int *Leq ; 
double *For; 
int **Ifp; 
int **Lm; 
int NPoin=2541, NElem=2000; 
int Ndf=3, Nnd=8;
Ifp = new int*[NPoin]; 
for (i=0; i<NPoin; i++) 
Ifp = new int[Ndf] ;
for (i=0; i<NPoin; i++) 
{ 
for(j=0; j<Ndf; j++) 
Ifp[j] = 0; 
}
Lm = new int*[NElem] ; 
for (i=0; i<NElem; i++) 
{ 
Lm = new int[Nnd*Ndf] ;
for (j=0; j<Nnd*Ndf; j++) 
Lm[j] = 0; 
} 
 
Neq = 0; 
for (ip=0; ip<NPoin; ip++) 
{ 
for (idf=0; idf<Ndf; idf++ ) 
{ 
if ( Ifp[ip][idf] == 0 ) 
{ 
Neq ++ ; 
Ifp[ip][idf] = Neq ; 
} 
else 
Ifp[ip][idf] = 0 ; 
} 
} 
 
Maxa = new int[Neq+1] ; 
Mht = new int[Neq] ; 
For = new double[Neq+1] ; 
 
for ( i=0; i<Neq; i++ ) 
{ 
Maxa = 0 ; 
Mht = 0 ; 
For = 0 ; 
} 
Maxa[Neq] = 0 ; 
For[Neq] = 0;
 
CSparseMatrix Gkk(Neq+1, Neq+1); 

for ( i=0; i<NPoin; i++ ) 
{ 
for ( j=0; j<Ndf; j++ ) 
{ 
kk = abs(Ifp[j]) ; 
if (kk > 0) 
{ 
For[kk] += 2 ; 
} 
} 
}
Nwk = Maxa[Neq] - Maxa[0] ;
int m, n, pn; 
for ( i=0; i<NElem; i++ ) 
{ 
 
Leq = new int[Nnd*Ndf] ; 
for ( j=0; j<Nnd*Ndf; j++ ) 
{ 
Leq[j] = Lm[j] ; 
}
k = Nnd * Ndf; 
 
for ( j=0; j<Ndf*Nnd; j++ ) 
{ 
m = Lm[j] ; 
if (m > 0) 
{ 
for (n=0; n<Ndf*Nnd; n++) 
{ 
 
l = Lm[n] ; 
if (l > 0) 
{ 
Gkk(m, l) = Gkk(m, l) + 12;
} 
} 
} 
}
delete[] Leq; 
}
int Nnz; 
Nnz = 0; 
double toler= 1e-15;
Gkk.DelAllNode();
for (i=0; i<NPoin; i++) 
{ 
delete []Ifp; 
Ifp = NULL;
} 
delete []Ifp; 
Ifp = NULL;
for (i=0; i<NElem; i++) 
{ 
delete []Lm; 
} 
delete[] Lm; 
 
delete []Maxa; 
delete []Mht; 
delete []For; 
}
int main() 
{ 
int i; 
for (i=0; i<3000; i++) 
testt() ;
return 0; 
}

the following is Sparsematrix.h
/**/ 
#ifndef _SPARSEMATRIX_H_ 
#define _SPARSEMATRIX_H_
struct MatrixNode 
{ 
int row; 
int col; 
double val; 
MatrixNode *right; 
MatrixNode *down; 
};
class CSparseMatrix 
{ 
public: //construct function 
 
CSparseMatrix(CSparseMatrix &rhs); //拷贝构造函数 
CSparseMatrix(int row, int col); //构造函数
protected :
int m_row; //矩阵的行数 
int m_col; //矩阵的列数
public:
MatrixNode **pRhead; //矩阵的行头节点 
MatrixNode **pChead; //矩阵的列头节点 
int nNumOfNode; //矩阵的节点数目
public: //initialization of the matrix 
 
void InitMatrix(); //初始化矩阵头指针 
// void ReadData(); //为矩阵读入数据 
void SetRow( int ); //设置矩阵的行数 
void SetCol( int ); //设置矩阵的列数 
 
public: //矩阵的基本运算 
 
CSparseMatrix TransposeSMatrix(); //转置矩阵
 
void InsertNode(int i,int j,double val); //插入节点到指定位置 
double & InsertNode(int i,int j); //插入节点到指定位置 
void ChangeNodeValue(int i,int j,double value); //改变指定节点的值 
void AddNodeValue(int i, int j, double value); //增加指定节点的值 
void RemoveNode(int i,int j); //删除指定节点 
void DelAllNode(); //删除所有非零节点，以及头指针 
void IncreaseNode(){++nNumOfNode; }; //增加节点数目 
void DecreaseNode(){--nNumOfNode;}; //减少节点数目 
long GetNumOfNode(){return nNumOfNode;} //取得非零节点的数目 
double GetData(int i,int j); //取得指定位置的任意元素
 
int GetRow()const ; //得到矩阵的行数 
int GetCol()const ; //得到矩阵的列数
public: //重载运算符函数，友元函数 
 
double & operator()(int row, int col);
public : //析构函数 
~CSparseMatrix();
 
};
 
#endif
the following is Sparsematrix.cpp:
#include "Sparsematrix.h" 
#include <math.h> 
#include <stdlib.h> 
#include "stdio.h" 
 
/********************************************************/ 
/*
* 
/* 初始化矩阵的行数 * 
/*
* 
/********************************************************/ 
void inline CSparseMatrix::SetRow (int row) 
{ 
m_row=row; 
}
/********************************************************/ 
/*
* 
/* 初始化矩阵的列数 * 
/*
* 
/********************************************************/ 
void inline CSparseMatrix::SetCol (int col) 
{ 
m_col=col; 
}
/********************************************************/ 
/*
* 
/* 返回矩阵的列数 * 
/*
* 
/********************************************************/ 
int CSparseMatrix::GetRow ()const 
{ 
return m_row; 
}
/********************************************************/ 
/*
* 
/* 返回矩阵的行数 * 
/*
* 
/********************************************************/ 
int CSparseMatrix::GetCol ()const 
{ 
return m_col; 
} 
 
/********************************************************/ 
/* 初始化矩阵
* 
/* 生成稀疏矩阵的行列头指针 * 
/*
* 
/********************************************************/
CSparseMatrix::CSparseMatrix(int row,int col) 
{ 
if(row <= 0) 
{ 
printf("矩阵初始化的行参数错误!"); 
exit(0); 
} 
if(col <= 0) 
{ 
printf("矩阵初始化的列参数错误!"); 
exit(0); 
} 
SetRow(row); //设置行数 
SetCol(col); //设置列数 
InitMatrix(); //初始化矩阵
 
}
/********************************************************/ 
/*
* 
/* 初始化矩阵的行列头指针 * 
/* 节点数目
* 
/********************************************************/ 
void CSparseMatrix::InitMatrix () 
{ 
nNumOfNode =0; 
int i; 
pRhead =new MatrixNode*[GetRow()+1]; //为行的头指针分配空间 
for(i=1;i<GetRow()+1;i++) //并赋初值为NULL 
pRhead =NULL; 
pChead =new MatrixNode*[GetCol()+1]; //为列的头指针分配空间
 
for( i=1;i<GetCol()+1;i++) //并赋初值为NULL 
pChead =NULL; 
}
/********************************************************/ 
/*
* 
/* 拷贝构造函数 * 
/*
* 
/********************************************************/ 
CSparseMatrix::CSparseMatrix(CSparseMatrix &rhs) 
{ 
MatrixNode *q,*p; 
double val;
SetRow(rhs.GetRow()); //设置行数 
SetCol(rhs.GetCol()); //设置列数
 
InitMatrix(); //初始化矩阵
 
for(int i=1;i<rhs.GetRow ()+1;i++) 
{ 
q=rhs. pRhead ; //寻找非零节点 
if(!q) continue; //为新矩阵赋值 
for(int j=1;j<rhs.GetCol ()+1;j++) 
{ 
p=rhs.pChead [j]; 
if(!p) continue; 
val=rhs.GetData(i,j); 
InsertNode (i,j,val); //为新矩阵插入非零节点
 
nNumOfNode =rhs.nNumOfNode ;
 
}//j 
}//i
delete p, q;
}
/********************************************************/ 
/*
* 
/* 插入元素到指定的位置 * 
/*
* 
/********************************************************/ 
void CSparseMatrix::InsertNode(int i, int j, double val) 
{ 
if(i < 0 || i>GetRow ()+1 ) //参数检查 
{ 
printf("传入的行参数错误!"); 
exit(0); 
} 
 
if(j < 0 || j>GetCol()+1 ) 
{ 
 
printf("传入的列参数错误!"); 
exit(0); 
}
MatrixNode *q,*p,*s; 
p=NULL; 
q= pRhead ;
 
 
while(q!=NULL && q->col <j) //定位指定的非零节点, 
{ //q指向被增加的节点前一位 
p=q; q=q->right ; 
}; 
if((q==NULL) || (q->col >j)) 
{ 
s=new MatrixNode; //增加节点 
IncreaseNode(); 
s->row=i; //为节点赋置 
s->col =j; 
s->val =val; 
if(p==NULL) //如果为第一个节点 
{ //就把地址存入该行头节点
 
s->right = pRhead ; 
pRhead =s; 
} 
else 
{ 
s->right =q; //如果不是第一个节点 
p->right =s; //调整该行的链接关系 
} 
p=NULL; 
q= pChead [j]; 
while((q!=NULL) && (q->row <i)) 
{ 
p=q; 
q=q->down ; 
}; 
if(p==NULL) 
{ //如果为第一个节点 
s->down = pChead [j]; //就把地址存入该列头节点
 
pChead [j] =s; 
} 
else 
{ //如果不是第一个节点 
s->down =q; //调整该列的链接关系 
p->down =s; 
} 
} 
} 
/**********************************************************/ 
/* 改变指定位置的元素 * 
/*
* 
/* i,j分别为行列下标 *
 
/**********************************************************/ 
void CSparseMatrix::ChangeNodeValue(int i,int j,double value) 
{ 
if(i <= 0 || i>GetRow () ) 
{ 
printf("传入的行参数错误!"); 
exit(1); 
} 
 
if(j <= 0 || j>GetCol() ) 
{ 
printf("传入的列参数错误!"); 
exit(2); 
}
MatrixNode *q,*p; 
q= pRhead ; 
while((q!=NULL) && (q->col <j)) //定位指定的非零节点, 
{ //q指向被删除的节点 
p=q; 
q=q->right ; 
}; 
if((q==NULL) || (q->col >j)) 
{ 
printf("节点不存在!"); 
return ; 
} 
q->val =value; //改变节点的值
 
}
/************************************************************/ 
/* 给指定位置的元素增加一个值,若该元素为空, * 
/* 则为该元素分配内存并赋值. * 
/* 该函数主要用来形成装配整体结构刚度矩阵 * 
/* i, j分别为行列下标 *
 
/************************************************************/ 
void CSparseMatrix::AddNodeValue (int i, int j, double value) 
{ 
if(i <= 0 || i>GetRow () ) 
{ 
printf("传入的行参数错误!"); 
exit(1); 
} 
 
if(j <= 0 || j>GetCol() ) 
{ 
printf("传入的列参数错误!"); 
exit(2); 
}
MatrixNode *q, *p; 
q= pRhead ; 
while((q!=NULL) && (q->col <j)) //定位指定的非零节点 
{
 
p=q; 
q=q->right ; 
}; 
if((q==NULL) || (q->col >j)) 
{ 
InsertNode(i, j, value); //若该元素为空, 则为该元素分配内存并赋值 
} 
else 
{ 
q->val += value; //增加节点的值
 
}
}
 
/********************************************************/ 
/* 删除指定位置的元素 *
 
/*
* 
/* i,j分别为行列下标 * 
/********************************************************/ 
void CSparseMatrix::RemoveNode (int i, int j) 
{ 
if(i <= 0 || i>GetRow() ) 
{ 
printf("传入的行参数错误!"); 
exit(0); 
} 
 
if(j <= 0 || j>GetCol() ) 
{ 
printf("传入的列参数错误!"); 
exit(0); 
}
MatrixNode *q,*p; 
p=NULL; 
q= pRhead ; 
while(q!=NULL && q->col <j) //定位指定的非零节点, 
{ //q指向被删除的节点 
p=q; 
q=q->right ; 
};
if(q==NULL || q->col >j )
 
return; 
else 
{ 
if(p==NULL) //重新设定行的链接关系 
pRhead =q->right ; 
else p->right =q->right ; 
p=NULL; 
q= pChead [j]; 
while(q->row <i) //定位指定的非零节点, 
{ //q指向被删除的节点 
p=q; 
q=q->down ; 
 
}; 
if(p==NULL) pChead [j]=q->down ; //重新设定列的链接关系 
else p->down =q->down ; 
delete q; 
DecreaseNode(); 
} 
delete p; 
}
/********************************************************/ 
/*
* 
/* 删除矩阵中的所有元素，释放内存 * 
/*
* 
/********************************************************/ 
void CSparseMatrix:elAllNode () 
{ 
int i; 
if(nNumOfNode==0) return ; 
MatrixNode *q,*p; 
/**/ 
for(i=1;i<GetRow()+1;i++) //该for循环用于从每行中删除非零节点 
{ 
p=q=pRhead; 
if(!q)continue; //该行无元素，结束该次循环 
while(q) 
{ 
p=q->right ; //下一个节点的指针存储在p中 
delete q; 
q=p; //q指向下一个节点 
}
}//i
for( i=1;i<GetRow()+1;i++) 
{//将行指针赋值为空 
// delete []pRhead; 
pRhead =NULL; 
} 
// delete []pRhead; 
// pRhead = NULL; 
 
for( i=1;i<GetCol()+1;i++) 
{//将列指针赋值为空 
// delete []pChead ; 
pChead =NULL; 
} 
// delete []pChead ; 
// pChead = NULL ;
nNumOfNode=0; //数组元素清零
 
delete p, q; 
}
/********************************************************/ 
/* 取得指定位置任意的元素 * 
/*
* 
/* i为行下标，j 为列下标 * 
/********************************************************/ 
double CSparseMatrix::GetData (int i, int j) 
{ 
if(i <= 0 || i>GetRow() ) //行列参数检查 
{
printf("传入的行参数错误!"); 
exit(0); 
} 
 
if(j <= 0 || j>GetCol() ) 
{ 
printf("传入的列参数错误!"); 
exit(0); 
}
MatrixNode *q,*p; 
p=NULL; 
q=NULL; 
if(i>=j) //如果行数>列数,就从行开始寻找非零节点 
{ 
q= pRhead ; 
while((q!=NULL) && (q->col <j) ) 
{ 
p=q; 
q=q->right ; 
}; 
if((q==NULL)||(q->col>j)) return 0; //没有找到指定节点返回0 
return q->val ; 
} 
else //如果行数<列数,就从列开始寻找非零节点 
{ 
q=pChead [j]; 
while((q!=NULL) && (q->row <i)) 
{ 
p=q; 
q=q->down ; 
}; 
if((q==NULL)||(q->row >i)) return 0; //没有找到指定节点返回0 
return q->val ; 
} 
 
}
/********************************************************/ 
/*
* 
/* 矩阵转置运算 * 
/*
* 
/********************************************************/ 
CSparseMatrix CSparseMatrix::TransposeSMatrix(){ 
CSparseMatrix At(this->GetCol() ,this->GetRow ()); 
MatrixNode *q; 
double x; 
for(int i=1;i<GetRow()+1;i++) 
{ 
q= pRhead ; 
if(!q) continue; //该行无元素,退出此次循环 
for(int j=1;j<GetCol()+1;j++) 
{ 
q= pChead [j]; 
if(!q) continue; //该列无元素,退出此次循环 
x=GetData(i,j); 
if(x) 
{ 
At.InsertNode (j,i,x); 
} 
}//j 
 
}//i 
return At; 
}
CSparseMatrix::~CSparseMatrix () 
{ 
if(nNumOfNode==0) return ; 
MatrixNode *q,*p; 
for(int i=1;i<GetRow()+1;i++) //该for循环用于从每行中删除非零节点 
{ 
p=q=pRhead; 
 
while(q) 
{ 
p=q->right ; //下一个节点的指针存储在p中 
delete q; 
q=p; //q指向下一个节点 
}
}//i 
nNumOfNode=0; 
delete []pRhead; //删除行，列头节点 
delete []pChead;
}
double & CSparseMatrix::InsertNode(int i,int j) 
{ 
if(i < 0 || i>GetRow ()+1 ) //参数检查 
{ 
printf("传入的行参数错误!"); 
exit(0); 
} 
 
if(j < 0 || j>GetCol()+1 ) 
{ 
 
printf("传入的列参数错误!"); 
exit(0); 
}
MatrixNode *q,*p,*s; 
p=NULL; 
q= pRhead ;
 
 
while(q!=NULL && q->col <j) //定位指定的非零节点, 
{ //q指向被增加的节点前一位 
p=q; q=q->right ; 
}; 
if((q==NULL) || (q->col >j)) 
{ 
s=new MatrixNode; //增加节点 
IncreaseNode(); 
s->row=i; //为节点赋置 
s->col =j; 
s->val =0; 
if(p==NULL) //如果为第一个节点 
{ //就把地址存入该行头节点
 
s->right = pRhead ; 
pRhead =s; 
} 
else 
{ 
s->right =q; //如果不是第一个节点 
p->right =s; //调整该行的链接关系 
} 
p=NULL; 
q= pChead [j]; 
while((q!=NULL) && (q->row <i)) 
{ 
p=q; 
q=q->down ; 
}; 
if(p==NULL) 
{ //如果为第一个节点 
s->down = pChead [j]; //就把地址存入该列头节点
 
pChead [j] =s; 
} 
else 
{ //如果不是第一个节点 
s->down =q; //调整该列的链接关系 
p->down =s; 
} 
} 
return s->val; 
}
 
double & CSparseMatrix:perator()(int i, int j) 
{ 
if(i <= 0 ) //行列参数检查 
{ 
printf("传入的行参数错误----!"); 
exit(0); 
} 
 
if(j <= 0 ) 
{ 
printf("传入的列参数错误!"); 
exit(0); 
}
if(i>GetRow() ) //行列参数检查 
{ 
SetRow(i); 
} 
 
if(j>GetCol() ) 
{ 
SetCol(j); 
}
 
MatrixNode *q,*p; 
p=NULL; 
q=NULL; 
if(i>=j) //如果行数>列数,就从行开始寻找非零节点 
{ 
q= pRhead ; 
while((q!=NULL) && (q->col <j) ) 
{ 
p=q; 
q=q->right ; 
}; 
if((q==NULL)||(q->col>j)) return InsertNode(i, j); //没有找到指定节点返回0 
return q->val ; 
} 
else //如果行数<列数,就从列开始寻找非零节点 
{ 
q=pChead [j]; 
while((q!=NULL) && (q->row <i)) 
{ 
p=q; 
q=q->down ; 
}; 
if((q==NULL)||(q->row >i)) return InsertNode(i, j); //没有找到指定节点返回0 
return q->val ; 
} 
p=NULL; 
q=NULL; 
delete []q; //删除行，列头节点 
delete []p;
}
/* 
void InvertMatrix(CSparseMatrix &TM) 
{ 
int i, j, n, k; 
double temp; 
 
n = TM.GetCol(); 
 
CSparseMatrix a(n, n); 
CSparseMatrix b(n, n); 
CSparseMatrix c(n, n); 
 
}
*/

View the full article

how to release memory in the use of orthogonal list

EDN Admin

Well-known member

Similar threads