Question

我正在编写一个C程序来转置矩阵并测试它我有一个结构，其中包含指向一组指针的指针，我在一个单独的函数中使用malloc分配内存。现在， 我的问题是： 我可以按以下格式初始化矩阵吗？：

cases[0].matq={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
cases[0].matq={1,5,9,13,2,6,10,14,3,7,11,15,4,8,12,16}; //or like this

where case是一个struct类型的数组。

Answer 1

不要使用指向显式分配内存的指针集的指针，为什么不执行以下操作：以常规方式存储2D数组，然后让结构中的指针指向它。我制作了一个迷你完整（编译，运行）程序来展示它是如何工作的（注意 - 这是在@ryyker的评论之后编辑的）：

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

int main(void) {

  int A[4][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}; // conventional initialization
  int **pp; // this is really an element of your structure
  pp = malloc(4 * sizeof (int *)); // four pointers to int

  int ii, jj;
  for(ii=0; ii<4; ii++) pp[ii] = &A[ii][0]; // point to the original matrix

  // show that it works:
  for(ii=0; ii<4; ii++) {
    for(jj=0; jj<4; jj++) {
      printf("%d ", pp[ii][jj]);
    }
    printf("\n");
  }
}

这给出了您期望的输出：

1 2 3 4 
5 6 7 8 
9 10 11 12 
13 14 15 16

正如您所看到的，使用此代码，数组在＆＃34; normal＆＃34;中初始化。方法，您可以通过双重解除引用来处理此数组中的元素。没有拷贝 - 你需要的只是指针数组。

我不清楚为什么你在做你正在做的事情;所以可能这种方法对你不起作用 - 但在这种情况下，我相信你会在评论中告诉我，我们可以调整它。

进一步更新

基于各种评论，或许这是思考问题的好方法：

// all the test cases in a 3D array:
int testCases[5][4][4]={ \
    {{1,2,3,4},{2,3,4,5},{3,4,5,6},{4,5,6,7}}, \
    {{2,3,4,5},{3,4,5,6},{4,5,6,7},{1,2,3,4}}, \
    {{3,4,5,6},{4,5,6,7},{1,2,3,4},{2,3,4,5}}, \
    {{4,5,6,7},{1,2,3,4},{2,3,4,5},{3,4,5,6}}};

int **pp; // this is really an element of your structure
pp = malloc(4 * sizeof (int *)); // four pointers to int
                                 // only allocate once
int ii, jj; // usual counters
int **qq; // place for the result

// create space: now we need two calls to malloc to get both the pointers, and the space
qq = malloc(4 * sizeof(int*));
qq[0]=malloc(4*4*sizeof(int)); // total block is 16 int long
for(ii=1;ii<4;ii++) qq[ii] = qq[0] + ii * 4 * sizeof(int); // set up other pointers

int tc;
for(tc = 0; tc < 5; tc++) { // loop over the test cases
  // make pp point to a test case
  for(ii=0; ii<4; ii++) pp[ii] = &testCases[tc][ii][0];
  doTranspose(pp, qq); // assuming that the result of transposing pp is in qq
  printMatrix(qq);     // some code that prints the result
}

您的doTranspose可能如下：

void doTranspose(int **pp, int **qq) {
  int ii, jj;
  for(ii=0; ii<4; ii++) {
    for(jj=0; jj<4; jj++) {
      qq[ii][jj] = pp[jj][ii];
    }
  }
}

将结果复制到不同的矩阵使代码更容易一些。如果你想进行就地转置，你可以做

void inplaceTranspose(int **pp) {
  int ii, jj, temp;
  for(ii=0; ii<4; ii++) {
    for(jj=0; jj<4; jj++) {
      temp = pp[ii][jj];
      pp[ii][jj]=pp[jj][ii];
      pp[jj][ii]=temp;
    }
  }
}

void printMatrix(int **pp){
  int ii, jj;
  for(ii=0; ii<4; ii++) {
    for(jj=0; jj<4; jj++) {
      printf("%4d ", pp[ii][jj]);
    }
    printf("\n");
  }
}

Answer 2

关于我可以用以下格式初始化矩阵吗？：

cases[0].matq={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};  
//(even if cases[0].matq happened to be `int **`, which is not defined in your question)

没有。这样做 不合法 ：

或这个：

 int **b={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};

但是， 这是合法的 ：

int b[4][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};

关于 ，我在一个单独的函数中使用malloc分配内存：
由于您使用calloc()为二维数组创建内存，因此您的数组元素已经初始化为0.要进一步分配，请使用循环或顺序语句为每个成员分别分配值。

鉴于您已成功使用malloc()初始化数组，您可以通过以下方式为数组分配伪随机数：

示例：

//...
srand(clock());
for(i=0;i<r;i++)
    for(j=0;j<c;j++)
        b[r][c]=rand();  
//...

整数结构中的双指针

2 个答案: