Maîtriser les membres de tableaux flexibles dans les structures C pour la gestion dynamique des données

Membres du tableau flexibles est utilisé pour gérer des tableaux à l’intérieur de structures sans définir leur taille. Ces tableaux obtiennent leur taille au moment de l'exécution. Une structure en C est un type de données défini par l'utilisateur dans lequel nous définissons ensemble plusieurs membres de différents types de données sous un même nom.

Vous trouverez ci-dessous la syntaxe pour déclarer une structure en C −

struct StructName {
 data_type member1;
 data_type member2;
 // ...
};

Ici, chaque membre peut avoir un type de données différent .

Membres du tableau flexibles étendre les structures en conservant un tableau de taille dynamique à l'extrémité de leurs membres de taille fixe et tous ensemble stockés dans un seul bloc de mémoire. Dans ce chapitre, nous verrons comment ils fonctionnent à l'intérieur des structures.

Membres de tableau flexibles dans la structure

Un membre de tableau flexible est un tableau à l'intérieur d'une structure sans taille fixe, et sa mémoire est allouée dynamiquement au moment de l'exécution à l'aide de malloc() , calloc() , ou des fonctions similaires et il est déclaré à l'aide de crochets vides [] .

Le membre du tableau flexible doit être déclaré à la fin de la structure, et il doit y avoir au moins un autre membre avant de le déclarer.

Voici la syntaxe pour déclarer un tableau flexible membre à l'intérieur d'une structure −

struct StructName {
 data_type member1;
 data_type flexible_array[]; // flexible array member
};

Ici, data_type est le type de données du tableau et arrayName[] est le tableau flexible sans taille fixe.

Allocation de mémoire pour un membre de tableau flexible

Un membre de tableau flexible n'a pas de taille fixe, le compilateur ne lui alloue donc aucune mémoire à l'intérieur de la structure. L'opérateur sizeof calcule uniquement la taille des membres fixes de la structure sans inclure le membre flexible du tableau. C'est pourquoi nous devons allouer la mémoire manuellement lors de la création de telles structures.

La mémoire totale requise est calculée comme suit :−

Total Memory = sizeof(structure) + (number of elements x sizeof(element type))

Ici, sizeof(structure) donne la mémoire pour les membres fixes, et (nombre d'éléments x taille de (type d'élément)) donne la mémoire pour le tableau flexible. Les ajouter donne la mémoire totale à allouer.

Exemple 1 : allocation de mémoire pour un membre de tableau flexible

Vous trouverez ci-dessous un exemple où nous définissons une structure avec un membre fixe et un tableau flexible, et allouons de la mémoire pour le tableau flexible.

#include <stdio.h>
#include <stdlib.h>
struct Example {
 int id; 
 int arr[]; // flexible array member 
};
int main() {
 int size = 5;
 // Allocate memory for structure + flexible array
 struct Example *e = malloc(sizeof(struct Example) + size * sizeof(int));
 if (e != NULL) {
 printf("Total allocated memory: %zu bytes\n", sizeof(struct Example) + size * sizeof(int));
 free(e);
 }
 return 0;
}

Ici, sizeof(struct Exemple) donne 4 octets pour l'id membre. Ensuite, nous calculons la mémoire du tableau flexible :5 x sizeof(int) =20 octets . La mémoire totale allouée est 4 + 20 =24 octets . La sortie est −

Total allocated memory: 24 bytes

Exemple 2 : Accès à un tableau flexible dans une structure

Dans cet exemple, nous définissons une structure Etudiant avec un membre fixe (id ) et un membre de tableau flexible (marks ). Nous allouons de la mémoire dynamiquement pour le tableau flexible et accéder à ses éléments. Si nous accédons à des éléments au-delà de la taille allouée, cela entraînera un comportement indéfini, nous accèderons donc uniquement aux marks[0]. à marques[2] .

#include <stdio.h>
#include <stdlib.h>
struct Student {
 int id;
 int marks[]; // flexible array member
};
int main() {
 int subjects = 3;
 // Allocate memory for structure + flexible array
 struct Student *s = malloc(sizeof(struct Student) + subjects * sizeof(int));
 if (s != NULL) {
 s->id = 102;
 s->marks[0] = 80;
 s->marks[1] = 75;
 s->marks[2] = 88;
 printf("Student ID: %d\n", s->id);
 printf("Marks: %d, %d, %d\n", s->marks[0], s->marks[1], s->marks[2]);
 printf("Total allocated memory: %zu bytes\n", sizeof(struct Student) + subjects * sizeof(int));
 free(s);
 }
 return 0;
}

Voici le résultat du programme ci-dessus −

Student ID: 102
Marks: 80, 75, 88
Total allocated memory: 16 bytes

Redimensionnement dynamique des membres du tableau flexibles

Les tableaux flexibles peuvent être redimensionnés à l'aide de la fonction realloc() . Cette fonction étend le bloc de mémoire existant ou alloue un nouveau bloc et copie automatiquement les données existantes.

Pour redimensionner un tableau flexible, nous appelons la fonction realloc() avec la nouvelle taille totale de la mémoire en utilisant la formule −

sizeof(structure) + (new_number_of_elements x sizeof(element_type))

Remarque :stockez toujours le résultat de la fonction realloc() dans un pointeur temporaire. En cas d'échec, votre pointeur d'origine reste en sécurité. Mettez également à jour le compteur de taille après le redimensionnement et initialisez uniquement les éléments nouvellement ajoutés.

Exemple 3 :Redimensionnement dynamique des membres d'un tableau flexible

Dans cet exemple, nous créons une structure Étudiant détenir 3 points au départ. Plus tard, nous redimensionnons le tableau flexible pour contenir 6 marques en utilisant realloc() . Les marques que nous avons déjà stockées restent inchangées, nous n'avons donc pas besoin de les copier manuellement.

#include <stdio.h>
#include <stdlib.h>
 
struct Student {
 int id;
 int count; // This field helps track current array size
 int marks[]; // Flexible array member
};
int main() {
 // Step 1: Initial allocation for 3 marks
 int initial_elements = 3;
 struct Student *s = malloc(sizeof(struct Student) + initial_elements * sizeof(int));
 
 if (s != NULL) {
 s->id = 101;
 s->count = initial_elements; // Store current array size
 
 // Display initial sizes
 printf("Structure size: %zu bytes\n", sizeof(struct Student)); // Output: 8 bytes (id + count)
 printf("Initial array elements: %d\n", s->count); // Output: 3
 printf("Initial total memory: %zu bytes\n", 
 sizeof(struct Student) + initial_elements * sizeof(int)); // Output: 20 bytes
 
 // Step 2: Resize to hold 6 marks
 int new_elements = 6;
 struct Student *temp = realloc(s, sizeof(struct Student) + new_elements * sizeof(int));
 
 if (temp != NULL) {
 s = temp;
 s->count = new_elements; // Update array size tracker
 
 // Display new sizes
 printf("\nAfter resizing:\n");
 printf("Structure size: %zu bytes\n", sizeof(struct Student)); // Still 8 bytes
 printf("New array elements: %d\n", s->count); // Output: 6
 printf("New total memory: %zu bytes\n", 
 sizeof(struct Student) + new_elements * sizeof(int)); // Output: 32 bytes
 }
 
 free(s);
 }
 return 0;
}

Vous trouverez ci-dessous le résultat affichant la taille de la structure et la mémoire totale pour le tableau flexible initial et redimensionné.

Structure size: 8 bytes
Initial array elements: 3
Initial total memory: 20 bytes
After resizing:
Structure size: 8 bytes
New array elements: 6
New total memory: 32 bytes

Dans ce chapitre, nous avons découvert les membres de tableaux flexibles dans les structures C. . Ils sont déclarés à la fin d'une structure et gèrent des données de longueur variable, économisent de la mémoire et s'adaptent facilement à différentes tailles de données. Nous avons également vu comment les allouer, y accéder et les redimensionner.