Menguasai Anggota Array Fleksibel dalam Struktur C untuk Penanganan Data Dinamis

Anggota Array Fleksibel digunakan untuk menangani array di dalam struktur tanpa menentukan ukurannya. Array ini mendapatkan ukurannya saat runtime. Sebuah struktur di C adalah tipe data yang ditentukan pengguna di mana kita mendefinisikan beberapa anggota dari tipe data berbeda bersama-sama di bawah satu nama.

Di bawah ini adalah sintaksnya untuk mendeklarasikan struktur dalam C −

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

Di sini, setiap anggota dapat memiliki tipe data yang berbeda .

Anggota array yang fleksibel memperluas struktur dengan menahan array berukuran dinamis di akhir anggota berukuran tetap dan semuanya disimpan dalam satu blok memori. Dalam bab ini, kita akan melihat cara kerjanya di dalam struktur.

Anggota Array Fleksibel dalam Struktur

Anggota array fleksibel adalah array di dalam struktur tanpa ukuran tetap, dan memorinya dialokasikan secara dinamis saat runtime menggunakan malloc() , kalloc() , atau fungsi serupa dan dideklarasikan menggunakan tanda kurung siku kosong [] .

Anggota array fleksibel harus dideklarasikan di akhir struktur, dan minimal harus ada satu anggota lain sebelum mendeklarasikannya.

Berikut ini adalah sintaks untuk mendeklarasikan array fleksibel anggota di dalam struktur −

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

Di sini, data_type adalah tipe data array, dan arrayName[] adalah array fleksibel tanpa ukuran tetap.

Alokasi Memori untuk Anggota Array Fleksibel

Anggota array fleksibel tidak memiliki ukuran tetap, sehingga kompiler tidak mengalokasikan memori apa pun untuknya di dalam struktur. operator ukuran hanya menghitung ukuran anggota tetap struktur tanpa menyertakan anggota susunan fleksibel. Itu sebabnya kita perlu mengalokasikan memori secara manual saat membuat struktur seperti itu.

Total memori yang dibutuhkan dihitung sebagai −

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

Di sini, sizeof(struktur) memberikan memori untuk anggota tetap, dan (jumlah elemen x ukuran(tipe elemen)) memberikan memori untuk array fleksibel. Menambahkannya akan memberikan total memori untuk dialokasikan.

Contoh 1:Mengalokasikan Memori untuk Anggota Array Fleksibel

Di bawah ini adalah contoh di mana kita mendefinisikan struktur dengan satu anggota tetap dan array fleksibel, dan mengalokasikan memori untuk array fleksibel.

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

Di sini, sizeof(Contoh struct) memberikan 4 byte untuk id anggota. Lalu, kita menghitung memori untuk array fleksibel:5 x sizeof(int) =20 byte . Total memori yang dialokasikan adalah 4 + 20 =24 byte . keluaran adalah −

Total allocated memory: 24 bytes

Contoh 2:Mengakses Array Fleksibel dalam Struktur

Dalam contoh ini, kita mendefinisikan Struktur siswa dengan satu anggota tetap (id ) dan anggota array yang fleksibel (tanda ). Kami mengalokasikan memori secara dinamis untuk array fleksibel dan mengakses elemen-elemennya. Jika kita mengakses elemen melebihi ukuran yang dialokasikan maka akan menyebabkan perilaku tidak terdefinisi, jadi kita hanya mengakses tanda[0] untuk menandai[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;
}

Berikut adalah keluarannya dari program di atas−

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

Pengubahan Ukuran Dinamis Anggota Array Fleksibel

Array fleksibel dapat diubah ukurannya menggunakan fungsi realloc() . Fungsi ini memperluas blok memori yang ada atau mengalokasikan blok baru dan menyalin data yang ada secara otomatis.

Untuk mengubah ukuran array fleksibel, kita memanggil fungsi realloc() dengan total ukuran memori baru menggunakan rumus −

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

Catatan:Selalu simpan hasil fungsi realloc() dalam penunjuk sementara. Jika gagal, penunjuk asli Anda tetap aman. Selain itu, perbarui penghitung ukuran setelah mengubah ukuran dan inisialisasi hanya elemen yang baru ditambahkan.

Contoh 3:Pengubahan Ukuran Dinamis Anggota Array Fleksibel

Dalam contoh ini, kita membuat Struktur siswa untuk memegang 3 tanda awalnya. Nanti, kami mengubah ukuran array fleksibel untuk menampung 6 tanda menggunakan realloc() . Tanda yang sudah kita simpan tetap tidak berubah, jadi kita tidak perlu menyalinnya secara manual.

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

Di bawah ini adalah keluarannya menunjukkan ukuran struktur dan total memori untuk array fleksibel awal dan yang diubah ukurannya.

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

Dalam bab ini, kita mempelajari tentang anggota array fleksibel dalam struktur C . Mereka dideklarasikan di akhir struktur dan menangani data dengan panjang variabel, menghemat memori, dan beradaptasi dengan ukuran data yang berbeda dengan mudah. Kami juga melihat cara mengalokasikan, mengakses, dan mengubah ukurannya.