P6-Estructuras

 Estructuras en C

Las estructuras son colecciones de variables relacionadas bajo un nombre.
Pueden contener variables de muchos tipos diferentes de datos
a diferencia de los arreglos que contienen únicamente elementos de un mismo
tipo de datos.

 Definición de estructuras

Las estructuras son tipos de datos derivados, están construidas utilizando
objetos de otros tipos. Considere la siguiente definición de estructura:

struct ejemplo {
char c;
int i;};

La palabra reservada struct indica se está definiendo una estructura. El
identificador ejemplo es el nombre de la estructura. Las variables declaradas
dentro de las llaves de la definición de estructura son los miembros de la estructura. Los miembros de la misma estructura deben tener nombres únicos
mientras que dos estructuras diferentes pueden tener miembros con el mismo
nombre. Cada definición de estructura debe terminar con un punto y coma.
La definición de struct ejemplo contiene un miembro de tipo char y otro
de tipo int. Los miembros de una estructura pueden ser variables de los tipos
de datos básicos (int, char, float,etc) o agregados como ser arreglos y otras
estructuras. Una estructura no puede contener una instancia de si misma.
Declaramos variables del tipo estructura del siguiente modo:

struct ejemplo e1, a[10];

o alternativamente sin usar la palabra struct:

ejemplo e1, a[10];

Las declaraciones anteriores declaran variables e1 de tipo ejemplo y a de tipo
arreglo de ejemplo de dimensión 10.
Se pueden declarar variables de tipo estructura ejemplo colocando sus nombres a continuación de la llave de cierre de la definición de estructura y el punto
y coma, en el caso anterior:

struct ejemplo {
char c;

int i;} e1, a[10];

 Una operación valida entre estructuras es asignar variables de estructura a
variables de estructura del mismo tipo. Las estructuras no pueden compararse entre si.

Estructuras Anidadas

Una estructura puede estar dentro de otra estructura a esto se le conoce como anidamiento o estructuras anidadas. Ya que se trabajan con datos en estructuras si definimos un tipo de dato en una estructura y necesitamos definir ese dato dentro de otra estructura solamente se llama el dato de la estructura anterior.

Ejemplo escrito:

1. /*
2.        estructura2.c
3.          
4.    Nombre Miembro Tipo
5.  
6.    Titulo char[30]
7.    Artista char[25]
8.    Precio float
9.   Total Canciones int
10.  */
11. 
    
12. #include <stdio.h>
13. #include <string.h>
14. 
    
15. /* creamos nuestra estructura con datos similares */
16. struct infopersona
17. {
18. char direccion[25];
19. char ciudad[20];
20. char provincia[20];
21. long int codigo_postal;
22. }; /* las estructuras necesitan punto y coma (;) al final */
23. 
    
24. /* creamos nuestra estructura empleado */
25. struct empleado
26. {
27. char nombre_empleado[25];
28. /* agregamos la estructura infopersona
29. * con nombre direcc_empleado
30. */
31. struct infopersona direcc_empleado; 
32. double salario;
33. }; /* las estructuras necesitan punto y coma (;) al final */
34. 
    
35. /* creamos nuestra estructura cliente */
36. struct cliente
37. {
38. char nombre_cliente[25];
39. /* agregamos la estructura infopersona
40.   con nombre direcc_cliente
41. */
42. struct infopersona direcc_cliente;
43. double saldo;
44. }; /* las estructuras necesitan punto y coma (;) al final */
45. 
    
46. int main(void)
47. {
48. /* creamos un nuevo cliente  */
49. struct cliente MiCliente;
51. /*inicializamos un par de datos de Micliente */
52. strcpy(MiCliente.nombre_cliente,"Alexis");
53. strcpy(MiCliente.direcc_cliente.direccion, "Altos del Cielo");
54. /* notese que se agrega direcc_cliente haciendo referencia 
55.   a la estructura infopersona por el dato direccion
56. */
58. /* imprimimos los datos */
59. printf("\n Cliente: ");
60. printf("\n Nombre: %s", MiCliente.nombre_cliente);
61. /* notese la forma de hacer referencia al dato */
62. printf("\n Direccion: %s", MiCliente.direcc_cliente.direccion); 
64. /* creamos un nuevo empleado  */
65. struct empleado MiEmpleado;
67. /*inicializamos un par de datos de MiEmplado */
68. strcpy(MiEmpleado.nombre_empleado,"Alexis");
69. strcpy(MiEmpleado.direcc_empleado.ciudad,"Nueva York");
70. /* para hacer referencia a ciudad de la estructura infopersona
71. * utilizamos direcc_empleado que es una estructura anidada
72. */
74. /* imprimimos los datos */
75. printf("\n");
76. printf("\n Empleado: ");
77. printf("\n Nombre: %s", MiEmpleado.nombre_empleado);
78. /* notese la forma de hacer referencia al dato */
79. printf("\n Ciudad: %s", MiEmpleado.direcc_empleado.ciudad);
81. return 0;
82. }

Arreglos de estructuras 

struct trabajador

{

char nombre[20];

char apellidos[40];

int edad;

};

struct trabajador fijo[20];

Así podremos almacenar los datos de 20 trabajadores. Ejemplos sobre como acceder a los campos y sus elementos: para ver el nombre del cuarto trabajador, fijo[3].nombre;. Para ver la tercera letra del nombre del cuarto trabajador, fijo[3].nombre[2];. Para inicializar la variable en el momento de declararla lo haremos de esta manera:
struct trabajador fijo[20]={{"José","Herrero Martínez",29},{"Luis","García Sánchez",46}};
Typedef
Es posible agrupar un conjunto de elementos de tipo estructura en un array. Esto se conoce como array de estructuras: El lenguaje 'C' dispone de una declaración llamada typedef que permite la creación de nuevos tipos de datos. Ejemplos:
typedef int entero; /* acabamos de crear un tipo de dato llamado entero */
entero a, b=3; /* declaramos dos variables de este tipo */