如何使用动态内存分配处理C中的矩阵？

我试图运行一个模拟，其中我需要填充三个大小为“2xiterations”的矩阵，这是（iterations=）10^8列和2行。我还研究了大小为10^8的向量t。使用动态内存分配，我编写了以下代码：

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

#define T 10000
#define dt 0.0001
#define iterations (T/dt)

/*(more code)*/
int main(){
  int i, j;
  double *t;
  double (*x)[2], (*y)[2], (*c)[2];

  t=(double *) malloc((iterations-1)*sizeof(double));
  x=(double (*)[2]) malloc((2*(iterations))*sizeof(double));
  y=(double (*)[2]) malloc((2*(iterations))*sizeof(double));
  c=(double (*)[2]) malloc((2*(iterations))*sizeof(double));

  for(i=0; i=1; i++){
   x[i][0]=50+500*i;
   y[i][0]=300;
   c[i][0]=15;
  }

  for(j=0; j<=iterations-2; j++){
   t[j+1]=t[j]+dt;
   /*(more code)*/
   printf("%G %G %G %G %G %G\n",x[0][j+1],x[1][j+1],y[0][j+1],y[1][j+1],c[0][j+1],c[1][j+1]);
  }
  return 0;
}

#包括
#包括
#包括
#包括
#定义T 10000
#定义dt 0.0001
#定义迭代次数（T/dt）
/*（更多代码）*/
int main（）{
int i，j；
双*t；
双（*x）[2]，（*y）[2]，（*c）[2]；
t=（双*）malloc（（迭代-1）*sizeof（双））；
x=（double（*）[2]）malloc（（2*（迭代））*sizeof（double））；
y=（double（*）[2]）malloc（（2*（迭代））*sizeof（double））；
c=（double（*）[2]）malloc（（2*（迭代））*sizeof（double））；
对于（i=0；i=1；i++）{
x[i][0]=50+500*i；
y[i][0]=300；
c[i][0]=15；
}
对于（j=0；j
我的意思是，我真的有一个“迭代”大小的向量t吗

既然你减去一，答案是否定的

…和三个大小为“2 x迭代”的矩阵

是的，您有三个大小为“2 x迭代”的矩阵。但是，您的矩阵相当于：

double m[iterations][2];

所以您有“迭代”行和2列

请记住始终检查“内存不足”，即

因此，您可以像这样访问它：

m[0][0]
m[0][1]
m[1][0]
m[1][1]
m[2][0]
m[2][1]
m[3][0]
......

分配矩阵的一般方法：

double **mat_init(int n_rows, int n_cols)
{
    double **m;
    int i;
    m = (double**)malloc(n_rows * sizeof(double*));
    for (i = 0; i < n_rows; ++i)
        m[i] = (double*)calloc(n_cols, sizeof(double));
    return m;
}    
void mat_destroy(int n_rows, double **m)
{
    int i;
    for (i = 0; i < n_rows; ++i) free(m[i]);
    free(m);
}

double**mat\u init（整数行，整数列）
{
双**m；
int i；
m=（双**）malloc（n_行*sizeof（双*）；
对于（i=0；i

您也可以这样做：

double **mat_init2(int n_rows, int n_cols)
{
    double **m;
    int i;
    m = (double**)malloc(n_rows * sizeof(double*));
    m[0] = (double*)calloc(n_rows * n_cols, sizeof(double));
    for (i = 1; i < n_rows; ++i)
        m[i] = m[i-1] + n_cols;
    return m;
}    
void mat_destroy2(double **m)
{
    free(m[0]); free(m);
}

double**mat\u init2（整数行，整数列）
{
双**m；
int i；
m=（双**）malloc（n_行*sizeof（双*）；
m[0]=（双*）calloc（n_行*n列，sizeof（双））；
对于（i=1；i

对于上述两种方法，您可以使用
matrix[row][col]
访问单元格。有时，您可能更喜欢分配单个数组，然后使用
matrix[row*n_cols+col]
访问单元格

顺便说一句，我相信有人会说“不要使用cast”，但使用cast有好处——这是离题的。
除了任何错误和优化之外，只需使用两个变量
x1
和
x2
，即可大大提高可读性。1）不要投出malloc的结果。2）不要使用幻数。3）这不是代码审查服务。你的具体问题是什么？4）注意：
sizeof（*x）
etc.一如既往地给出了数组中单个项的大小。我应该写两个向量而不是一个矩阵吗？我需要一个真正的最佳代码，因为我处理的是大量数据和大量数字。起初，我用倍频程编写了相同的模拟，但为参数输入特定值会使程序在运行ab之后挂起在8小时内…具体的问题是，执行程序时，我得到了错误分段错误（'core'拒绝）OP想要“10^8列和2行”，但声明了
double（*x）[2]
，然后分配
x=（double（*）[2]）malloc（（2*（迭代））*sizeof（double））；
…谢谢！@4386427，你的意思是
double m[2][迭代]
，对吗？问题是我得到了一个分段错误，使用调试器我得到了以下结果：程序接收信号SIGSEGV，分段错误.x[0][0]=50；我不知道出了什么问题……。@S.Proa-不，我实际上是指写了什么。你不应该有问题
x[0][0]
除非你有内存。请看更新的答案。哇，好吧！那么，我是否必须声明
double（*x）[迭代次数]
并分配
x=（double（*）[2]）malloc（（2*（迭代次数））*sizeof（double））；
？或者最好是以下命令：
double**x=（double**）malloc（2*sizeof（double*）；
（i=0；i@S.Proa是的，第一个建议应该可以。除了强制转换，但只需在malloc前面删除强制转换。我会检查malloc和calloc的返回值（不是为了启动宗教战争，但我也更喜欢
double**m=malloc（n_rows*sizeof*m）；
，但是是的，它是OT）指针传递给destroy函数，因为虽然释放空指针是可以的，但取消引用空指针（m[i]或m[0]）是一个运行时错误。
double **mat_init(int n_rows, int n_cols)
{
    double **m;
    int i;
    m = (double**)malloc(n_rows * sizeof(double*));
    for (i = 0; i < n_rows; ++i)
        m[i] = (double*)calloc(n_cols, sizeof(double));
    return m;
}    
void mat_destroy(int n_rows, double **m)
{
    int i;
    for (i = 0; i < n_rows; ++i) free(m[i]);
    free(m);
}

double **mat_init2(int n_rows, int n_cols)
{
    double **m;
    int i;
    m = (double**)malloc(n_rows * sizeof(double*));
    m[0] = (double*)calloc(n_rows * n_cols, sizeof(double));
    for (i = 1; i < n_rows; ++i)
        m[i] = m[i-1] + n_cols;
    return m;
}    
void mat_destroy2(double **m)
{
    free(m[0]); free(m);
}