À l'aide de malloc pour la répartition des multi-dimensions des tableaux avec différentes longueurs de ligne

J'ai le texte suivant C code :

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

qui fonctionne très bien. Mais si j'ai le texte suivant :

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

où chaque élément de b a une longueur différente.

Comment est-il possible de faire la même chose pour b comme je l'ai fait pour a; c'est à dire le code suivant tiendrait-elle correcte?

char *c;
size_t size = 2000*sizeof(char *);
c = (char *) malloc(size);
InformationsquelleAutor asel | 2009-12-28
  1. 76

    Tout d'abord, vous devez allouer un tableau de pointeurs comme char **c = malloc( N * sizeof( char* )), puis allouer chaque ligne avec un appel séparé à malloc, probablement dans la boucle:

    
/* 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 vous connaissez le nombre total d'éléments (par exemple N*M) vous pouvez le faire en une seule allocation.

    • Si vous alloc NM octets en une seule opération, puis vous remplissez toutes les c[i]s manuellement: c[i] = p + M, i;
    • Cela dépend de la c type - si c'est char**, alors oui, si c'est un char*, alors que l'indexation des changements: element[i][j] ~ c[i*M + j].
    • N Fetissov, il y a beaucoup de mallocs dans le code, comment cela peut-il être tous libérés? par ailleurs, l'utilisation de boucles for?
    • oui, un free pour chaque malloc. Vous devez faire une boucle par la char* variables en les libérant, puis libérer le char**.
    • J'ai vu la même dans un livre, il est dit: "...la mémoire n'est pas garanti d'être contiguës."?
    InformationsquelleAutor Nikolai Fetissov
  2. 48

    La forme typique pour allouer dynamiquement un NxM tableau de type T est

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

    Si chaque élément de la matrice a une longueur différente, puis remplacez M à la longueur appropriée pour cet élément; par exemple

    T **a = malloc(sizeof *a * N);
if (a)
{
  for (i = 0; i < N; i++)
  {
    a[i] = malloc(sizeof *a[i] * length_for_this_element);
  }
}
    • Si j'ai le nombre total de int est que je vais avoir, mais pas combien de personnes vont aller dans chaque tableau, comment dois-je procéder?
    • Réponse très claire, je vous remercie! Pourriez-vous aussi ajouter une description de l'ordre dans lequel correctement free la mémoire allouée?
    • En général, libre dans l'ordre inverse vous avez alloué, à chaque a[i] d'abord, puis de gratuit a.
    InformationsquelleAutor John Bode
  3. 28

    Équivalent de l'allocation de mémoire pour char a[10][20] serait comme suit.

    char **a;

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

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

    J'espère que cela a l'air simple à comprendre.

    InformationsquelleAutor Ramesh
  4. 10

    L'autre approche serait d'allouer un espace contigu de mémoire comprenant bloc d'en-tête des pointeurs vers les lignes ainsi que des corps de bloc pour stocker des données réelles dans les lignes. Ensuite, il suffit de marquer la mémoire par l'attribution d'adresses de la mémoire du corps à l'pointeurs dans l'en-tête sur chaque ligne. Il serait comme suit:

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

    L'avantage de cette approche est à la fois élégante et libération de la mémoire et de la capacité à utiliser semblable au tableau de notation pour accéder aux éléments de l'résultant tableau 2D.

    • Quelque chose à noter: cette solution fonctionnent généralement mieux avec le respect de la cohérence du cache, comme les lignes individuelles sont garantis d'être contiguës, contrairement à d'autres approches, qui allouent une ligne à la fois, et peut conduire à une matrice dont les éléments sont dispersés dans toute grande fragmentation du tas.
    • Ce qui malheureusement a aussi le côté-effet de ne pas garantir l'alignement pour les non-pointeur de la taille des types. Ex: un système avec des pointeurs 32 bits et 64 bits des chambres doubles avec un nombre impair de lignes sera le début de la première colonne de la rangée de double sur un cas de non-alignement de la frontière double. C'est très important ceci est pris en compte, car il peut facilement conduire à une erreur de bus à cause d'un mauvais alignement des données. Une solution générale doit s'assurer que les données-les lignes commencent sur une limite de 8 octets, de décisions d'allocation supplémentaire d'espace et d'ajuster en conséquence lors de l'affectation de pointeurs à la primaire pointeur de segment.
    • Où en êtes-vous de déclarercolumnSizes[]?
    InformationsquelleAutor Dmitry Aleks
  5. 3

    Si chaque élément de b a différentes longueurs, alors vous devez faire quelque chose comme:

    int totalLength = 0;
for_every_element_in_b {
    totalLength += length_of_this_b_in_bytes;
}
return (char **)malloc(totalLength);
    • Il n'a pas d'allouer de la mémoire pour un 1-dimensions tableau de char* pointeurs.
    InformationsquelleAutor plinth
  6. 2

    Je pense qu'une des 2 étapes de l'approche est la meilleure, parce que c 2-d les tableaux sont juste et tableau de tableaux. La première étape consiste à allouer un tableau unique, puis la boucle à travers elle allocation des tableaux pour chaque colonne que vous allez. Cet article donne de bons détails.

    InformationsquelleAutor zdav
  7. 1

    2-D De La Matrice De L'Allocation De Mémoire Dynamique

    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));
    InformationsquelleAutor Sridhar T
  8. 0

    malloc n'alloue pas sur les limites précises, de sorte qu'il doit être présumé qu'elle alloue sur une frontière d'octet.

    Le pointeur retourné peut alors pas être utilisé si converti en un autre type, car l'accès à ce pointeur sera probablement produire une violation d'accès mémoire par le CPU, et la demande sera immédiatement arrêté.

    InformationsquelleAutor Vendicar Decarian