动态二维数组传值

AC_YE 2020-11-11 10:45:45
#include <stdio.h> #include <stdlib.h> void show(int v[],int n)//将压缩矩阵转变为原矩阵输出 { int i,j; for(i=0;i<n;i++) { for(j=0;j<n;j++) { if(i>=j)//比较行和列下标 printf("%5d",v[i*(i+1)/2+j]); else printf("%5d",v[j*(j+1)/2+i]); } printf("\n"); } } void multiply(int va[],int vb[],int c[][n],int n) { int i,j,k,s,op1,op2; for(i=0;i<n;i++) { for(j=0;j<n;j++) { s=0; for(k=0;k<n;k++) { if(i>=k)//比较行和列的下标,行不变,列改变 k相当于列下标 { op1=va[i*(i+1)/2+k]; } else { op1=va[k*(k+1)/2+i]; } if(k>=j)//比较行和列的下标,列不变,行改变 k相当于行下标 { op2=vb[k*(k+1)/2+j]; } else { op2=vb[j*(j+1)/2+k]; } s+=op1*op2; } c[i][j]=s; } } for(i=0;i<n;i++)//打印二维数组 { for(j=0;j<n;j++) { printf("%5d",c[i][j]); } printf("\n"); } return; } void Destroy(int **a,int n)//二维动态数组销毁 { int i; for(i=0;i<n;i++) { free(a[i]); } } int main() { int n,k,i,j; int *a,*b; int **c=(int**)malloc(n*sizeof(int*));//动态分配二维数组 for(i=0;i<n;i++) { c[i]=(int*)malloc(sizeof(int)*n); } printf("请输入阶数n:\n"); scanf("%d",&n); k=n*(n+1)/2; //k作为一维数组来存储n阶对称矩阵一维数组要求的元素个数 a=(int*)malloc(sizeof(int)*k);//动态分配一维数组a b=(int*)malloc(sizeof(int)*k);//动态分配一维数组b printf("生成矩阵A 请输入%d个压缩矩阵中的数:\n",n*(n+1)/2); for(i=0;i<k;i++) { scanf("%d",&a[i]);//输入压缩矩阵元素 } printf("矩阵A为 :\n"); show(a,n);//将压缩矩阵转变为原矩阵输出 printf("生成矩阵B 请输入%d个压缩矩阵中的数:\n",n*(n+1)/2); for(i=0;i<k;i++) { scanf("%d",&b[i]);////输入压缩矩阵元素 } printf("矩阵B为 :\n"); show(b,n);//将压缩矩阵转变为原矩阵输出 printf("A*B=:\n"); multiply(a,b,c,n);//返回二维数组的地址 Destroy(c,n);//销毁二维数组 return 0; } 为什么会报错?
...全文
96 8 打赏 收藏 转发到动态 举报
写回复
用AI写文章
8 条回复
切换为时间正序
请发表友善的回复…
发表回复
AC_YE 2020-11-12
  • 打赏
  • 举报
回复
引用 1 楼 qybao的回复:
void multiply(int va[], int vb[], int c[][n], int n) //这里的int c[][n]的n不是常量,不能这样定义动态数组,要用指针int **c(或者把n定义为宏)。 这个动态数组问题我怎么觉得lz不止一次问过了,怎么还是老犯同样的错误。
换成int**c后编译没问题但在后面执行时突然停止,这是怎么回事?
自信男孩 2020-11-12
  • 打赏
  • 举报
回复
引用 6 楼 肥牛肉^*^ 的回复:
[quote=引用 5 楼 肥牛肉^*^的回复:][quote=引用 3 楼 自信男孩的回复:]楼主看一下main函数里,n是未初始化的,直接就用这个n申请空间,很明显会有问题。楼主能在n是不确定的情况下使用动态申请空间的方式方向是对的,但是注意有一个先后问题;


    printf("请输入阶数n:\n");
scanf("%d",&n);
int **c=(int**)malloc(n*sizeof(int*));//动态分配二维数组
if (!c)
exit(0);
for(i=0;i<n;i++)
{
c[i]=(int*)malloc(sizeof(int)*n);
if (!c[i])
exit(0);
}

先输入后申请。建议楼主加上判断Malloc的返回值判断;

#include <stdio.h>
#include <stdlib.h>

void show(int v[],int n)//将压缩矩阵转变为原矩阵输出
{
int i,j;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(i>=j)//比较行和列下标
printf("%5d",v[i*(i+1)/2+j]);
else
printf("%5d",v[j*(j+1)/2+i]);
}
printf("\n");
}
}
//void multiply(int va[],int vb[],int c[][n],int n) //这儿的c是二重指针,因此直接用**c即可
void multiply(int va[],int vb[],int **c,int n)
{
int i,j,k,s,op1,op2;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
s=0;
for(k=0;k<n;k++)
{
if(i>=k)//比较行和列的下标,行不变,列改变 k相当于列下标
{
op1=va[i*(i+1)/2+k];
}
else
{
op1=va[k*(k+1)/2+i];
}
if(k>=j)//比较行和列的下标,列不变,行改变 k相当于行下标
{
op2=vb[k*(k+1)/2+j];
}
else
{
op2=vb[j*(j+1)/2+k];
}
s+=op1*op2;
}
c[i][j]=s;
}
}
for(i=0;i<n;i++)//打印二维数组
{
for(j=0;j<n;j++)
{
printf("%5d",c[i][j]);
}
printf("\n");
}
return;
}
void Destroy(int **a,int n)//二维动态数组销毁
{
int i;
for(i=0;i<n;i++)
{
free(a[i]);
}

free(a); //最后也要把a释放了
}
int main()
{
int n,k,i,j;
int *a,*b;

printf("请输入阶数n:\n");
scanf("%d",&n);
int **c=(int**)malloc(n*sizeof(int*));//动态分配二维数组
for(i=0;i<n;i++)
{
c[i]=(int*)malloc(sizeof(int)*n);
}
k=n*(n+1)/2; //k作为一维数组来存储n阶对称矩阵一维数组要求的元素个数
a=(int*)malloc(sizeof(int)*k);//动态分配一维数组a
b=(int*)malloc(sizeof(int)*k);//动态分配一维数组b

printf("生成矩阵A 请输入%d个压缩矩阵中的数:\n",n*(n+1)/2);
for(i=0;i<k;i++)
{
scanf("%d",&a[i]);//输入压缩矩阵元素
}
printf("矩阵A为 :\n");
show(a,n);//将压缩矩阵转变为原矩阵输出


printf("生成矩阵B 请输入%d个压缩矩阵中的数:\n",n*(n+1)/2);
for(i=0;i<k;i++)
{
scanf("%d",&b[i]);////输入压缩矩阵元素
}
printf("矩阵B为 :\n");
show(b,n);//将压缩矩阵转变为原矩阵输出
printf("A*B=:\n");
multiply(a,b,c,n);//返回二维数组的地址
Destroy(c,n);//销毁二维数组
return 0;
}


楼主还是要分清二维数组和二重指针的区别。楼主的multip函数里,如果实参是二维数组,这样定义还是有一点点问题,因为这个n要用一个宏或确定值才行。如果是二重指针是实参,那么形参就要用**c了。

形参和实参建议楼主学习一下,二重指针和二维数组的区别已经形参和实参的内容,建议都要对比学习一下吧

a,b是一级指针分配的一维数组,那形参用int* a和int* b或int a【】和int b【】,那如果我事先输入n,然后再动态分配二维数组,形参是不是可以用int c【】【n】不用int **c这样可以吗[/quote]
还是说n不能从主函数输入然后传值,要定义成宏[/quote]

首先这个程序,由于main函数里的实参c是二重指针,所以,你的形参只能用**c
第二,即使实参是二维数组,那么也不能用n这样一个变量,因为n在自定义函数里是未知的,不确定的值。
明白了吗?形参是二维数组的形式,需要确定列数。
AC_YE 2020-11-12
  • 打赏
  • 举报
回复
引用 5 楼 肥牛肉^*^的回复:
[quote=引用 3 楼 自信男孩的回复:]楼主看一下main函数里,n是未初始化的,直接就用这个n申请空间,很明显会有问题。楼主能在n是不确定的情况下使用动态申请空间的方式方向是对的,但是注意有一个先后问题;


    printf("请输入阶数n:\n");
scanf("%d",&n);
int **c=(int**)malloc(n*sizeof(int*));//动态分配二维数组
if (!c)
exit(0);
for(i=0;i<n;i++)
{
c[i]=(int*)malloc(sizeof(int)*n);
if (!c[i])
exit(0);
}

先输入后申请。建议楼主加上判断Malloc的返回值判断;

#include <stdio.h>
#include <stdlib.h>

void show(int v[],int n)//将压缩矩阵转变为原矩阵输出
{
int i,j;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(i>=j)//比较行和列下标
printf("%5d",v[i*(i+1)/2+j]);
else
printf("%5d",v[j*(j+1)/2+i]);
}
printf("\n");
}
}
//void multiply(int va[],int vb[],int c[][n],int n) //这儿的c是二重指针,因此直接用**c即可
void multiply(int va[],int vb[],int **c,int n)
{
int i,j,k,s,op1,op2;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
s=0;
for(k=0;k<n;k++)
{
if(i>=k)//比较行和列的下标,行不变,列改变 k相当于列下标
{
op1=va[i*(i+1)/2+k];
}
else
{
op1=va[k*(k+1)/2+i];
}
if(k>=j)//比较行和列的下标,列不变,行改变 k相当于行下标
{
op2=vb[k*(k+1)/2+j];
}
else
{
op2=vb[j*(j+1)/2+k];
}
s+=op1*op2;
}
c[i][j]=s;
}
}
for(i=0;i<n;i++)//打印二维数组
{
for(j=0;j<n;j++)
{
printf("%5d",c[i][j]);
}
printf("\n");
}
return;
}
void Destroy(int **a,int n)//二维动态数组销毁
{
int i;
for(i=0;i<n;i++)
{
free(a[i]);
}

free(a); //最后也要把a释放了
}
int main()
{
int n,k,i,j;
int *a,*b;

printf("请输入阶数n:\n");
scanf("%d",&n);
int **c=(int**)malloc(n*sizeof(int*));//动态分配二维数组
for(i=0;i<n;i++)
{
c[i]=(int*)malloc(sizeof(int)*n);
}
k=n*(n+1)/2; //k作为一维数组来存储n阶对称矩阵一维数组要求的元素个数
a=(int*)malloc(sizeof(int)*k);//动态分配一维数组a
b=(int*)malloc(sizeof(int)*k);//动态分配一维数组b

printf("生成矩阵A 请输入%d个压缩矩阵中的数:\n",n*(n+1)/2);
for(i=0;i<k;i++)
{
scanf("%d",&a[i]);//输入压缩矩阵元素
}
printf("矩阵A为 :\n");
show(a,n);//将压缩矩阵转变为原矩阵输出


printf("生成矩阵B 请输入%d个压缩矩阵中的数:\n",n*(n+1)/2);
for(i=0;i<k;i++)
{
scanf("%d",&b[i]);////输入压缩矩阵元素
}
printf("矩阵B为 :\n");
show(b,n);//将压缩矩阵转变为原矩阵输出
printf("A*B=:\n");
multiply(a,b,c,n);//返回二维数组的地址
Destroy(c,n);//销毁二维数组
return 0;
}


楼主还是要分清二维数组和二重指针的区别。楼主的multip函数里,如果实参是二维数组,这样定义还是有一点点问题,因为这个n要用一个宏或确定值才行。如果是二重指针是实参,那么形参就要用**c了。

形参和实参建议楼主学习一下,二重指针和二维数组的区别已经形参和实参的内容,建议都要对比学习一下吧
a,b是一级指针分配的一维数组,那形参用int* a和int* b或int a【】和int b【】,那如果我事先输入n,然后再动态分配二维数组,形参是不是可以用int c【】【n】不用int **c这样可以吗[/quote] 还是说n不能从主函数输入然后传值,要定义成宏
AC_YE 2020-11-12
  • 打赏
  • 举报
回复
引用 3 楼 自信男孩的回复:
楼主看一下main函数里,n是未初始化的,直接就用这个n申请空间,很明显会有问题。楼主能在n是不确定的情况下使用动态申请空间的方式方向是对的,但是注意有一个先后问题;


    printf("请输入阶数n:\n");
scanf("%d",&n);
int **c=(int**)malloc(n*sizeof(int*));//动态分配二维数组
if (!c)
exit(0);
for(i=0;i<n;i++)
{
c[i]=(int*)malloc(sizeof(int)*n);
if (!c[i])
exit(0);
}

先输入后申请。建议楼主加上判断Malloc的返回值判断;

#include <stdio.h>
#include <stdlib.h>

void show(int v[],int n)//将压缩矩阵转变为原矩阵输出
{
int i,j;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(i>=j)//比较行和列下标
printf("%5d",v[i*(i+1)/2+j]);
else
printf("%5d",v[j*(j+1)/2+i]);
}
printf("\n");
}
}
//void multiply(int va[],int vb[],int c[][n],int n) //这儿的c是二重指针,因此直接用**c即可
void multiply(int va[],int vb[],int **c,int n)
{
int i,j,k,s,op1,op2;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
s=0;
for(k=0;k<n;k++)
{
if(i>=k)//比较行和列的下标,行不变,列改变 k相当于列下标
{
op1=va[i*(i+1)/2+k];
}
else
{
op1=va[k*(k+1)/2+i];
}
if(k>=j)//比较行和列的下标,列不变,行改变 k相当于行下标
{
op2=vb[k*(k+1)/2+j];
}
else
{
op2=vb[j*(j+1)/2+k];
}
s+=op1*op2;
}
c[i][j]=s;
}
}
for(i=0;i<n;i++)//打印二维数组
{
for(j=0;j<n;j++)
{
printf("%5d",c[i][j]);
}
printf("\n");
}
return;
}
void Destroy(int **a,int n)//二维动态数组销毁
{
int i;
for(i=0;i<n;i++)
{
free(a[i]);
}

free(a); //最后也要把a释放了
}
int main()
{
int n,k,i,j;
int *a,*b;

printf("请输入阶数n:\n");
scanf("%d",&n);
int **c=(int**)malloc(n*sizeof(int*));//动态分配二维数组
for(i=0;i<n;i++)
{
c[i]=(int*)malloc(sizeof(int)*n);
}
k=n*(n+1)/2; //k作为一维数组来存储n阶对称矩阵一维数组要求的元素个数
a=(int*)malloc(sizeof(int)*k);//动态分配一维数组a
b=(int*)malloc(sizeof(int)*k);//动态分配一维数组b

printf("生成矩阵A 请输入%d个压缩矩阵中的数:\n",n*(n+1)/2);
for(i=0;i<k;i++)
{
scanf("%d",&a[i]);//输入压缩矩阵元素
}
printf("矩阵A为 :\n");
show(a,n);//将压缩矩阵转变为原矩阵输出


printf("生成矩阵B 请输入%d个压缩矩阵中的数:\n",n*(n+1)/2);
for(i=0;i<k;i++)
{
scanf("%d",&b[i]);////输入压缩矩阵元素
}
printf("矩阵B为 :\n");
show(b,n);//将压缩矩阵转变为原矩阵输出
printf("A*B=:\n");
multiply(a,b,c,n);//返回二维数组的地址
Destroy(c,n);//销毁二维数组
return 0;
}


楼主还是要分清二维数组和二重指针的区别。楼主的multip函数里,如果实参是二维数组,这样定义还是有一点点问题,因为这个n要用一个宏或确定值才行。如果是二重指针是实参,那么形参就要用**c了。

形参和实参建议楼主学习一下,二重指针和二维数组的区别已经形参和实参的内容,建议都要对比学习一下吧
a,b是一级指针分配的一维数组,那形参用int* a和int* b或int a【】和int b【】,那如果我事先输入n,然后再动态分配二维数组,形参是不是可以用int c【】【n】不用int **c这样可以吗
自信男孩 2020-11-12
  • 打赏
  • 举报
回复
引用 2 楼 肥牛肉^*^ 的回复:
[quote=引用 1 楼 qybao的回复:]void multiply(int va[], int vb[], int c[][n], int n) //这里的int c[][n]的n不是常量,不能这样定义动态数组,要用指针int **c(或者把n定义为宏)。
这个动态数组问题我怎么觉得lz不止一次问过了,怎么还是老犯同样的错误。

换成int**c后编译没问题但在后面执行时突然停止,这是怎么回事?[/quote]
突然停止很可能是main函数里先malloc了,没有先scanf
因为n是一个随机值,数值比较大,导致申请的空间过大吧
自信男孩 2020-11-12
  • 打赏
  • 举报
回复
楼主看一下main函数里,n是未初始化的,直接就用这个n申请空间,很明显会有问题。楼主能在n是不确定的情况下使用动态申请空间的方式方向是对的,但是注意有一个先后问题;


    printf("请输入阶数n:\n");
scanf("%d",&n);
int **c=(int**)malloc(n*sizeof(int*));//动态分配二维数组
if (!c)
exit(0);
for(i=0;i<n;i++)
{
c[i]=(int*)malloc(sizeof(int)*n);
if (!c[i])
exit(0);
}

先输入后申请。建议楼主加上判断Malloc的返回值判断;

#include <stdio.h>
#include <stdlib.h>

void show(int v[],int n)//将压缩矩阵转变为原矩阵输出
{
int i,j;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(i>=j)//比较行和列下标
printf("%5d",v[i*(i+1)/2+j]);
else
printf("%5d",v[j*(j+1)/2+i]);
}
printf("\n");
}
}
//void multiply(int va[],int vb[],int c[][n],int n) //这儿的c是二重指针,因此直接用**c即可
void multiply(int va[],int vb[],int **c,int n)
{
int i,j,k,s,op1,op2;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
s=0;
for(k=0;k<n;k++)
{
if(i>=k)//比较行和列的下标,行不变,列改变 k相当于列下标
{
op1=va[i*(i+1)/2+k];
}
else
{
op1=va[k*(k+1)/2+i];
}
if(k>=j)//比较行和列的下标,列不变,行改变 k相当于行下标
{
op2=vb[k*(k+1)/2+j];
}
else
{
op2=vb[j*(j+1)/2+k];
}
s+=op1*op2;
}
c[i][j]=s;
}
}
for(i=0;i<n;i++)//打印二维数组
{
for(j=0;j<n;j++)
{
printf("%5d",c[i][j]);
}
printf("\n");
}
return;
}
void Destroy(int **a,int n)//二维动态数组销毁
{
int i;
for(i=0;i<n;i++)
{
free(a[i]);
}

free(a); //最后也要把a释放了
}
int main()
{
int n,k,i,j;
int *a,*b;

printf("请输入阶数n:\n");
scanf("%d",&n);
int **c=(int**)malloc(n*sizeof(int*));//动态分配二维数组
for(i=0;i<n;i++)
{
c[i]=(int*)malloc(sizeof(int)*n);
}
k=n*(n+1)/2; //k作为一维数组来存储n阶对称矩阵一维数组要求的元素个数
a=(int*)malloc(sizeof(int)*k);//动态分配一维数组a
b=(int*)malloc(sizeof(int)*k);//动态分配一维数组b

printf("生成矩阵A 请输入%d个压缩矩阵中的数:\n",n*(n+1)/2);
for(i=0;i<k;i++)
{
scanf("%d",&a[i]);//输入压缩矩阵元素
}
printf("矩阵A为 :\n");
show(a,n);//将压缩矩阵转变为原矩阵输出


printf("生成矩阵B 请输入%d个压缩矩阵中的数:\n",n*(n+1)/2);
for(i=0;i<k;i++)
{
scanf("%d",&b[i]);////输入压缩矩阵元素
}
printf("矩阵B为 :\n");
show(b,n);//将压缩矩阵转变为原矩阵输出
printf("A*B=:\n");
multiply(a,b,c,n);//返回二维数组的地址
Destroy(c,n);//销毁二维数组
return 0;
}


楼主还是要分清二维数组和二重指针的区别。楼主的multip函数里,如果实参是二维数组,这样定义还是有一点点问题,因为这个n要用一个宏或确定值才行。如果是二重指针是实参,那么形参就要用**c了。

形参和实参建议楼主学习一下,二重指针和二维数组的区别已经形参和实参的内容,建议都要对比学习一下吧
qybao 2020-11-12
  • 打赏
  • 举报
回复
引用 2 楼 肥牛肉^*^ 的回复:
换成int**c后编译没问题但在后面执行时突然停止,这是怎么回事?

突然停止是什么现象?是你输入的数据不够,系统等待你的输入吧?
具体描述一下问题现象,或者把截图贴出来。
qybao 2020-11-11
  • 打赏
  • 举报
回复
void multiply(int va[], int vb[], int c[][n], int n) //这里的int c[][n]的n不是常量,不能这样定义动态数组,要用指针int **c(或者把n定义为宏)。 这个动态数组问题我怎么觉得lz不止一次问过了,怎么还是老犯同样的错误。

69,335

社区成员

发帖
与我相关
我的任务
社区描述
C语言相关问题讨论
社区管理员
  • C语言
  • 花神庙码农
  • 架构师李肯
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧