C - Estructuras

Las matrices permiten definir el tipo de variables que pueden contener varios elementos de datos del mismo tipo. similarstructure 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 sobre cada libro:

Title
Author
Subject
ID del libro

Definición de una estructura

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

struct [structure tag] {

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

los structure tages opcional y cada definición de miembro es una definición de variable normal, como int i; o flotar 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ía la estructura del libro:

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 de una estructura, usamos el member access operator (.). El operador de acceso a miembros se codifica como un período entre el nombre de la variable de estructura y el miembro de estructura al que deseamos acceder. Usarías la palabra clavestructpara definir variables de tipo de estructura. El siguiente ejemplo muestra cómo utilizar una estructura en un programa:

#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 se compila y ejecuta el código anterior, 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 un argumento de función de la misma manera que pasa cualquier otra variable o puntero.

#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 se compila y ejecuta el código anterior, 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 el puntero de estructura.

#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 se compila y ejecuta el código anterior, 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 es escaso. Los ejemplos típicos incluyen:

Empaquetando varios objetos en una palabra de máquina. por ejemplo, se pueden compactar banderas de 1 bit.
Lectura de formatos de archivo externos: se pueden leer formatos de archivo no estándar, por ejemplo, números enteros de 9 bits.

C nos permite hacer esto en una definición de estructura poniendo: longitud de bit 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 un 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, algunos compiladores pueden permitir la superposición de memoria para los campos mientras que otros almacenarían el siguiente campo en la siguiente palabra.

↰ Previous page Next page ↱