Освоение гибких членов массива в структурах C для динамической обработки данных

Члены гибкого массива используется для обработки массивов внутри структур без определения их размера. Эти массивы получают свой размер во время выполнения. Структура в C — это определяемый пользователем тип данных, в котором мы определяем несколько членов разных типов данных вместе под одним именем.

Ниже приведен синтаксис . для объявления структуры в C −

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

Здесь каждый участник может иметь другой тип данных .

Гибкие элементы массива расширяйте структуры, сохраняя массив динамического размера в конце их членов фиксированного размера и все вместе храня их в одном блоке памяти. В этой главе мы увидим, как они работают внутри структур.

Гибкие элементы массива в структуре

гибкий элемент массива представляет собой массив внутри структуры без фиксированного размера, а его память выделяется динамически во время выполнения с помощью malloc() , calloc() или подобные функции и объявляются с использованием пустых квадратных скобок [] .

элемент гибкого массива должна быть объявлена в конце структуры, и перед ее объявлением должен быть хотя бы еще один член.

Ниже приведен синтаксис объявления гибкого массива. член внутри структуры −

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

Здесь тип_данных — тип данных массива, а arrayName[] — гибкий массив без фиксированного размера.

Выделение памяти для элемента гибкого массива

гибкий элемент массива не имеет фиксированного размера, поэтому компилятор не выделяет для него памяти внутри структуры. Оператор sizeof вычисляет только размер фиксированных элементов структуры, не включая гибкий элемент массива. Вот почему нам нужно выделить память вручную при создании таких структур.

Общий требуемый объем памяти рассчитывается как —

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

Здесь sizeof(структура) дает память для фиксированных элементов и (количество элементов x sizeof(тип элемента)) дает память для гибкого массива. Их добавление дает общий объем выделяемой памяти.

Пример 1:выделение памяти для гибкого элемента массива

Ниже приведен пример. где мы определяем структуру с одним фиксированным элементом и гибким массивом и выделяем память для гибкого массива.

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

Здесь sizeof(пример структуры) дает 4 байта для id член. Затем мы вычисляем объем памяти для гибкого массива:5 x sizeof(int) =20 байт . Общий объем выделенной памяти составляет 4 + 20 =24 байта. . Выход это −

Total allocated memory: 24 bytes

Пример 2:доступ к гибкому массиву в структуре

В этом примере мы определяем Структуру учеников. с одним фиксированным членом (id ) и гибкий член массива (метки ). Мы выделяем память динамически для гибкого массива и доступа к его элементам. Если мы получим доступ к элементам, превышающим выделенный размер, это приведет к неопределенному поведению, поэтому мы получаем доступ только к marks[0]. до отметок[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;
}

Ниже приведен выход . вышеуказанной программы −

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

Динамическое изменение размера элементов гибкого массива

Размер гибких массивов можно изменить с помощью функции realloc(). . Эта функция либо расширяет существующий блок памяти, либо выделяет новый блок и автоматически копирует существующие данные.

Чтобы изменить размер гибкого массива, мы вызываем функцию realloc(). с новым общим объемом памяти по формуле −

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

Примечание. Всегда сохраняйте результат функции realloc(). во временном указателе. Если это не удастся, исходный указатель останется в безопасности. Кроме того, обновите счетчик размера после изменения размера и инициализируйте только вновь добавленные элементы.

Пример 3. Динамическое изменение размера элементов гибкого массива

В этом примере мы создаем Структуру студентов. чтобы удержать 3 балла изначально. Позже мы изменяем размер гибкого массива, чтобы вместить 6 баллов. используя realloc() . Метки, которые мы уже сохранили, остаются неизменными, поэтому нам не нужно копировать их вручную.

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

Ниже приведен выход. показывающий размер структуры и общий объем памяти как для исходного, так и для гибкого массива с измененным размером.

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

В этой главе мы узнали о гибких членах массива в структурах C. . Они объявляются в конце структуры и обрабатывают данные переменной длины, экономят память и легко адаптируются к различным размерам данных. Мы также увидели, как их распределять, получать к ним доступ и изменять их размер.