El uso de malloc para la asignación de matrices multidimensionales con diferentes longitudes fila

Question

tengo el C siguiente código:

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

que funciona muy bien. Pero si tengo el siguiente:

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

donde cada elemento de b tiene una longitud diferente.

¿Cómo es posible hacer lo mismo para b como lo hice para a; es decir, el siguiente código sería válido?

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

Answer 1

En primer lugar, es necesario asignar matriz de punteros como char **c = malloc(N * sizeof(char*)), a continuación, asignar a cada fila con un separada llamar a malloc, probablemente en el bucle:

/* 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'; 

Si conoce el número total de elementos (por ejemplo N*M) se puede hacer esto en una sola asignación.

Answer 2

Si todos los elementos de b tiene diferentes longitudes, entonces usted necesita para hacer algo como:

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

Answer 3

Creo que un enfoque de 2 pasos es mejor, porque las matrices c 2-d son justas y la matriz de matrices. El primer paso es asignar una única matriz, luego recorrerla asignando matrices para cada columna sobre la marcha. This article da buenos detalles.

Answer 4

La forma típica para asignar dinámicamente una matriz NxM de tipo T es

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

Si cada elemento de la matriz tiene una longitud diferente, entonces reemplazar M con la longitud apropiada para ese elemento; por ejemplo

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

Answer 5

El otro enfoque sería asignar un trozo contiguo de memoria que comprende bloque de cabecera para los punteros a las filas, así como bloque de cuerpo para almacenar datos reales en filas. A continuación, simplemente marque la memoria asignando direcciones de memoria en el cuerpo a los punteros en el encabezado por fila. Se vería como sigue:

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; 
} 

La ventaja de este enfoque es elegante liberación de la memoria y la capacidad de utilizar la notación de matriz similar a acceder a los elementos de la matriz 2D resultante.

Answer 6

La asignación de memoria equivalente para char a[10][20] sería la siguiente.

char **a; 

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

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

Espero que esto parezca simple de entender.

Answer 7

malloc no se asigna en límites específicos, por lo que se debe suponer que se asigna en un límite de bytes.

El puntero devuelto no se puede utilizar si se convierte a otro tipo, ya que el acceso a ese puntero probablemente producirá una violación de acceso a la memoria por parte de la CPU y la aplicación se cerrará inmediatamente.

Answer 8

2-D de matriz de asignación de memoria dinámica

int **a,i; 

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