Miembros de array flexible en una estructura en C

Flexible Array Member (FAM) es una característica introducida en el estándar C99 del lenguaje de programación C.

• Para las estructuras en lenguaje de programación C desde el estándar C99 en adelante, podemos declarar un arreglo sin dimensión y cuyo tamaño es de naturaleza flexible.
• Una array de este tipo dentro de la estructura debe declararse preferiblemente como el último miembro de la estructura y su tamaño es variable (se puede cambiar en tiempo de ejecución).
• La estructura debe contener al menos un miembro más con nombre además del miembro de array flexible.

¿Cuál debe ser el tamaño de la estructura de abajo?

struct student
{
   int stud_id;
   int name_len;
   int struct_size;
   char stud_name[];
};

The size of structure is = 4 + 4 + 4 + 0 = 12

En el fragmento de código anterior, el tamaño, es decir, la longitud de la array «stud_name» no es fijo y es un FAM.

La asignación de memoria utilizando miembros de array flexibles (según los estándares C99) para el ejemplo anterior se puede realizar de la siguiente manera:

 struct student *s = malloc( sizeof(*s) + sizeof(char [strlen(stud_name)])  );

Nota: Al usar miembros de array flexibles en estructuras, se define alguna convención con respecto al tamaño real del miembro.
En el ejemplo anterior, la convención es que el miembro «stud_name» tiene tamaño de carácter.

Por ejemplo, considere la siguiente estructura:

Input : id = 15, name = "Kartik" 
Output : Student_id : 15
         Stud_Name  : Kartik
         Name_Length: 6
         Allocated_Struct_size: 18

Asignación de memoria de la estructura anterior:

struct student *s = 
        malloc( sizeof(*s) + sizeof(char [strlen("Kartik")]));

Su estructura de representación es igual a:

struct student
{
   int stud_id;
   int name_len;
   int struct_size;
   char stud_name[6]; //character array of length 6
};

Implementación

// C program for variable length members in
// structures in GCC
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
  
// A structure of type student
struct student
{
    int stud_id;
    int name_len;
  
    // This is used to store size of flexible
    // character array stud_name[]
    int struct_size;
  
    // Flexible Array Member(FAM)
    // variable length array must be last
    // member of structure
    char stud_name[];
};
  
// Memory allocation and initialisation of structure
struct student *createStudent(struct student *s,
                              int id, char a[])
{
    // Allocating memory according to user provided
    // array of characters
    s =
        malloc( sizeof(*s) + sizeof(char) * strlen(a));
  
    s->stud_id = id;
    s->name_len = strlen(a);
    strcpy(s->stud_name, a);
  
    // Assigning size according to size of stud_name
    // which is a copy of user provided array a[].
    s->struct_size =
        (sizeof(*s) + sizeof(char) * strlen(s->stud_name));
  
    return s;
}
  
// Print student details
void printStudent(struct student *s)
{
    printf("Student_id : %d\n"
           "Stud_Name : %s\n"
           "Name_Length: %d\n"
           "Allocated_Struct_size: %d\n\n",
           s->stud_id, s->stud_name, s->name_len,
           s->struct_size);
  
    // Value of Allocated_Struct_size is in bytes here
}
  
// Driver Code
int main()
{
    struct student *s1 = createStudent(s1, 523, "Cherry");
    struct student *s2 = createStudent(s2, 535, "Sanjayulsha");
  
    printStudent(s1);
    printStudent(s2);
  
    // Size in struct student
    printf("Size of Struct student: %lu\n",
                    sizeof(struct student));
  
    // Size in struct pointer
    printf("Size of Struct pointer: %lu",
                              sizeof(s1));
  
    return 0;
}

Producción:

Student_id : 523
Stud_Name : SanjayKanna
Name_Length: 11
Allocated_Struct_size: 23

Student_id : 535
Stud_Name : Cherry
Name_Length: 6
Allocated_Struct_size: 18

Size of Struct student: 12
Size of Struct pointer: 8

Puntos importantes:

1. Las ubicaciones de memoria adyacentes se utilizan para almacenar miembros de la estructura en la memoria.
2. En los estándares anteriores del lenguaje de programación C, podíamos declarar un miembro de array de tamaño cero en lugar de un miembro de array flexible. El compilador GCC con el estándar C89 lo considera como una array de tamaño cero.

Este artículo es una contribución de Sanjay Kumar Ulsha de JNTUH College Of Engineering, Hyderabad . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.