查看: 5951|回复: 3

求高手帮助C动态分配内存

字体大小: 正常放大

yaa

8 主题	2 听众	76 积分

升级 74.74%

该用户从未签到

电梯直达

1^#

发表于 2005-6-9 21:32 |只看该作者 |倒序浏览

|招呼Ta 关注Ta

我的C程序中需要调用一个120*100*15的三维数组，tc2.0下根本无法运行，就算换用VC编译好像也不行。听说采用分配动态内存的办法可以解决这个问题，但我不会用，求高手帮助，该怎么做啊

zan

转播0 淘帖0 分享0 收藏0 支持0 反对0 微信

使用道具举报

madio

3万主题	1312 听众	5万积分

TA的每日心情

	奋斗 2024-7-1 22:21

签到天数: 2014 天

[LV.Master]伴坛终老

自我介绍: 数学中国站长

群组: 数学建模培训课堂1

群组: 数学中国美赛辅助报名

群组: Matlab讨论组

群组: 2013认证赛A题讨论群组

群组: 2013认证赛C题讨论群组

2^#

发表于 2005-6-9 23:04 |只看该作者 |招呼Ta 关注Ta |邮箱已经成功绑定

例子

<

>下面是一个定义数组的例子，我估计你定义不了是因为在栈里面无法定义，而在堆里面是可以定义的！
<

>#define T 100000
<

>#include "stdlib.h" #include "math.h" #include "stdio.h" #include <string.h> struct position { int x; int y; }; ////////////////////////////////////////////////////////////////////////////// //摘自《C常用算法程序集（第二版）》，实矩阵求逆的全选主高斯-约当法 // //int brinv(a,n) // //本函数返回一个整形标志值。若返回的标志值为0，则表示矩阵A奇异，还输出信息 //“err * * not inv”；若返回的标志值不为0，则表示正常返回。 //形参说明： //a——双精度实型二维数组，体积为n*n。存放原矩阵A；返回时存放其逆矩阵A逆。 //n——整形变量。矩阵的阶数。 ////////////////////////////////////////////////////////////////////////////// int brinv(double a[],int n) { int *is,*js,i,j,k,l,u,v; double d,p; is=(int *)malloc((unsigned)n*sizeof(int)); js=(int *)malloc((unsigned)n*sizeof(int)); for (k=0; k<=n-1; k++) { d=0.0; for (i=k; i<=n-1; i++) for (j=k; j<=n-1; j++) { l=i*n+j; p=fabs(a[l]); if (p>d) { d=p; is[k]=i; js[k]=j; } } if (fabs(d)<0.0000001) { free(is); free(js); printf("err**not inv\n"); return(0); } if (is[k]!=k) { for (j=0; j<=n-1; j++) { u=k*n+j; v=is[k]*n+j; p=a; a=a[v]; a[v]=p; } } if (js[k]!=k) { for (i=0; i<=n-1; i++) { u=i*n+k; v=i*n+js[k]; p=a; a=a[v]; a[v]=p; } } l=k*n+k; a[l]=1.0/a[l]; for (j=0; j<=n-1; j++) { if (j!=k) { u=k*n+j; a=a*a[l]; } } for (i=0; i<=n-1; i++) { if (i!=k) { for (j=0; j<=n-1; j++) { if (j!=k) { u=i*n+j; a=a-a[i*n+k]*a[k*n+j]; } } } } for (i=0; i<=n-1; i++) { if (i!=k) { u=i*n+k; a=-a*a[l]; } } } for (k=n-1; k>=0; k--) { if (js[k]!=k) { for (j=0; j<=n-1; j++) { u=k*n+j; v=js[k]*n+j; p=a; a=a[v]; a[v]=p; } } if (is[k]!=k) { for (i=0; i<=n-1; i++) { u=i*n+k; v=i*n+is[k]; p=a; a=a[v]; a[v]=p; } } } free(is); free(js); return(1); }
<

>////////////////////////////////////////////////////////////////////////////// //摘自《C常用算法程序集（第二版）》，实矩阵相乘 // //void brmul(a,b,m,n,k,c) // //形参说明： //a——双精度实型二维数组，体积为m*n。存放矩阵A的元素。 //b——双精度实型二维数组，体积为n*k。存放矩阵B的元素。 //m——整形变量。矩阵A的行数，也是乘积矩阵C＝AB的行数。 //n——整形变量。矩阵A的列数，也是矩阵B的行数。 //k——整形变量。矩阵B的列数，也是乘积矩阵C＝AB的列数。 //c——双精度实型二维数组，体积为m*k。返回乘积矩阵C＝AB的元素。 ////////////////////////////////////////////////////////////////////////////// void brmul(double a[],double b[],int m,int n,int k,double c[]) { int i,j,l,u; for (i=0; i<=m-1; i++) { for (j=0; j<=k-1; j++) { u=i*k+j; c=0.0; for (l=0; l<=n-1; l++) c=c+a[i*n+l]*b[l*k+j]; } } return; }
<

>////////////////////////////////////////////////////////////////////////////// void main() { FILE *para_fp,*in_fp,*out_fp,*fp; int n;// 特征空间的大小，即共n个特征 int lines,columns;//对应数据场的行列值 int m;//分类数 int *nl;//一维数组，存放每类的样本点数量 struct position **style;//二维数组，存放每类的样本点坐标 double *xp,**x;//二维数组x，存放训练样本数据的数组; double *xtp,**xt;//数组x的逆，存放训练样本数据的数组; double *up,**u;//二维数组，存放每一类的均值 double ***sigma,*sigmap,**sigmapp;//三维数组，存放每类的散度矩阵 double ***anti_sigma,*anti_sigmap,**anti_sigmapp;//三维数组，存放每类的散度矩阵的逆矩阵 double **sigma_temp,*sigma_tempp,**anti_sigma_temp,*anti_sigma_tempp;//临时用的矩阵 int return_brinv;//矩阵求逆返回值，标示矩阵是否奇异 double *g;//数组，存放像元x 与每一类的广义距离 double min_g; int min_i;//存放最大g的i int datatype;//对应每一数据类型所占的字节数 int i,j,k;//循环变量 long count;//循环变量，扫描整个数据场 char d[10];//原数据场的数据类型 //以下为临时变量 struct position style_temp; char pels_temp; char temp; short temp_0; int temp_1; long temp_2; float temp_3; double temp_4;
* U+ B& t! \% b% |8 \! w+ N" }6 w<> double g_temp0[1],*g_temp1p,**g_temp1; ////////////////////////////////////////////////////////////////////////////////////////////// // 变量说明 // // nl每类样本点数量 style每类的样本点坐标 // | | // nl[0] style[0][0]---style[0][(nl[0])] // nl[1] style[1][0]---style[0][(nl[1])] // // …… …… // // nl[m] style[m][0]---style[0][(nl[m])] // //sigma[m][n][n]：存放所有类的sigma矩阵； //anti_sigma[m][n][n]：存放所有类的sigma矩阵的逆矩阵； // ////////////////////////////////////////////////////////////////////////////////////////////////( r* d& g- _; m8 \0 b% H$ v" {
<> ////////////读取特征空间的大小////////////////////////////////// if((para_fp=fopen("guangyi.par","rt"))==NULL) { return; } fscanf(para_fp,"%d",&n);//读取特征空间的大小 fscanf(para_fp,"%d",&m);//预分类数 //band=(int *)malloc((unsigned)n*sizeof(int));//存取n个波段号 //for(i=0;i<n;i++) band=0; //for(i=0;i<n;i++) //{ // fscanf(para_fp,"%d",&(band)); //} fclose(para_fp);2 K. \; p6 r: [& T) P) }
<> //for(i=0;i<n;i++) //{ //} ////////////读取数据场的行列值////////////////////////////////// if((para_fp=fopen("sourceimg.par","rt"))==NULL) { return; } fscanf(para_fp,"%d,%d",&lines,&columns); fclose(para_fp);
) D b+ ^' H0 B7 _8 `- i<> printf("lines=%d,columns=%d\n",lines,columns); /////////////////////////////////// if((fp=fopen("leixing.par","rt"))==NULL) { return; } i=0; while(!feof(fp)) { d=fgetc(fp); // printf("%c\n",d); i=i+1; } d[i-1]='\0'; //fscanf(fp,"%s",d);
) i! O" ]% |7 K% x1 W) L9 B<> if(strcmp(d,"char")==0) { datatype=1; } if(strcmp(d,"short")==0) { datatype=2; } if(strcmp(d,"int")==0) { datatype=4; } if(strcmp(d,"long")==0) { datatype=4; } if(strcmp(d,"float")==0) { datatype=4; } if(strcmp(d,"double")==0) { datatype=8; } printf("datatype=%d\n",datatype); printf("%s",d); ////////////读取样本数和样本区////////////////////////////////// style=(struct position **)malloc((unsigned)m*sizeof(struct position *)); nl=(int*)malloc((unsigned)m*sizeof(int));9 [# P% m' |5 `# v* A4 `
<> if((para_fp=fopen("style.par","rt"))==NULL) { free(style); free(nl); return; } for(i=0;i<m;i++) { fscanf(para_fp,"%d",&(nl)); style=(struct position *)malloc((unsigned)(nl)*sizeof(struct position)); for(j=0;j<(nl);j++) { style_temp.x=0; style_temp.y=0; style[j]=style_temp; } for(j=0;j<(nl);j++) { // 读入每一类的样本点的坐标 fscanf(para_fp,"%d,%d",&(style_temp.x),&(style_temp.y)); style[j]=style_temp; } } fclose(para_fp);: p+ T- Q9 [4 E! y& O1 f+ k
<> for(i=0;i<m;i++) { printf("\nClass %3d:%3d\n",i,nl); for(j=0;j<(nl);j++) { style_temp=style[j]; // printf("(%d,%d)",style_temp.x,style_temp.y); } } ////////////计算m个类别训练组的u，sigma，sigma逆////////////////////////////////// if((in_fp=fopen("sourceimg.dat","rb"))==NULL) { for(k=0;k<m;k++) { free(style[k]); } free(style); free(nl); return; }# t' d8 q+ R& q, R1 y( A8 ]7 s# v
<> up=(double *)malloc((unsigned)n*m*sizeof(double)); u=(double **)malloc((unsigned)n*sizeof(double*)); for(k=0;k<n;k++) { u[k]=&(up[k*m]); } for(k=0;k<n;k++) { for(j=0;j<m;j++) { u[k][j]=0.0; } }. t1 }' A. Q8 g+ w
<> sigmap=(double *)malloc((unsigned)m*n*n*sizeof(double)); sigmapp=(double **)malloc((unsigned)m*n*sizeof(double *)); sigma=(double ***)malloc((unsigned)m*sizeof(double **));
! X8 e F& M0 p7 D( F1 B' q<> for(i=0;i<m;i++) { for(j=0;j<n;j++) { sigmapp[i*n+j]=&(sigmap[i*n*n+j*n]); } sigma=&(sigmapp[i*n]); }
. Q- H3 N; ~. R% E' T<> anti_sigmap=(double *)malloc((unsigned)m*n*n*sizeof(double)); anti_sigmapp=(double **)malloc((unsigned)m*n*sizeof(double *)); anti_sigma=(double ***)malloc((unsigned)m*sizeof(double **));; q6 s+ _, g# P n6 {
<> for(i=0;i<m;i++) { for(j=0;j<n;j++) { anti_sigmapp[i*n+j]=&(anti_sigmap[i*n*n+j*n]); } anti_sigma=&(anti_sigmapp[i*n]); }
! y) i% O2 W$ w. p<> //对每一类进行循环，计算计算m个类别训练组的u，sigma，sigma逆 for(i=0;i<m;i++) { sigma_tempp=(double *)malloc((unsigned)n*n*sizeof(double)); sigma_temp=(double **)malloc((unsigned)n*sizeof(double*)); for(k=0;k<n;k++) { sigma_temp[k]=&(sigma_tempp[k*n]); }
" l' r. N- J; y<> anti_sigma_tempp=(double *)malloc((unsigned)n*n*sizeof(double)); anti_sigma_temp=(double **)malloc((unsigned)n*sizeof(double*)); for(k=0;k<n;k++) { anti_sigma_temp[k]=&(anti_sigma_tempp[k*n]); }
$ K6 I# B1 q+ t9 f<> xp=(double *)malloc((unsigned)n*nl*sizeof(double)); x=(double **)malloc((unsigned)n*sizeof(double*)); //训练样本 for(k=0;k<n;k++) { x[k]=&(xp[k*nl]); } xtp=(double *)malloc((unsigned)nl*n*sizeof(double)); xt=(double **)malloc((unsigned)nl*sizeof(double*)); //训练样本的转置 for(j=0;j<nl;j++) { xt[j]=&(xtp[j*n]); }
, d$ S7 o7 j' C q3 e- r<> ///////////////////读取矩阵X/////////////////////////////////// for(j=0;j<nl;j++) { style_temp=style[j]; for(k=0;k<n;k++) { //style_temp=style[j]; if(k==0) { fseek(in_fp,(style_temp.x*lines+style_temp.y)*datatype,SEEK_SET); } else { fseek(in_fp,(lines*columns-1)*datatype,SEEK_CUR); } /////////////////从数据场文件中读入训练样本的数据 if(1==datatype) { fread(&temp,datatype,1,in_fp); x[k][j]=(double)temp; } if(2==datatype) { fread(&temp_0,datatype,1,in_fp); x[k][j]=(double)temp_0; } if(strcmp(d,"int")==0) { fread(&temp_1,datatype,1,in_fp); x[k][j]=(double)temp_1; } if(strcmp(d,"long")==0) { fread(&temp_2,datatype,1,in_fp); x[k][j]=(double)temp_2; } if(strcmp(d,"float")==0) { fread(&temp_3,datatype,1,in_fp); x[k][j]=(double)temp_3; } if(8==datatype) { fread(&temp_4,datatype,1,in_fp); x[k][j]=(double)temp_4; } ///////////////////// // fread(&temp,datatype,1,in_fp); // x[k][j]=(double)temp; // if(x[k][j]<0) x[k][j]+=256; } } // printf("\nWhen Class= %3d,X is:\n",i); for(k=0;k<n;k++) { for(j=0;j<nl;j++) { // printf("%10.5f",x[k][j]); } // printf("\n"); } ///////////////////求X的转置矩阵Xt//////////////////////////////// for(k=0;k<n;k++) { for(j=0;j<nl;j++) { //计算训练样本的转置矩阵 xt[j][k]=x[k][j]; } }
$ b% ~# _' X' {( x+ Y! `<> printf("\nWhen Class= %3d,Xt is:\n",i); for(j=0;j<nl;j++) { for(k=0;k<n;k++) { // printf("%10.5f",xt[j][k]); } // printf("\n"); }. x$ |" b# r6 K8 z+ m
<>///////////////////求矩阵u///////////////////////////////////////// printf("\nWhen Class= %3d,U is:\n",i); for(k=0;k<n;k++) { for(j=0;j<nl;j++) { u[k]+=x[k][j]; } u[k]=(u[k])/(nl);//求每一类的样本均值 // printf("%13.7lf\n",u[k]); }% i" s" a6 _+ ^. J9 ^7 s6 B
<> // printf("\n");" ] n2 o: X- ]/ z8 {
<>///////////////////计算矩阵Sigma=X*Xt////////////////////////////// brmul(xp,xtp,n,nl,n,sigma_tempp); for (k=0;k<n;k++) for(j=0;j<n;j++) sigma_temp[k][j]=sigma_temp[k][j]/(nl-1); //求每一类的散度矩阵 printf("\nWhen Class= %3d,Sigma is:\n",i); for(k=0;k<n;k++) { for(j=0;j<n;j++) { // printf("%13.3lf",sigma_temp[k][j]); } // printf("\n"); }1 a1 M/ c* h% [. e4 T& h
<> ///////////////////计算矩阵Sigma的逆矩阵anti_sigma//////////////// for(k=0;k<n;k++) { for(j=0;j<n;j++) { anti_sigma_temp[k][j]=sigma_temp[k][j]; } }
7 ^, n! a& D* T" Z" l I/ ^; a9 b<> return_brinv=brinv(anti_sigma_tempp,n);//求散度矩阵的逆矩阵4 f5 N1 F5 e; m* a
<> if(return_brinv==0)//矩阵Sigma奇异，退出程序，重新选择参数 { free(x); free(xp); free(xt); free(xtp); free(sigma_tempp); free(sigma_temp); free(anti_sigma_tempp); free(anti_sigma_temp);
/ c' O8 p. N7 r9 \6 I<> // free(p); free(nl); for(k=0;k<m;k++) { free(style[k]); } free(style); free(u); free(up); free(sigmap); free(sigmapp); free(sigma); free(anti_sigmap); free(anti_sigmapp); free(anti_sigma); return; }1 w8 N# c8 o0 Y/ g' \0 z9 d& Q
<> printf("\nWhen Class= %3d,Anti_Sigma is:\n",i); for(k=0;k<n;k++) { for(j=0;j<n;j++) { // printf("%13.3e ",anti_sigma_temp[k][j]); } // printf("\n"); }9 E5 V% _: ^* {3 R1 g
 // printf("\nWhen Class= %3d,Det Sigma is:%13.7lf\n",i,bsdet(sigma_tempp,n));
6 U. F7 w. o9 \$ |% f) |& O/* double c[n][n]; brmul(sigma_tempp,anti_sigma_tempp,n,n,n,c); printf("\n\n"); for(k=0;k<n;k++) { for(j=0;j<n;j++) { printf("%13.3e ",c[k][j]); } printf("\n"); } */
$ D; s5 e: Y9 `- r5 x //////////////////////////将每类的Sigma，Anti_Sigma存放入三维数组////// for(k=0;k<n;k++) { for(j=0;j<n;j++) { sigma[k][j]=sigma_temp[k][j]; anti_sigma[k][j]=anti_sigma_temp[k][j]; } } free(x); free(xp); free(xt); free(xtp); free(sigma_tempp); free(sigma_temp); free(anti_sigma_tempp); free(anti_sigma_temp); }
* b7 H/ _! P- s. t; W///////////////////////////////////////////////////////////////////////////// //////////逐点扫描整个数据场 if((out_fp=fopen("m_printf.dat","wb"))==NULL) { free(sigmap); free(sigmapp); free(sigma); free(anti_sigmap); free(anti_sigmapp); free(anti_sigma); return; }
4 ?% S$ Z- A# O xp=(double *)malloc((unsigned)n*1*sizeof(double)); x=(double **)malloc((unsigned)n*sizeof(double*)); for(k=0;k<n;k++) { x[k]=&(xp[k*1]); //这里的数组x是逐个要扫描的每一个数据点 } xtp=(double *)malloc((unsigned)1*n*sizeof(double)); xt=(double **)malloc((unsigned)1*sizeof(double*));//这里的数组xt是逐个要扫描的每一个数据点的转置向量 for(j=0;j<1;j++) { xt[j]=&(xtp[j*n]); } g=(double*)malloc((unsigned)m*sizeof(double)); sigma_tempp=(double *)malloc((unsigned)n*n*sizeof(double)); sigma_temp=(double **)malloc((unsigned)n*sizeof(double*)); for(k=0;k<n;k++) { sigma_temp[k]=&(sigma_tempp[k*n]); }
3 o1 G' `, X: S6 B1 ` anti_sigma_tempp=(double *)malloc((unsigned)n*n*sizeof(double)); anti_sigma_temp=(double **)malloc((unsigned)n*sizeof(double*)); for(k=0;k<n;k++) { anti_sigma_temp[k]=&(anti_sigma_tempp[k*n]); } g_temp1p=(double *)malloc((unsigned)1*n*sizeof(double)); g_temp1=(double **)malloc((unsigned)1*sizeof(double*)); for(j=0;j<1;j++) { g_temp1[j]=&(g_temp1p[j*n]); } //读取数据场中的数据4 r- ]" p+ b |' p l1 a
 for(count=0;count<lines*columns;count++) { //读取一个数据点值 for(k=0;k<n;k++) { if(k==0) { fseek(in_fp,count*datatype,SEEK_SET); } else { fseek(in_fp,(lines*columns-1)*datatype,SEEK_CUR); } ////////////////////根据原数据场的数据类型，读取每个数据点 if(1==datatype) { fread(&temp,datatype,1,in_fp); x[k][0]=(double)temp; } if(2==datatype) { fread(&temp_0,datatype,1,in_fp); x[k][0]=(double)temp_0; } if(strcmp(d,"int")==0) { fread(&temp_1,datatype,1,in_fp); x[k][0]=(double)temp_1; } if(strcmp(d,"long")==0) { fread(&temp_2,datatype,1,in_fp); x[k][0]=(double)temp_2; } if(strcmp(d,"float")==0) { fread(&temp_3,datatype,1,in_fp); x[k][0]=(double)temp_3; } if(8==datatype) { fread(&temp_4,datatype,1,in_fp); x[k][0]=(double)temp_4; } ///////////////////// //fread(&temp,datatype,1,in_fp); //x[k][0]=(double)temp; //if(x[k][0]<0) x[k][0]+=256; } H1 W5 ~; M8 B" e5 u8 W9 C
 for(i=0;i<m;i++) { ///////////////计算矩阵(x-u)以及其转置/////////////////////////////////// for(k=0;k<n;k++) { x[k][0]-=u[k]; xt[0][k]=x[k][0]; } ///////////////取出本类的矩阵Sigma及其逆矩阵Anti_Sigma/////////////////// for(k=0;k<n;k++) { for(j=0;j<n;j++) { sigma_temp[k][j]=sigma[k][j]; anti_sigma_temp[k][j]=anti_sigma[k][j]; } } ///////////////计算g，并求出最小的g////////////////////////////////// brmul(xtp,anti_sigma_tempp,1,n,n,g_temp1p); brmul(g_temp1p,xp,1,n,1,g_temp0); //计算数据点与每一类的距离 g=g_temp0[0]; if(i==0) { min_g=g; min_i=0; } else { if(min_g>g) { min_g=g; min_i=i; } } } ///////////////将该数据点所属类别写入分类文件/////////////////////////////
+ [8 D, B7 F# b* b0 i if(min_g>T) min_i=m;////////////////如果min_g>T，划为拒绝类/////// pels_temp=(char)(min_i*255/m); fwrite(&pels_temp,sizeof(char),1,out_fp);//保存最终的分类结果
: r% F: x# B# m# D- N( ^6 J } fclose(out_fp); fclose(in_fp);
+ M* D ~% l8 f* `9 I free(x); free(xp); free(xt); free(xtp); free(g); free(g_temp1p); free(g_temp1); free(sigma_tempp); free(sigma_temp); free(anti_sigma_tempp); free(anti_sigma_temp);
8 L, O/ n9 |5 D3 m+ d3 B3 M9 M+ Q" W% f A# ^

+ ^1 x4 O- [/ G" M0 {3 j // free(p); free(nl); for(i=0;i<m;i++) { free(style); } free(style); free(u); free(up); free(sigmap); free(sigmapp); free(sigma); free(anti_sigmap); free(anti_sigmapp); free(anti_sigma); }