Verwendung von malloc zur Zuweisung von mehrdimensionalen Arrays mit unterschiedlichen Zeilenlängen

Ich habe folgendes C Code:

int *a;
size_t size = 2000*sizeof(int);
a = malloc(size);

was gut funktioniert. Aber wenn ich folgendes habe:

char **b = malloc(2000*sizeof *b);

wo jedes Element von b hat eine andere Länge.

Wie ist es möglich, dasselbe für zu tun b wie ich für a; dh der folgende Code würde richtig halten?

char *c;
size_t size = 2000*sizeof(char *);
c = malloc(size);

Zuerst müssen Sie ein Array von Zeigern wie zuweisen char **c = malloc( N * sizeof( char* ))und weisen Sie dann jeder Zeile einen separaten Aufruf von zu mallocwahrscheinlich in der Schleife:

/* N is the number of rows  */
/* note: c is char** */
if (( c = malloc( N*sizeof( char* ))) == NULL )
{ /* error */ }

for ( i = 0; i < N; i++ )
{
  /* x_i here is the size of given row, no need to
   * multiply by sizeof( char ), it's always 1
   */
  if (( c[i] = malloc( x_i )) == NULL )
  { /* error */ }

  /* probably init the row here */
}

/* access matrix elements: c[i] give you a pointer
 * to the row array, c[i][j] indexes an element
 */
c[i][j] = 'a';

Wenn Sie die Gesamtzahl der Elemente kennen (z N*M) können Sie dies in einer einzigen Zuordnung tun.

Die typische Form für die dynamische Zuordnung eines NxM-Arrays vom Typ T ist

T **a = malloc(sizeof *a * N);
if (a)
{
  for (i = 0; i < N; i++)
  {
    a[i] = malloc(sizeof *a[i] * M);
  }
}

Wenn jedes Element des Arrays eine andere Länge hat, ersetzen Sie M durch die entsprechende Länge für dieses Element; zum Beispiel

T **a = malloc(sizeof *a * N);
if (a)
{
  for (i = 0; i < N; i++)
  {
    a[i] = malloc(sizeof *a[i] * length_for_this_element);
  }
}

Äquivalente Speicherzuweisung für char a[10][20] wäre wie folgt.

char **a;

a=malloc(10*sizeof(char *));

for(i=0;i<10;i++)
    a[i]=malloc(20*sizeof(char));

Ich hoffe, das sieht einfach verständlich aus.

Der andere Ansatz wäre, einen zusammenhängenden Speicherblock zuzuweisen, der einen Header-Block für Zeiger auf Zeilen sowie einen Body-Block zum Speichern tatsächlicher Daten in Zeilen umfasst. Markieren Sie dann einfach den Speicher, indem Sie die Adressen des Speichers im Körper den Zeigern im Header auf Zeilenbasis zuweisen. Es würde wie folgt aussehen:

int** 2dAlloc(int rows, int* columns) {    
    int header = rows * sizeof(int*);

    int body = 0;
    for(int i=0; i<rows; body+=columnSizes[i++]) {  
    }
    body*=sizeof(int);

    int** rowptr = (int**)malloc(header + body);

    int* buf  = (int*)(rowptr + rows);
    rowptr[0] = buf;
    int k;
    for(k = 1; k < rows; ++k) {
        rowptr[k] = rowptr[k-1] + columns[k-1];
    }
    return rowptr;
}

int main() {
    // specifying column amount on per-row basis
    int columns[] = {1,2,3};
    int rows = sizeof(columns)/sizeof(int);
    int** matrix = 2dAlloc(rows, &columns);

    // using allocated array
    for(int i = 0; i<rows; ++i) {
        for(int j = 0; j<columns[i]; ++j) {
            cout<<matrix[i][j]<<", ";
        }   
            cout<<endl;
    }

    // now it is time to get rid of allocated 
    // memory in only one call to "free"
    free matrix;
}

Der Vorteil dieses Ansatzes ist das elegante Freigeben von Speicher und die Fähigkeit, eine Array-ähnliche Notation zu verwenden, um auf Elemente des resultierenden 2D-Arrays zuzugreifen.

Wenn jedes Element in b unterschiedliche Längen hat, müssen Sie so etwas tun:

int totalLength = 0;
for_every_element_in_b {
    totalLength += length_of_this_b_in_bytes;
}
return malloc(totalLength);

Ich denke, ein 2-Schritt-Ansatz ist am besten, weil c 2-d-Arrays nur ein Array von Arrays sind. Der erste Schritt besteht darin, ein einzelnes Array zuzuweisen, dann eine Schleife durchzugehen und dabei Arrays für jede Spalte zuzuweisen. Dieser Artikel gibt gute Details.

Dynamische 2-D-Array-Speicherzuweisung

int **a,i;

// for any number of rows & columns this will work
a = malloc(rows*sizeof(int *));
for(i=0;i<rows;i++)
    *(a+i) = malloc(cols*sizeof(int));