PDF de programación - Anexo II Registros, uniones y enumerados en C - Estructuras de Datos y Algoritmos

Estructuras de Datos

y Algoritmos

Anexo II

Registros, uniones y enumerados en C

Prof. Dr. P. Javier Herrera

Contenido

1
2
3
4
5
6
7
8
9

Registro
Acceso a registros
Registros anidados
Arrays de registros
Utilización de registros como parámetros
Uniones
Enumeraciones
sizeof de tipos de datos estructurados
typedef

Anexo II

2

1.

Registros

•

•

Los arrays es una estructura de datos homogénea. Esto supone una gran
limitación cuando se requieren grupos de elementos con tipos diferentes
de datos cada uno.

La solución a este problema es utilizar un tipo de dato registro, en C
llamado estructura (del inglés struct). Un registro es una colección de uno
o más tipos de elementos denominados miembros, cada uno de los cuales
puede ser de un tipo de dato diferente.

• Por ejemplo, se puede utilizar un registro para almacenar diferentes tipos
de información sobre una persona, tal como nombre, estado civil, edad y
fecha de nacimiento. Cada uno de estos elementos se denominan nombre
del miembro.

Anexo II

3

1.1 Declaración de registros

• Un registro es un tipo de dato definido por el usuario, que se debe

declarar antes de que se pueda utilizar. El formato de la declaración es:

struct <nombre_del_registro>{

<tipo_de_dato_miembro> <nombre_miembro>
<tipo_de_dato_miembro> <nombre_miembro>
...
<tipo_de_dato_miembro> <nombre_miembro>

};

•

Ejemplo de declaración del registro CD es:

struct coleccion_CD{
char titulo[30];
char artista[25];
int num_canciones;
float precio;
char fecha_compra[8];

};

Anexo II

4
4

1.2 Definición de variables de registros

• A un registro se accede utilizando una variable o variables que se deben

definir después de la declaración del registro.

•

Las variables de registros se pueden definir de dos formas:
1) Situándolas inmediatamente después de la llave de cierre de la declaración

de la estructura,

struct info_libro{
char titulo[60];
char autor[30];
char editorial[30];
int anio;

} libro1, libro2, libro3;

2) Situando el tipo del registro creado seguida por las variables

correspondientes en cualquier lugar del programa antes de utilizarlas.

struct info_libro libro1, libro2, libro3;

Anexo II

5
5

1.3 Uso de registros en asignaciones

• Como un registro es un tipo de dato similar a un int o un char, se

puede asignar un registro a otro.

• Por ejemplo, se puede hacer que libro3, libro4 y libro5 tengan los

mismos valores en sus miembros que libro1. Por consiguiente, sería
necesario realizar las siguientes sentencias:

libro3 = libro1;
libro4 = libro1;
libro5 = libro1;

• De modo alternativo se puede escribir:

libro4 = libro5 = libro6 = libro1;

Anexo II

6
6

1.4 Inicialización de una declaración de registros

•

Se puede inicializar un registro de dos formas. Se puede inicializar un
registro dentro de la sección de código del programa, o bien se puede
inicializar el registro como parte de la definición.

• Cuando se inicializa un registro como parte de la definición, se especifican

los valores iniciales, entre llaves, después de la definición de variables
registro. El formato general en este caso:

struct <tipo> <nombre_variable_registro> =
{ valor_miembro1,
valor_miembro2,
...
valor_miembron

};

Anexo II

7
7

1.4 Inicialización de una declaración de registros

•

Ejemplo:

struct info_libro{
char titulo[60];
char autor[30];
char editorial[30];
int anio;

} libro1 = {"El Pirata Garrapata","Juan Muñoz Martin","SM",1982);

• Otro ejemplo:

struct info_libro libro1 =

{"El Pirata Garrapata","Juan Muñoz Martin","SM",1982};

Anexo II

8
8

2.

Acceso a registros

• Cuando se accede a un registro, o bien se almacena información en la

estructura o se recupera la información de la estructura.

•

•

Se puede acceder a los miembros de un registro de una de estas dos
formas:
1. utilizando el operador punto (.),
2. utilizando el operador puntero ->.

Se puede almacenar información en un registro mediante inicialización,
asignación directa o lectura del teclado.

Anexo II

9
9

2.1 Acceso mediante el operador punto

•

•

•

La asignación de datos a los miembros de una variable registro se hace
mediante el operador punto. La sintaxis en C es:

<nombre_variable_registro> . <nombre_miembro> = datos;

El operador punto proporciona el camino directo al miembro
correspondiente.

Los datos que se almacenan en un miembro dado deben ser del mismo
tipo que el tipo declarado para ese miembro.

• Algunos ejemplos:

strcpy(cd1.titulo,"Granada");
cd1.precio = 3450.75;
cd1.num_canciones = 7;

Anexo II

10
10

2.2 Acceso mediante el operador puntero

•

El operador puntero sirve para acceder a los datos del registro a partir de
un puntero.

• Para utilizar este operador se debe definir primero una variable puntero

para apuntar a la estructura. A continuación, utilizar simplemente el
operador puntero para apuntar a un miembro dado.

•

La asignación de datos a registros utilizando el operador puntero tiene el
formato:

<puntero_registro> -> <nombre_miembro> = datos;

Anexo II

11
11

2.2 Acceso mediante el operador puntero

•

•

•

Por ejemplo, el registro estudiante:

struct estudiante{
char Nombre[41];
int Num_Estudiante;
int Anio_de_matricula;
float Nota;

};

Se puede definir ptr_est como un puntero al registro:

struct estudiante *ptr_est;

A los miembros del registro estudiante se pueden asignar datos como sigue (siempre y
cuando el registro ya tenga creado su espacio de almacenamiento en memoria, por ejemplo,
con malloc(); o bien, tenga la dirección de una variable registro).

ptr_est = &mejor; // ptr-est tiene la dirección (apunta a) mejor
strcpy(ptr_est -> Nombre, "Pepe alomdra");
ptr_est -> Num_Estudiante = 3425;
ptr_est -> Nota = 8.5;

Anexo II

12
12

2.3 Lectura de información

•

•

Si se desea introducir la información en el registro, basta con acceder a los miembros de la
estructura con el operador punto o flecha (puntero). Se puede introducir la información
desde el teclado o desde un archivo, o asignar valores calculados.

Así, si z es una variable de tipo registro complejo, se lee parte real, parte imaginaria y se
calcula el módulo:

struct complejo{

float pr;
float pi;
float modulo;

};
struct complejo z;

printf("\nParte real: ");
scanf("%f",&z.pr);
printf("\nParte imaginaria: ");
scanf("%f",&z.pi);
/* cálculo del módulo */
z.modulo = sqrt(z.pr*z.pr + z.pi*z.pi);

Anexo II

13
13

2.4 Recuperación de información

•

•

Se recupera información de un registro utilizando el operador de asignación o una
sentencia de salida (printf(), puts(), ...). El formato general toma uno de
estos formatos:

1. <nombre_variable> = <nombre_variable_registro> . <nombre_miembro>;
o bien

<nombre_variable> = <puntero_de_registro> -> <nombre_miembro>;

2. Para salida:

printf("...",<nombre_variable_registro> . <nombre_miembro>);

o bien

printf("...",<puntero_de_registro> -> <nombre_miembro>);

Ejemplo:
struct complejo *pz;
...
printf("\nNumero complejo (%.1f,%.1f), módulo: %.2f", pz->pr, pz->pi, pz->modulo);

Anexo II

14
14

3.

Registros anidados

• Un registro puede contener otros registros llamados registros anidados.

•

•

Las estructuras anidadas ahorran tiempo en la escritura de programas que
utilizan estructuras similares.

Se han de definir los miembros comunes sólo una vez en su propia
estructura y a continuación utilizar esa estructura como un miembro de
otra estructura.

Anexo II

15
15

3.

Registros anidados

•

Ejemplo:

struct info_dir{

char direccion[25];
char ciudad[20];
char provincia[20] ;
long int cod_postal;

struct empleado{

char nombre_emp[30];
struct info_dir direccion_emp;
double salario;

};

};

•

•

Este registro se puede utilizar como un miembro de los otros registros (anidarse).

También es posible inicializar registros anidados en la definición. El siguiente ejemplo
inicializa una variable emp1 de tipo struct empleado.

struct empleado emp1 = {"Luis Gomez",

{"Castello", "Pozuelo", "Madrid", 28000},
1500};

Anexo II

16
16

4.

Arrays de registros

•

•

•

Se puede crear un array de registros tal como se crea un array de otros
tipos. Permiten almacenar juntos diversos valores de diferentes tipos,
agrupados como registros.

Los arrays de registros son idóneos para almacenar un archivo completo
de empleados, un archivo de inventario, o cualquier otro conjunto de
datos que se adapte a un formato de registro.

La declaración de un array de registros info_libro se puede hacer de
un modo similar a cualquier array, es decir,
struct info_libro libros[100];

asigna un array de 100 elementos denominado libros.

Anexo II

17
17

4.

Arrays de registros

•

•

Para acceder a los miembros de cada uno de los elementos registro se utiliza una notación de
array. Para inicializar el primer elemento de libros, por ejemplo, de la forma siguiente:

strcpy(libros[0].titulo, "Fray Perico y su Borrico");
strcpy(libros[0].autor, "Juan Muñoz Martin");
strcpy(libros[0].editorial, "SM");
libros[0].anio = 1979;

También puede inicializarse un array de registros en el punto de la declaración encerrando la
lista de inicializadores entre llaves, {}. Por ejemplo

struct info_libro libros[3] = {

"Fray Perico y su Borrico", "Juan Muñoz Martin", "SM", 1979,
"El pirata Garrapata", "Juan Muñoz Martin", "SM", 1982,
"Baldomero el Pistolero", "Juan Muñoz Martin", "SM", 1988};

•

Otro ejemplo:

struct racional{ int N; int D; };
struct racional rs[4] = {1,2,2,3,-4,7,0,1};

Anexo II

18
18

4.1 Arrays como miembros

•

•

Los miembros de los registros pueden ser asimismo arrays.

Ejemplo: Esta sentencia declara un array de 100 registros, cada registro
contiene información de datos de empleados de una compañía.

struct nomina{

char nombre[30];
int dependientes;
char departamento[10];
float horas_dias[7]; // array de tipo float
float salario;

} empleado [100]; // Un array de 100 empleados

Anexo II

19
19

5. Utilización de registros como parámetros

• C permite pasar registros a funcion