C - Estructuras

Las matrices permiten definir el tipo de variables que pueden contener varios elementos de datos del mismo tipo. Del mismo modo estructura es otro tipo de datos definido por el usuario disponible en C que permite combinar elementos de datos de diferentes tipos.

Las estructuras se utilizan para representar un registro. Suponga que desea realizar un seguimiento de sus libros en una biblioteca. Es posible que desee realizar un seguimiento de los siguientes atributos de cada libro:

Título
Autor
Asunto
Identificación del libro

Definición de una estructura

Para definir una estructura, debe utilizar la estructura declaración. La instrucción struct define un nuevo tipo de datos, con más de un miembro. El formato de la instrucción struct es el siguiente −

struct [structure tag] {

   member definition;
   member definition;
   ...
   member definition;
} [one or more structure variables];

La etiqueta de estructura es opcional y cada definición de miembro es una definición de variable normal, como int i; o flotante f; o cualquier otra definición de variable válida. Al final de la definición de la estructura, antes del punto y coma final, puede especificar una o más variables de estructura, pero es opcional. Esta es la forma en que declararías la estructura del Libro:

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

Acceso a los miembros de la estructura

Para acceder a cualquier miembro de una estructura, usamos el operador de acceso a miembros (.) . El operador de acceso a miembros se codifica como un punto entre el nombre de la variable de estructura y el miembro de estructura al que deseamos acceder. Usarías la palabra clave struct para definir variables de tipo estructura. El siguiente ejemplo muestra cómo usar una estructura en un programa −

Demostración 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;        /* Declare Book1 of type Book */
   struct Books Book2;        /* Declare Book2 of type Book */
 
   /* book 1 specification */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;

   /* book 2 specification */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* print Book1 info */
   printf( "Book 1 title : %s\n", Book1.title);
   printf( "Book 1 author : %s\n", Book1.author);
   printf( "Book 1 subject : %s\n", Book1.subject);
   printf( "Book 1 book_id : %d\n", Book1.book_id);

   /* print Book2 info */
   printf( "Book 2 title : %s\n", Book2.title);
   printf( "Book 2 author : %s\n", Book2.author);
   printf( "Book 2 subject : %s\n", Book2.subject);
   printf( "Book 2 book_id : %d\n", Book2.book_id);

   return 0;
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

Estructuras como argumentos de función

Puede pasar una estructura como argumento de función de la misma manera que pasa cualquier otra variable o puntero.

Demostración en vivo

#include <stdio.h>
#include <string.h>
 
struct Books {
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};

/* function declaration */
void printBook( struct Books book );

int main( ) {

   struct Books Book1;        /* Declare Book1 of type Book */
   struct Books Book2;        /* Declare Book2 of type Book */
 
   /* book 1 specification */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;

   /* book 2 specification */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* print Book1 info */
   printBook( Book1 );

   /* Print Book2 info */
   printBook( Book2 );

   return 0;
}

void printBook( struct Books book ) {

   printf( "Book title : %s\n", book.title);
   printf( "Book author : %s\n", book.author);
   printf( "Book subject : %s\n", book.subject);
   printf( "Book book_id : %d\n", book.book_id);
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −

Book title : C Programming
Book author : Nuha Ali
Book subject : C Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700

Punteros a Estructuras

Puede definir punteros a estructuras de la misma manera que define punteros a cualquier otra variable −

struct Books *struct_pointer;

Ahora, puede almacenar la dirección de una variable de estructura en la variable de puntero definida anteriormente. Para encontrar la dirección de una variable de estructura, coloque el '&'; operador antes del nombre de la estructura de la siguiente manera −

struct_pointer = &Book1;

Para acceder a los miembros de una estructura usando un puntero a esa estructura, debe usar el operador → de la siguiente manera −

struct_pointer->title;

Reescribamos el ejemplo anterior usando un puntero de estructura.

Demostración en vivo

#include <stdio.h>
#include <string.h>
 
struct Books {
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};

/* function declaration */
void printBook( struct Books *book );
int main( ) {

   struct Books Book1;        /* Declare Book1 of type Book */
   struct Books Book2;        /* Declare Book2 of type Book */
 
   /* book 1 specification */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;

   /* book 2 specification */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* print Book1 info by passing address of Book1 */
   printBook( &Book1 );

   /* print Book2 info by passing address of Book2 */
   printBook( &Book2 );

   return 0;
}

void printBook( struct Books *book ) {

   printf( "Book title : %s\n", book->title);
   printf( "Book author : %s\n", book->author);
   printf( "Book subject : %s\n", book->subject);
   printf( "Book book_id : %d\n", book->book_id);
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −

Book title : C Programming
Book author : Nuha Ali
Book subject : C Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700

Campos de bits

Los campos de bits permiten el empaquetado de datos en una estructura. Esto es especialmente útil cuando la memoria o el almacenamiento de datos son escasos. Los ejemplos típicos incluyen −

Empaquetar varios objetos en una palabra de máquina. p.ej. Las banderas de 1 bit se pueden compactar.
Lectura de formatos de archivo externos:se pueden leer formatos de archivo no estándar, por ejemplo, enteros de 9 bits.

C nos permite hacer esto en una definición de estructura poniendo :bit length después de la variable. Por ejemplo −

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í, la estructura empaquetada contiene 6 miembros:cuatro indicadores de 1 bit f1..f3, un tipo de 4 bits y my_int de 9 bits.

C empaqueta automáticamente los campos de bits anteriores de la forma más compacta posible, siempre que la longitud máxima del campo sea menor o igual que la longitud de la palabra entera de la computadora. Si este no es el caso, entonces algunos compiladores pueden permitir la superposición de memoria para los campos, mientras que otros almacenarían el siguiente campo en la siguiente palabra.

Do - Cuerdas C - Uniones

Lenguaje C