Définir des pointeurs sur la masortingce dynamic

J’essaie de créer une masortingce de taille dynamic composée d’éléments de 1 octet. Pour ce faire, j’ai défini la fonction suivante. Le problème survient lorsque j’essaie de définir les premiers éléments “nrows” de la masortingce pour qu’ils pointent sur la ligne correspondante (je peux donc faire la masortingce [i] [j]). Cela ressemble à cette masortingx[i] = masortingx[nrows + i * single_row_elements_bytes]; ne fonctionne pas assez bien (le programme comstack mais génère une erreur de violation de segment principal). Comment puis-je faire ce travail?

 uint8_t **NewMasortingx(unsigned nrows, unsigned ncols) { uint8_t **masortingx; size_t row_pointer_bytes = nrows * sizeof *masortingx; size_t single_row_elements_bytes = ncols * sizeof **masortingx; masortingx = malloc(row_pointer_bytes + nrows * single_row_elements_bytes); unsigned i; for(i = 0; i < nrows; i++) matrix[i] = matrix[nrows + i * single_row_elements_bytes]; return matrix; } 

Hormis divers bugs mentionnés dans une autre réponse, vous n’atsortingbuez pas correctement le tableau 2D. En fait, vous n’allouez pas du tout un tableau 2D, mais une table de consultation lente et fragmentée.

La méthode correcte pour allouer un tableau 2D de manière dynamic est décrite à la section Comment puis-je configurer, accéder et libérer correctement un tableau multidimensionnel en C? . Des explications détaillées sur son fonctionnement et sur le fonctionnement des pointeurs de tableau sont expliquées dans Fonction pour allouer de manière dynamic la masortingce .

Voici un exemple utilisant les techniques décrites ci-dessus, pour votre cas spécifique:

 #include  #include  #include  #include  void NewMasortingx (size_t nrows, size_t ncols, uint8_t (**masortingx)[nrows][ncols]) { *masortingx = malloc ( sizeof (uint8_t[nrows][ncols]) ); } int main (void) { size_t r = 3; size_t c = 4; uint8_t (*arr_ptr)[r][c]; NewMasortingx(r, c, &arr_ptr); uint8_t (*masortingx)[c] = arr_ptr[0]; uint8_t count=0; for(size_t i=0; i 

Je pense que votre code pose quelques problèmes.

  • Vous pouvez simplifier cette ligne:

     masortingx = malloc(row_pointer_bytes + nrows * single_row_elements_bytes); 

    à:

     masortingx = malloc(row_pointer_bytes); 

    Ce qui alloue de l’espace pour uint8_t* nombreuses lignes de la masortingce.

    La fonction malloc() requirejs uniquement size_t nombre d’octets nécessaires pour allouer la mémoire demandée sur le size_t de mémoire, et renvoie un pointeur sur celle-ci.

    et cela peut simplement être alloué en sachant combien de lignes sont nécessaires dans la masortingce, dans ce cas.

  • De plus, votre boucle for:

     for(i = 0; i < nrows; i++) matrix[i] = matrix[nrows + i * single_row_elements_bytes]; 

    N'alloue pas de mémoire pour la masortingx[i] , car chaque ligne comporte n colonnes et vous devez allouer de la mémoire pour ces colonnes.

    Cela devrait plutôt être:

     for(i = 0; i < nrows; i++) matrix[i] = malloc(single_row_elements_bytes); 
  • Un autre problème est de savoir comment allouer single_row_elements_bytes . Au lieu de:

     size_t single_row_elements_bytes = ncols * sizeof **masortingx; //**masortingx is uint8_t** 

    Cela nécessite d'allouer uint8_t octets pour n colonnes et non uint8_t** octets. Cela peut être ceci à la place:

     size_t single_row_elements_bytes = ncols * sizeof(uint8_t); 

Ceci dit, votre code sera compilé s'il est écrit comme ceci. Ceci est un exemple que j'ai écrit pour tester le code.

 #include  #include  #include  #include  uint8_t **NewMasortingx(unsigned nrows, unsigned ncols); int main(int argc, char *argv[]) { uint8_t **returnmasortingx; unsigned nrows = 2, ncols = 2; int i, j; returnmasortingx = NewMasortingx(nrows, ncols); for (i = 0; i < nrows; i++) { for (j = 0; j < ncols; j++) { printf("Enter number for row %d column %d: ", i+1, j+1); /* format speficier for uint8_t, from  */ if (scanf("%"SCNu8"", &returnmasortingx[i][j]) != 1) { printf("Invalid 8 bit number.\n"); exit(EXIT_FAILURE); } } } printf("\nYour masortingx:\n"); for (i = 0; i < nrows; i++) { for (j = 0; j < ncols; j++) { printf("%d ", returnmatrix[i][j]); } printf("\n"); } /* Good to free at the end */ free(returnmatrix); return 0; } uint8_t **NewMatrix(unsigned nrows, unsigned ncols) { int i; uint8_t **matrix; size_t row_pointer_bytes = nrows * sizeof * matrix; size_t column_row_elements_bytes = ncols * sizeof(uint8_t); matrix = malloc(row_pointer_bytes); /* Good to check return value */ if (!matrix) { printf("Cannot allocate memory for %d rows.\n", nrows); exit(EXIT_FAILURE); } for(i = 0; i < nrows; i++) { matrix[i] = malloc(column_row_elements_bytes); if (!matrix[i]) { printf("Cannot allocate memory for %d columns.\n", ncols); exit(EXIT_FAILURE); } } return matrix; } 

Consortingbution:

 Enter number for row 1 column 1: 1 Enter number for row 1 column 2: 2 Enter number for row 2 column 1: 3 Enter number for row 2 column 2: 4 

Sortie:

 Your masortingx: 1 2 3 4 

Compilé avec:

 gcc -Wall -o masortingx masortingx.c 
  for (i=0;i 

Les 2 lignes ci-dessous doivent être remplacées par les 2 lignes ci-dessus

  for(i = 0; i < nrows; i++) matrix[i] = matrix[nrows + i * single_row_elements_bytes]; 

avec (nrows + i * single_row_elements_bytes) comme taille d'allocation, et avec nrows = 5 et ncols =5 , disons, un total de 65 octets est alloué. Cela inclut 40 octets pour stocker les pointeurs de ligne (en supposant une taille de pointeur de 64 bits) et 25 octets pour stocker le contenu de chaque élément r, c. Mais la mémoire pour le pointeur de colonne (pointeur vers chaque élément de cette ligne) n'est pas allouée.

Donc, la masortingx[i][j] déréférencement masortingx[i][j] va segmenter la faute.