C语言-将矩阵表示为指针数组

我试图将矩阵表示为指针数组，然后对矩阵执行某些操作

为了进一步简化，假设一个矩阵有

n

行和

m

列

我定义了一个

int**matrix

，它指向大小为

n

的数组（指针）的开头。这个数组中的每个块都是一个指针，指向一个大小为

m

的数组（整数）。结果是清楚的。您有

n

指针，每个指针指向

m

整数数组，总的

nxm

值。因此，用这种方式表示矩阵应该是可能的

我的问题是，我不知道如何访问矩阵的整数值。例如，假设我希望在矩阵中插入值。如何访问

矩阵[I][j]

这是我的代码，你可以看到它是不完整的，我将感谢帮助完成它

int** create_matrix(int rows,int columns)
{
    int** matrix,i;
    matrix=(int**)malloc(rows*sizeof(int*));
    for(i=0;i<rows;i++)
        *(matrix)+i=(int*)malloc(columns*sizeof(int));
    for(i=0;i<rows;i++)
    {
        for(j=0;j<columns;j++)
            *(*(matrix)+i)

int**create_矩阵（int行，int列）
{
int**矩阵，i；
矩阵=（int**）malloc（行*sizeof（int*）；
对于（i=0；i任何类型
T
的一般模式为

T **arr = malloc( rows * sizeof *arr );
if ( arr )
{
  for ( size_t i = 0; i < rows; i++ )
  {
    arr[i] = malloc( columns * sizeof *arr[i] );
    if ( arr[i] )
    {
      for ( size_t j = 0; j < columns; j++ )
      {
        arr[i][j] = some_value;
      }
    }
    else
      // memory allocation failure
  }
}
else
  // memory allocation failure.

T**arr=malloc（行*sizeof*arr）；
如果（arr）
{
对于（大小i=0；i

数组下标是根据指针算法定义的：
a[i]
被定义为
*（a+i）
a[i][j]
被定义为
*（*（a+i）+j）
任何类型
T
的一般模式是

T **arr = malloc( rows * sizeof *arr );
if ( arr )
{
  for ( size_t i = 0; i < rows; i++ )
  {
    arr[i] = malloc( columns * sizeof *arr[i] );
    if ( arr[i] )
    {
      for ( size_t j = 0; j < columns; j++ )
      {
        arr[i][j] = some_value;
      }
    }
    else
      // memory allocation failure
  }
}
else
  // memory allocation failure.

T**arr=malloc（行*sizeof*arr）；
如果（arr）
{
对于（大小i=0；i

数组下标是根据指针算法定义的：
a[i]
被定义为
*（a+i）
a[i][j]
被定义为
*（*（a+i）+j）
任何类型
T
的一般模式是

T **arr = malloc( rows * sizeof *arr );
if ( arr )
{
  for ( size_t i = 0; i < rows; i++ )
  {
    arr[i] = malloc( columns * sizeof *arr[i] );
    if ( arr[i] )
    {
      for ( size_t j = 0; j < columns; j++ )
      {
        arr[i][j] = some_value;
      }
    }
    else
      // memory allocation failure
  }
}
else
  // memory allocation failure.

T**arr=malloc（行*sizeof*arr）；
如果（arr）
{
对于（大小i=0；i

数组下标是根据指针算法定义的：
a[i]
被定义为
*（a+i）
a[i][j]
被定义为
*（*（a+i）+j）
任何类型
T
的一般模式是

T **arr = malloc( rows * sizeof *arr );
if ( arr )
{
  for ( size_t i = 0; i < rows; i++ )
  {
    arr[i] = malloc( columns * sizeof *arr[i] );
    if ( arr[i] )
    {
      for ( size_t j = 0; j < columns; j++ )
      {
        arr[i][j] = some_value;
      }
    }
    else
      // memory allocation failure
  }
}
else
  // memory allocation failure.

T**arr=malloc（行*sizeof*arr）；
如果（arr）
{
对于（大小i=0；i

数组下标是根据指针算术定义的：
a[i]
定义为
*（a+i）
a[i][j]
定义为
*（*（a+i）+j）
int**matrix，i，j；
矩阵=malloc（行*sizeof（int*）；
对于（i=0；i
int**矩阵，i，j；
矩阵=malloc（行*sizeof（int*）；
对于（i=0；i
int**矩阵，i，j；
矩阵=malloc（行*sizeof（int*）；
对于（i=0；i
int**矩阵，i，j；
矩阵=malloc（行*sizeof（int*）；
对于（i=0；i请尝试以下代码-

int** create_matrix(int rows,int columns)
{
   int** matrix,i;
   matrix=(int**)malloc(rows*sizeof(int*));
   for(i=0;i<rows;i++)
      matrix[i]=(int*)malloc(columns*sizeof(int)); // Fix 1
   for(i=0;i<rows;i++)
   {
      for(j=0;j<columns;j++)
         *(*(matrix+i)+j)=rand();
    }
    return matrix;
 }

int**create_矩阵（int行，int列）
{
int**矩阵，i；
矩阵=（int**）malloc（行*sizeof（int*）；
对于（i=0；i请尝试以下代码-

int** create_matrix(int rows,int columns)
{
   int** matrix,i;
   matrix=(int**)malloc(rows*sizeof(int*));
   for(i=0;i<rows;i++)
      matrix[i]=(int*)malloc(columns*sizeof(int)); // Fix 1
   for(i=0;i<rows;i++)
   {
      for(j=0;j<columns;j++)
         *(*(matrix+i)+j)=rand();
    }
    return matrix;
 }

int**create_矩阵（int行，int列）
{
int**矩阵，i；
矩阵=（int**）malloc（行*sizeof（int*）；
对于（i=0；i请尝试以下代码-

int** create_matrix(int rows,int columns)
{
   int** matrix,i;
   matrix=(int**)malloc(rows*sizeof(int*));
   for(i=0;i<rows;i++)
      matrix[i]=(int*)malloc(columns*sizeof(int)); // Fix 1
   for(i=0;i<rows;i++)
   {
      for(j=0;j<columns;j++)
         *(*(matrix+i)+j)=rand();
    }
    return matrix;
 }

int**create_矩阵（int行，int列）
{
int**矩阵，i；
矩阵=（int**）malloc（行*sizeof（int*）；
对于（i=0；i请尝试以下代码-

int** create_matrix(int rows,int columns)
{
   int** matrix,i;
   matrix=(int**)malloc(rows*sizeof(int*));
   for(i=0;i<rows;i++)
      matrix[i]=(int*)malloc(columns*sizeof(int)); // Fix 1
   for(i=0;i<rows;i++)
   {
      for(j=0;j<columns;j++)
         *(*(matrix+i)+j)=rand();
    }
    return matrix;
 }

int**create_矩阵（int行，int列）
{
int**矩阵，i；
矩阵=（int**）malloc（行*sizeof（int*）；
对于（i=0；i）您可以按照您编写的方式访问它：
matrix[i][j]
。哦，顺便说一句，在C语言中，您不需要指针算法吗？如果我想这样做的话？只是为了让我知道如何做
*（*（matrix+i）+j）=random（）
，那么您应该记住（或学习）那
*（array\u或\u pointer+X）
相当于
数组或指针[X]
。你可以按照你编写的方式访问它：
矩阵[i][j]
。哦，顺便说一句，在C语言中，你不需要指针算法。如果我想做的话？只要我知道如何做
*（*（矩阵+i）+j）=random（）；
那么你应该记住（或学习）
*（array_或_pointer+X）
相当于
array_或_pointer[X]
。你可以按照你写的方式访问它：
matrix[i][j]
。哦，顺便说一句，在C语言中，你不需要指针算法。如果我还想做的话？只要我知道如何做
*（*（matrix+i）+j）=random（）；
，你就应该记住（或学习）那
*（array\u或\u pointer+X）
相当于
array\u或\u pointer[X]
。你用你写的方式来访问它：
矩阵[i][j]
。哦，顺便说一句，在C语言中。那么指针算法是不需要的吗？如果我想做的话？只是为了让我知道怎么做
*（*（matrix+i）+j）=random（）
那么你应该记住（或学习）
*（数组或指针+X）
相当于
数组或指针[X]
。