Zuordnung zusammenhängenden Speicher zu einem 2D-Array post-Erklärung

Question

Ich verstehe, dass moderne C-Normen mir einen Speicherblock zu einem 2D-Array zuweisen können wie folgt:

size_t rows, cols; 
// assign rows and cols 
int (*arr)[cols] = malloc(sizeof(double[cols][rows])); 

Aber ist es eine Möglichkeit, einen Block von der Zuteilung Speicher zu einem 2d-Array nach einer Deklaration? Z.B. Ich habe eine externe Variable deklariert an anderer Stelle möchte ich Speicher zuweisen möchten:

size_t rows, cols; 
extern int **arr; 

//Malloc block to 2d array 

Ich weiß, es ist möglich, beispielsweise einen einzigen Index anstelle von 2 verwenden [i] [j] -> [i * Zeilen + j] aber ich frage mich, ob ich die 2 Indizes behalten kann?

Answer 1

Den Zeiger und den spitzen Bereich gleichzeitig sichern.

wie diese

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

int **arr; 

int **Malloc_block_to_2d_array(size_t rows, size_t cols){ 
    int **arr = malloc(rows * sizeof(*arr) + rows * cols * sizeof(**arr)); 
    if(arr){ 
     char *body_top = (char*)arr + rows * sizeof(*arr); 
     for(size_t r = 0; r < rows; ++r){ 
      arr[r] = (int *)(body_top + r * cols * sizeof(**arr)); 
     } 
    } 
    return arr; 
} 

int main(void){ 
    //DEMO 
    size_t rows = 3; 
    size_t cols = 5; 

    arr = Malloc_block_to_2d_array(rows, cols); 
    for(size_t r = 0; r < rows; ++r) 
     for(size_t c = 0; c < cols; ++c) 
      arr[r][c] = (r+1)*10 + c+1; 

    for(size_t r = 0; r < rows; ++r){ 
     for(size_t c = 0; c < cols; ++c) 
      printf("%d ", arr[r][c]); 
     puts(""); 
    } 
    free(arr); 
} 

Answer 2

können Sie nicht zwei Indizes "behalten", weil extern int **arr keine zusammenhängenden 2D-Array deklarieren. Es ist ein Array von Zeigern, daher unterscheidet sich der Mechanismus zum Anwenden zweier Indizes, der vom Compiler verwendet wird, sehr von dem Mechanismus, der für 2D-Arrays verwendet wird.

Der größte Unterschied besteht darin, dass der Zugriff auf 2D-Array erfordert, dass der Compiler den Wert cols kennt, während der Zugriff auf ein Array von Zeigern nicht funktioniert.

Die Erklärung

int (*arr)[cols] = malloc(sizeof(double[cols][rows])); 

ist eine Variable-length-Array. Dies ist im statischen Kontext nicht zulässig, daher kann nicht global sein.

Sie könnten ein Array von Zeigern zu einem zusammenhängenden Block machen. Zwei-Indexausdruck funktionieren wird, auf Kosten eines zusätzlichen Array Zuweisung:

// In the header 
extern size_t rows, cols; 
extern double **arr; 

// In the C file 

size_t rows, cols; 
double **arr; 

void init_array(size_t r, size_t c) { 
    rows = r; 
    cols = c; 
    double (*a)[cols] = malloc(sizeof(double[cols][rows])); 
    arr = malloc(rows*sizeof(double*)); 
    for (size_t i = 0 ; i != rows ; i++) { 
     arr[i] = a[i]; 
    } 
} 
void free_array() { 
    free(arr[0]); 
    free(arr); 
} 

Demo.