Dominar los miembros de una matriz flexible en estructuras C para el manejo dinámico de datos

Miembros de matriz flexible se utiliza para manejar matrices dentro de estructuras sin definir su tamaño. Estas matrices obtienen su tamaño en tiempo de ejecución. Una estructura en C hay un tipo de datos definido por el usuario donde definimos varios miembros de diferentes tipos de datos juntos bajo un mismo nombre.

A continuación se muestra la sintaxis para declarar una estructura en C −

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

Aquí, cada miembro puede tener un tipo de datos diferente .

Miembros de matriz flexible Extiende estructuras manteniendo una matriz de tamaño dinámico al final de sus miembros de tamaño fijo y todos juntos almacenados en un bloque de memoria. En este capítulo veremos cómo funcionan dentro de las estructuras.

Miembros de matriz flexible en estructura

Un miembro de matriz flexible es una matriz dentro de una estructura sin un tamaño fijo, y su memoria se asigna dinámicamente en tiempo de ejecución usando malloc() , calloc() , o funciones similares y se declara usando corchetes vacíos [] .

El miembro de matriz flexible debe declararse al final de la estructura, y debe haber al menos otro miembro antes de declararla.

A continuación se muestra la sintaxis para declarar una matriz flexible miembro dentro de una estructura −

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

Aquí, tipo_datos es el tipo de datos de la matriz y arrayName[] es la matriz flexible sin tamaño fijo.

Asignación de memoria para miembros de matriz flexible

Un miembro de matriz flexible no tiene un tamaño fijo, por lo que el compilador no le asigna memoria dentro de la estructura. El operador sizeof solo calcula el tamaño de los miembros fijos de la estructura sin incluir el miembro de la matriz flexible. Es por eso que necesitamos asignar memoria manualmente al crear dichas estructuras.

La memoria total requerida se calcula como −

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

Aquí, tamaño de (estructura) proporciona la memoria para los miembros fijos y (número de elementos x tamaño de (tipo de elemento)) proporciona la memoria para la matriz flexible. Sumarlos proporciona la memoria total para asignar.

Ejemplo 1:asignación de memoria para un miembro de matriz flexible

A continuación se muestra un ejemplo donde definimos una estructura con un miembro fijo y una matriz flexible, y asignamos memoria para la matriz 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;
}

Aquí, sizeof(struct Ejemplo) da 4 bytes para el id miembro. Luego, calculamos la memoria para la matriz flexible:5 x sizeof(int) =20 bytes . La memoria total asignada es 4 + 20 =24 bytes . La salida es −

Total allocated memory: 24 bytes

Ejemplo 2:acceder a una matriz flexible en una estructura

En este ejemplo, definimos una estructura de estudiantes con un miembro fijo (id ) y un miembro de matriz flexible (marcas ). Asignamos memoria dinámicamente para la matriz flexible y acceder a sus elementos. Si accedemos a elementos más allá del tamaño asignado, provocará un comportamiento indefinido, por lo que solo accederemos a marcas[0] a marcas[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;
}

A continuación se muestra el resultado del programa anterior −

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

Cambio de tamaño dinámico de los miembros de la matriz flexible

Las matrices flexibles se pueden cambiar de tamaño usando la función realloc() . Esta función expande el bloque de memoria existente o asigna un nuevo bloque y copia los datos existentes automáticamente.

Para cambiar el tamaño de una matriz flexible, llamamos a la función realloc() con el nuevo tamaño total de memoria usando la fórmula −

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

Nota:Almacene siempre el resultado de la función realloc() en un puntero temporal. Si falla, su puntero original permanece seguro. Además, actualice el contador de tamaño después de cambiar el tamaño e inicialice solo los elementos recién agregados.

Ejemplo 3:cambio de tamaño dinámico de miembros de matriz flexible

En este ejemplo, creamos una estructura de Estudiante para mantener 3 puntos inicialmente. Más tarde, cambiamos el tamaño de la matriz flexible para que contenga 6 marcas. usando realloc() . Las marcas que ya almacenamos permanecen sin cambios, por lo que no necesitamos copiarlas manualmente.

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

A continuación se muestra el resultado que muestra el tamaño de la estructura y la memoria total para la matriz flexible inicial y redimensionada.

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

En este capítulo, aprendimos sobre los miembros de matrices flexibles en estructuras C . Se declaran al final de una estructura y manejan datos de longitud variable, ahorran memoria y se adaptan fácilmente a diferentes tamaños de datos. También vimos cómo asignarlos, acceder a ellos y cambiar su tamaño.