Dominando estructuras en C: Organiza datos complejos eficientemente

Los arrays permiten definir variables que almacenan varios datos del mismo tipo. De forma similar, la estructura (struct) es otro tipo de dato definido por el usuario que permite combinar datos de diferentes tipos.

Las estructuras representan un registro. Supongamos que quieres rastrear libros en una biblioteca. Podrías querer estos atributos por libro:

• Título
• Autor
• Asunto
• ID del libro

Definiendo una estructura

Para definir una estructura, usa la sentencia struct. Define un nuevo tipo de dato con más de un miembro. Formato:

struct [etiqueta_estructura] {
    definición_miembro;
    definición_miembro;
    ...
    definición_miembro;
} [una_o_más_variables_estructura];

La etiqueta_estructura es opcional y cada definición de miembro es una definición normal de variable (int i;, float f;, etc.). Al final, antes del punto y coma final, puedes especificar variables de estructura (opcional). Declaración de estructura Books:

struct Books {
    char title[50];
    char author[50];
    char subject[100];
    int book_id;
} book;

Acceso a miembros de estructura

Para acceder a cualquier miembro, usamos el operador de acceso a miembro (.): punto entre nombre de variable estructura y miembro deseado. Usa struct para definir variables de tipo estructura. Ejemplo completo:

Demo en vivo

#include <stdio.h>
#include <string.h>
struct Books {
    char title[50];
    char author[50];
    char subject[100];
    int book_id;
};
int main() {
    struct Books Book1; /* Declarar Book1 tipo Book */
    struct Books Book2; /* Declarar Book2 tipo Book */
    /* Especificación libro 1 */
    strcpy(Book1.title, "Programación en C");
    strcpy(Book1.author, "Nuha Ali");
    strcpy(Book1.subject, "Tutorial de C");
    Book1.book_id = 6495407;
    /* Especificación libro 2 */
    strcpy(Book2.title, "Facturación Telecom");
    strcpy(Book2.author, "Zara Ali");
    strcpy(Book2.subject, "Tutorial Facturación Telecom");
    Book2.book_id = 6495700;
    /* Imprimir info Book1 */
    printf("Libro 1 título: %s\n", Book1.title);
    printf("Libro 1 autor: %s\n", Book1.author);
    printf("Libro 1 asunto: %s\n", Book1.subject);
    printf("Libro 1 ID: %d\n", Book1.book_id);
    /* Imprimir info Book2 */
    printf("Libro 2 título: %s\n", Book2.title);
    printf("Libro 2 autor: %s\n", Book2.author);
    printf("Libro 2 asunto: %s\n", Book2.subject);
    printf("Libro 2 ID: %d\n", Book2.book_id);
    return 0;
}

Resultado:

Libro 1 título: Programación en C
Libro 1 autor: Nuha Ali
Libro 1 asunto: Tutorial de C
Libro 1 ID: 6495407
Libro 2 título: Facturación Telecom
Libro 2 autor: Zara Ali
Libro 2 asunto: Tutorial Facturación Telecom
Libro 2 ID: 6495700

Estructuras como argumentos de función

Puedes pasar una estructura como argumento igual que cualquier variable o puntero.

Demo en vivo

#include <stdio.h>
#include <string.h>
struct Books {
    char title[50];
    char author[50];
    char subject[100];
    int book_id;
};
/* declaración función */
void printBook(struct Books book);
int main() {
    struct Books Book1, Book2;
    strcpy(Book1.title, "Programación en C");
    strcpy(Book1.author, "Nuha Ali");
    strcpy(Book1.subject, "Tutorial de C");
    Book1.book_id = 6495407;
    strcpy(Book2.title, "Facturación Telecom");
    strcpy(Book2.author, "Zara Ali");
    strcpy(Book2.subject, "Tutorial Facturación Telecom");
    Book2.book_id = 6495700;
    printBook(Book1);
    printBook(Book2);
    return 0;
}
void printBook(struct Books book) {
    printf("Título: %s\n", book.title);
    printf("Autor: %s\n", book.author);
    printf("Asunto: %s\n", book.subject);
    printf("ID: %d\n", book.book_id);
}

Resultado idéntico al anterior.

Punteros a estructuras

Puedes definir punteros a estructuras igual que a cualquier variable:

struct Books *puntero_estructura;

Almacena dirección de variable estructura con operador &:

puntero_estructura = &Book1;

Para acceder a miembros usando puntero, usa operador ->:

puntero_estructura->title;

Reescribamos el ejemplo usando puntero a estructura:

Demo en vivo

#include <stdio.h>
#include <string.h>
struct Books {
    char title[50];
    char author[50];
    char subject[100];
    int book_id;
};
void printBook(struct Books *book);
int main() {
    struct Books Book1, Book2;
    strcpy(Book1.title, "Programación en C");
    strcpy(Book1.author, "Nuha Ali");
    strcpy(Book1.subject, "Tutorial de C");
    Book1.book_id = 6495407;
    strcpy(Book2.title, "Facturación Telecom");
    strcpy(Book2.author, "Zara Ali");
    strcpy(Book2.subject, "Tutorial Facturación Telecom");
    Book2.book_id = 6495700;
    printBook(&Book1);
    printBook(&Book2);
    return 0;
}
void printBook(struct Books *book) {
    printf("Título: %s\n", book->title);
    printf("Autor: %s\n", book->author);
    printf("Asunto: %s\n", book->subject);
    printf("ID: %d\n", book->book_id);
}

Mismo resultado.

Campos de bits (Bit Fields)

Permiten empaquetar datos en una estructura. Útil cuando memoria/almacenamiento es escaso. Ejemplos típicos:

• Empaquetar varios objetos en una palabra de máquina. ej. banderas de 1 bit.

• Leer formatos de archivo externos no estándar (ej. enteros de 9 bits).

C permite esto poniendo :longitud_bits tras la variable en la definición:

struct packed_struct {
    unsigned int f1:1;
    unsigned int f2:1;
    unsigned int f3:1;
    unsigned int f4:1;
    unsigned int type:4;
    unsigned int my_int:9;
} pack;

Aquí packed_struct tiene 6 miembros: cuatro banderas de 1 bit (f1..f4), un tipo de 4 bits y un entero de 9 bits.

C empaqueta automáticamente los campos de bits lo más compactamente posible, siempre que la longitud máxima no exceda la longitud de palabra entera del computador. Si no es así, algunos compiladores permiten solapamiento, otros almacenan el siguiente campo en la siguiente palabra.