Beheersing van flexibele array-leden in C-structuren voor dynamische gegevensverwerking

Flexibele array-leden wordt gebruikt om arrays binnen structuren te verwerken zonder hun grootte te definiëren. Deze arrays krijgen hun grootte tijdens runtime. Een structuur in C is een door de gebruiker gedefinieerd gegevenstype waarbij we meerdere leden van verschillende gegevenstypen samen onder één naam definiëren.

Hieronder vindt u de syntaxis voor het declareren van een structuur in C −

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

Hier elk lid kan een ander gegevenstype hebben .

Flexibele arrayleden breid structuren uit door een array van dynamische grootte aan het einde van hun leden met een vaste grootte vast te houden en alles samen opgeslagen in één geheugenblok. In dit hoofdstuk zullen we zien hoe ze binnen de structuren werken.

Flexibele matrixleden in structuur

Een flexibel arraylid is een array binnen een structuur zonder vaste grootte, en het geheugen ervan wordt tijdens runtime dynamisch toegewezen met behulp van malloc() , calloc() , of vergelijkbare functies en wordt gedeclareerd met lege vierkante haken [] .

Het flexibele arraylid moet aan het einde van de structuur worden gedeclareerd en er moet minstens één ander lid zijn voordat dit wordt gedeclareerd.

Hieronder volgt de syntaxis voor het declareren van een flexibele array lid binnen een structuur −

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

Hier data_type is het gegevenstype van de array, en arrayName[] is de flexibele array zonder vaste grootte.

Geheugentoewijzing voor flexibel arraylid

Een flexibel arraylid heeft geen vaste grootte, dus de compiler wijst er geen geheugen voor toe binnen de structuur. De sizeof-operator berekent alleen de grootte van de vaste elementen van de structuur zonder het flexibele array-lid mee te nemen. Daarom moeten we geheugen handmatig toewijzen bij het maken van dergelijke structuren.

Het totale vereiste geheugen wordt berekend als −

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

Hier sizeof(structuur) geeft het geheugen voor de vaste leden, en (aantal elementen x groottevan(elementtype)) geeft het geheugen voor de flexibele array. Als u ze toevoegt, krijgt u het totale toe te wijzen geheugen.

Voorbeeld 1:geheugen toewijzen aan een flexibel arraylid

Hieronder vindt u een voorbeeld waar we een structuur definiëren met één vast lid en een flexibele array, en geheugen toewijzen voor de flexibele array.

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

Hier sizeof(struct voorbeeld) levert 4 bytes op voor de id lid. Vervolgens berekenen we het geheugen voor de flexibele array:5 x sizeof(int) =20 bytes . Het totale toegewezen geheugen is 4 + 20 =24 bytes . De uitvoer is −

Total allocated memory: 24 bytes

Voorbeeld 2:toegang krijgen tot een flexibele array in een structuur

In dit voorbeeld definiëren we een Studentenstructuur met één vast lid (id ) en een flexibel arraylid (markeringen ). We wijzen geheugen toe dynamisch voor de flexibele array en toegang tot de elementen ervan. Als we elementen benaderen die groter zijn dan de toegewezen grootte, zal dit ongedefinieerd gedrag veroorzaken, dus we hebben alleen toegang tot markeringen[0] tot markeringen[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;
}

Hieronder volgt de uitvoer van bovenstaand programma −

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

Dynamisch aanpassen van de grootte van flexibele arrayleden

Het formaat van flexibele arrays kan worden aangepast met de realloc() functie . Deze functie breidt het bestaande geheugenblok uit of wijst een nieuw blok toe en kopieert de bestaande gegevens automatisch.

Om het formaat van een flexibele array te wijzigen, roepen we de realloc()-functie aan met de nieuwe totale geheugengrootte met behulp van de formule −

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

Opmerking:sla altijd het resultaat op van de functie realloc() in een tijdelijke aanwijzer. Als het mislukt, blijft uw oorspronkelijke aanwijzer veilig. Werk ook de grootteteller bij nadat u het formaat hebt gewijzigd en initialiseer alleen de nieuw toegevoegde elementen.

Voorbeeld 3:Dynamische aanpassing van de grootte van flexibele arrayleden

In dit voorbeeld maken we een Studentenstructuur om 3 punten vast te houden aanvankelijk. Later passen we de grootte van de flexibele array aan zodat deze 6 markeringen bevat met behulp van realloc() . De markeringen die we al hebben opgeslagen blijven ongewijzigd, dus we hoeven ze niet handmatig te kopiëren.

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

Hieronder vindt u de uitvoer toont de structuurgrootte en het totale geheugen voor zowel de initiële flexibele array als de gewijzigde flexibele array.

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

In dit hoofdstuk leerden we over flexibele arrayleden in C-structuren . Ze worden aan het einde van een structuur gedeclareerd en verwerken gegevens van variabele lengte, besparen geheugen en passen zich gemakkelijk aan verschillende gegevensgroottes aan. We hebben ook gezien hoe je ze kunt toewijzen, openen en het formaat ervan kunt wijzigen.