C Estructura

Los arrays en C permiten definir variables que pueden almacenar elementos de datos del mismo tipo,La estructuraes otro tipo de datos disponible definido por el usuario en la programación en C, que le permite almacenar elementos de datos de diferentes tipos.

Los miembros de datos en una estructura pueden ser tipos de datos básicos (como int, float, char, etc.), también pueden ser otros tipos de estructura, tipos de puntero, etc.

La estructura se utiliza para representar un registro. Supongamos que desea realizar un seguimiento de los libros en una biblioteca, es posible que necesite rastrear los siguientes atributos de cada libro:

Title
Author
Subject
Book ID

Definición de estructura

La definición de una estructura consta de la palabra clavestructy del nombre de la estructura. El nombre de la estructura se puede definir según sea necesario.

La declaración struct define un nuevo tipo de datos que contiene múltiples miembros. El formato de la declaración struct es el siguiente:

struct tag {
member-list
member-list
member-list
...
} variable-list ;

tages la etiqueta de la estructura.

member-listes una definición de variable estándar, por ejemploint i;ofloat f;, u otra definición de variable válida.

variable-listVariables de estructura, definidas al final de la estructura, antes del último punto y coma. Puede especificar una o más variables de estructura. A continuación se muestra la forma de declarar la estructura Book:

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

En general,tag、member-list、variable-listal menos 2 de estas 3 partes deben aparecer. A continuación se muestran ejemplos:

// esta declaración declara una estructura con 3 miembros: a de tipo entero, b de tipo carácter y c de tipo doble
// también declara la variable de estructura s1
// esta estructura no tiene etiqueta especificada
struct
{
int a;
char b;
double c;
} s1;

// esta declaración declara una estructura con 3 miembros: a de tipo entero, b de tipo carácter y c de tipo doble
// la etiqueta de la estructura se llama SIMPLE, no se declara variable
struct SIMPLE
{
int a;
char b;
double c;
};
// usando la etiqueta SIMPLE de la estructura, se declaran además las variables t1, t2, t3
struct SIMPLE t1, t2[20], *t3;

// también se puede usar typedef para crear un nuevo tipo
typedef struct
{
int a;
char b;
double c;
} Simple2;
// ahora se puede usar Simple2 como tipo para declarar nuevas variables de estructura
Simple2 u1, u2[20], *u3;

En las declaraciones anteriores, la primera y la segunda declaración son tratadas por el compilador como dos tipos completamente diferentes, incluso si sus listas de miembros son iguales. Si se hace t3=&s1, es ilegal.

Los miembros de una estructura pueden contener otras estructuras, y también pueden contener punteros a su propio tipo de estructura. Generalmente, la aplicación de tales punteros es para implementar estructuras de datos más avanzadas, como listas enlazadas y árboles.

// la declaración de esta estructura contiene otras estructuras
struct COMPLEX
{
char string[100];
struct SIMPLE a;
};

// la declaración de esta estructura contiene un puntero a su propio tipo
struct NODE
{
char string[100];
struct NODE *next_node;
};

Si dos estructuras se contienen mutuamente, es necesario hacer una declaración incompleta de una de ellas, como se muestra a continuación:

struct B; // declaración incompleta de la estructura B

// la estructura A contiene un puntero a la estructura B
struct A
{
struct B *partner;
//other members;
};

// la estructura B contiene un puntero a la estructura A; después de declarar A, B se declara a continuación
struct B
{
struct A *partner;
//other members;
};

Inicialización de variables de estructura

Igual que con otros tipos de variables, se pueden especificar valores iniciales para las variables de estructura al definirlas.

Ejemplo

#include <stdio.h>

struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} book = {"Lenguaje C", "EJEMPLO", "Lenguaje de programación", 123456};

int main()
{
printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
}

El resultado de la ejecución es:

title : C 语言
author: EJEMPLO
subject: 编程语言
book_id: 123456

Acceso a los miembros de la estructura

Para acceder a los miembros de la estructura, utilizamosel operador de acceso a miembros (.). El operador de acceso a miembros es un punto entre el nombre de la variable de estructura y el miembro de la estructura al que queremos acceder. Puede utilizarstructla palabra clave para definir variables de tipo estructura. El siguiente ejemplo demuestra el uso de las estructuras:

Ejemplo

#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 Books */
struct Books Book2; /* Declarar Book2, tipo Books */

/* Detalles de Book1 */
strcpy( Book1.title, "C Programming");
strcpy( Book1.author, "Nuha Ali");
strcpy( Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;

/* Detalles de Book2 */
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Zara Ali");
strcpy( Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;

/* Imprimir información de Book1 */
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);

/* Imprimir información de Book2 */
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

Estructura como parámetro de función

Puede pasar una estructura como parámetro de función, de forma similar a como se pasan variables o punteros de otros tipos. Puede acceder a las variables de estructura de la manera que se muestra en el ejemplo anterior:

Ejemplo

#include <stdio.h>
#include <string.h>

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

/* Declaración de la función */
void printBook( struct Books book );
int main( )
{
struct Books Book1; /* Declarar Book1, tipo Books */
struct Books Book2; /* Declarar Book2, tipo Books */

/* Detalles de Book1 */
strcpy( Book1.title, "C Programming");
strcpy( Book1.author, "Nuha Ali");
strcpy( Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;

/* Detalles de Book2 */
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Zara Ali");
strcpy( Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;

/* Imprimir información de Book1 */
printBook( Book1 );

/* Imprimir información de 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

Puntero a estructura

Puede definir un puntero a una estructura, de manera similar a como se define un puntero a variables de otros tipos, como se muestra a continuación:

struct Books *struct_pointer;

Ahora puede almacenar la dirección de una variable de estructura en la variable de puntero definida anteriormente. Para obtener la dirección de una variable de estructura, coloque el operador & delante del nombre de la estructura, como se muestra a continuación:

struct_pointer = &Book1;

Para acceder a los miembros de la estructura utilizando un puntero a la estructura, debe usar el operador ->, como se muestra a continuación:

struct_pointer->title;

Reescribamos el ejemplo anterior usando punteros a estructura; esto le ayudará a comprender el concepto de punteros a estructura:

Ejemplo

#include <stdio.h>
#include <string.h>

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

/* Declaración de la función */
void printBook( struct Books *book );
int main( )
{
struct Books Book1; /* Declarar Book1, tipo Books */
struct Books Book2; /* Declarar Book2, tipo Books */

/* Detalles de Book1 */
strcpy( Book1.title, "C Programming");
strcpy( Book1.author, "Nuha Ali");
strcpy( Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;

/* Detalles de Book2 */
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Zara Ali");
strcpy( Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;

/* Imprimir información de Book1 pasando la dirección de Book1 */
printBook( &Book1 );

/* Imprimir información de Book2 pasando la dirección de 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

Cálculo del tamaño de una estructura

En C, podemos usarsizeofel operador para calcular el tamaño de una estructura,sizeofque devuelve el tamaño en bytes de un tipo o variable determinados.

Para una estructura,sizeofdevolverá el número total de bytes de la estructura, incluido el tamaño de todas las variables miembro y los posibles bytes de relleno.

El siguiente ejemplo demuestra cómo calcular el tamaño de una estructura:

Ejemplo

#include <stdio.h>

struct Person {
char name[20];
int age;
float height;
};

int main() {
struct Person person;
printf("El tamaño de la estructura Person es: %zu bytes\n", sizeof(person));
return 0;
}

En el ejemplo anterior, definimos una llamadaPersonestructura, que contiene un arreglo de caracteresname, un enteroagey un número de coma flotante (float).height。

EnmainEn la función, declaramos una variablePersondel tipoperson, y luego usamossizeofel operador para obtenerpersonel tamaño de la estructura.

Finalmente, usamosprintfla función para imprimir el tamaño de la estructura, el resultado es el siguiente:

结构体 Person 大小为: 28 字节

NotaEl tamaño de una estructura puede verse afectado por la optimización del compilador y las reglas de alineación. El compilador puede insertar algunos bytes de relleno adicionales en la estructura para alinear las variables miembro y mejorar la eficiencia del acceso a memoria. Por lo tanto, el tamaño real de la estructura puede ser mayor que la suma de los tamaños de las variables miembro. Si necesita conocer con exactitud el diseño de memoria y la alineación de la estructura, puede usaroffsetofla macro y__attribute__((packed))los atributos, entre otros, para controlar y consultar aún más el tamaño y la alineación de la estructura.

Otras extensiones

C Biblioteca estándar

C Estructura

Definición de estructura

Inicialización de variables de estructura

Ejemplo

Acceso a los miembros de la estructura

Ejemplo

Estructura como parámetro de función

Ejemplo

Puntero a estructura

Ejemplo

Cálculo del tamaño de una estructura

Ejemplo