Beherrschung flexibler Array-Mitglieder in C-Strukturen für die dynamische Datenverarbeitung

Flexible Array-Mitglieder wird verwendet, um Arrays innerhalb von Strukturen zu verarbeiten, ohne deren Größe zu definieren. Diese Arrays erhalten ihre Größe zur Laufzeit. Eine Struktur in C ist ein benutzerdefinierter Datentyp, bei dem wir mehrere Mitglieder verschiedener Datentypen gemeinsam unter einem Namen definieren.

Nachfolgend finden Sie die Syntax zur Deklaration einer Struktur in C −

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

Hier, jedes Mitglied kann einen anderen Datentyp haben .

Flexible Array-Mitglieder Erweitern Sie Strukturen, indem Sie am Ende ihrer Mitglieder fester Größe ein Array mit dynamischer Größe halten und alles zusammen in einem Speicherblock speichern. In diesem Kapitel werden wir sehen, wie sie innerhalb der Strukturen funktionieren.

Flexible Array-Mitglieder in der Struktur

Ein flexibles Array-Mitglied ist ein Array innerhalb einer Struktur ohne feste Größe, dessen Speicher zur Laufzeit dynamisch mit malloc() zugewiesen wird , calloc() oder ähnliche Funktionen und wird mit leeren eckigen Klammern [] deklariert .

Das flexible Array-Mitglied muss am Ende der Struktur deklariert werden, und vor der Deklaration muss mindestens ein weiteres Mitglied vorhanden sein.

Im Folgenden finden Sie die Syntax zum Deklarieren eines flexiblen Arrays Mitglied innerhalb einer Struktur −

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

Hier:data_type ist der Datentyp des Arrays und arrayName[] ist das flexible Array ohne feste Größe.

Speicherzuweisung für flexible Array-Mitglieder

Ein flexibles Array-Mitglied hat keine feste Größe, daher reserviert der Compiler keinen Speicher dafür innerhalb der Struktur. Der sizeof-Operator Berechnet nur die Größe der festen Elemente der Struktur, ohne das flexible Array-Element einzubeziehen. Aus diesem Grund müssen wir den Speicher manuell zuweisen beim Erstellen solcher Strukturen.

Der erforderliche Gesamtspeicher wird als −

berechnet

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

Hier sizeof(structure) Gibt den Speicher für die festen Elemente an und (Anzahl der Elemente x Größe von (Elementtyp)) Gibt den Speicher für das flexible Array an. Wenn Sie sie hinzufügen, erhalten Sie den gesamten zuzuordnenden Speicher.

Beispiel 1:Zuweisen von Speicher für ein flexibles Array-Mitglied

Unten finden Sie ein Beispiel Dabei definieren wir eine Struktur mit einem festen Mitglied und einem flexiblen Array und weisen Speicher für das flexible Array zu.

#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 Beispiel) ergibt 4 Bytes für die id Mitglied. Dann berechnen wir den Speicher für das flexible Array:5 x sizeof(int) =20 Bytes . Der insgesamt zugewiesene Speicher beträgt 4 + 20 =24 Byte . Die Ausgabe ist −

Total allocated memory: 24 bytes

Beispiel 2:Zugriff auf ein flexibles Array in einer Struktur

In diesem Beispiel definieren wir eine Student-Struktur mit einem festen Mitglied (id ) und ein flexibles Array-Mitglied (marks ). Wir ordnen Speicher zu dynamisch für das flexible Array und greifen Sie auf seine Elemente zu. Wenn wir auf Elemente zugreifen, die über die zugewiesene Größe hinausgehen, führt dies zu undefiniertem Verhalten, sodass wir nur auf Markierungen[0] zugreifen zuMarken[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;
}

Es folgt die Ausgabe des obigen Programms −

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

Dynamische Größenänderung flexibler Array-Mitglieder

Flexible Arrays können mit der Funktion realloc() in der Größe geändert werden . Diese Funktion erweitert entweder den vorhandenen Speicherblock oder weist einen neuen Block zu und kopiert die vorhandenen Daten automatisch.

Um die Größe eines flexiblen Arrays zu ändern, rufen wir die Funktion realloc() auf mit der neuen Gesamtspeichergröße unter Verwendung der Formel −

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

Hinweis:Speichern Sie immer das Ergebnis der realloc()-Funktion in einem temporären Zeiger. Wenn dies fehlschlägt, bleibt Ihr ursprünglicher Zeiger sicher. Aktualisieren Sie außerdem den Größenzähler nach der Größenänderung und initialisieren Sie nur die neu hinzugefügten Elemente.

Beispiel 3:Dynamische Größenänderung flexibler Array-Mitglieder

In diesem Beispiel erstellen wir eine Student-Struktur 3 Punkte halten zunächst. Später ändern wir die Größe des flexiblen Arrays, um 6 Markierungen aufzunehmen mit realloc() . Die bereits gespeicherten Markierungen bleiben unverändert, sodass wir sie nicht manuell kopieren müssen.

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

Unten ist die Ausgabe Zeigt die Strukturgröße und den Gesamtspeicher sowohl für das anfängliche als auch für das in der Größe geänderte flexible Array an.

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 diesem Kapitel haben wir etwas über flexible Array-Mitglieder in C-Strukturen gelernt . Sie werden am Ende einer Struktur deklariert und verarbeiten Daten variabler Länge, sparen Speicher und passen sich problemlos an unterschiedliche Datengrößen an. Wir haben auch gesehen, wie man sie zuordnet, darauf zugreift und ihre Größe ändert.