ZC

1. Estructuras y uniones
Programación

2. Definición de estructura
Una estructura (también llamada registro) es un tipo de datos que agrupa
varios datos de tipo simple en un solo objeto.
Las estructuras se declaran con la palabra reservada struct.
struct nombre{
campos;
};
Cada campo esta formado por la declaración de una o más variables de algún
otro tipo. Ejemplo:
struct persona{
char nombre[30];
int edad;
};
nombre (cadena) edad (int)
persona
Campos

3. CARACTERISTICAS DE
ESTRUCTURA
• Las estructuras nos permiten agrupar varios
datos, aunque sean de distinto tipo, que
mantengan algún tipo de relación, permitiendo
manipularlos todos juntos, con un mismo
identificador, o por separado.
• Las estructuras son llamadas también muy a
menudo registros, o en inglés "records". Y son
estructuras análogas en muchos aspectos a los
registros de bases de datos. Y siguiendo la misma
analogía, cada variable de una estructura se
denomina a menudo campo, o "field".

4. Los componentes individuales de una estructura se llaman miembros. Cada
miembro (elemento) de una estructura puede contener datos de un tipo diferente
de otros miembros. Por ejemplo, se puede utilizar una estructura 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.
•Una estructura puede contener cualquier número de miembros, cada uno de los
cuales tiene un nombre único, denominado nombre del miembro. Supongamos
que se desea almacenar los datos de una colección de discos compactos (CD) de
música. Estos datos pueden ser:
1.Título.
2.Artista.
3.Número de canciones.
4.Precio.
5.Fecha de compra.
•La estructura CD contiene cinco miembros. Tras decidir los miembros, se debe
decidir cuáles son los tipos de datos para utilizar por los miembros. Esta
información se representa en la tabla siguiente:
GENERALIDADES

5. struct
Un struct es un tipo de datos complejo
conformado por un conjunto de campos de
otros tipos (básicos o complejos) asociados
a un identificador:
struct [etiqueta]
{
tipo campo;
tipo campo;
...
};
Programación en C 5

6. Variables de tipo estructura
Una vez definida la estructura se pueden declarar variables de ese tipo:
struct persona{
char nombre[30];
int edad;
};
persona juan, maria; o
struct persona juan, maria;
Typedef struct persona personas;
Personas juan, maria;
La asignación se hace mediante el operador “.”
gets(juan.nombre);
juan.edad = 23;
gets(maria.nombre);
TAMBIEN
struct persona{
char nombre[30];
int edad;
}juan, maria;

7. Ejemplo
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct persona{
char nombre[30];
int edad;
};
main(){
persona per1,per2;
strcpy(per1.nombre,"pedro");
strcpy(per2.nombre,"maria");
per1.edad = 23;
per2.edad = 17;
printf("nombre: %snedad: %dn",per1.nombre,per1.edad);
printf("nombre: %snedad: %dn",per2.nombre,per2.edad);
getch();
}

8. Otros ejemplos
struct carta{
int numero;
char palo;
}
numero palo
Carta de baraja
struct libro{
char titulo[40];
char autor[30];
char editorial[20];
int anyo;
}
titulo autor
Libro
editorial anyo
struct poligono{
char nombre[20];
int lados;
float longitudLado,
area;
}
nombre lados
Polígono regular
longitudLado
area

9. struct carta c1;
c1.numero = 3;
c1.palo = ‘D’;
struct libro L1;
strcpy(L1.titulo,”Piensa en C”);
strcpy(L1.autor,”Osvaldo Cairó”);
strcpy(L1.editorial,”Pearson”);
L.anyo = 2006;
struct poligono p;
strcpy(p.nombre,”hexagono”);
p.lados = 6;
p.longitudLado = 5;
p.area = p.lados*p.longitudLado*p.longitudLado/2.0/
tan(PI/p.lados);

10. Ejemplo de alumnos
struct alumno{
int matricula;
char nombre[20];
char carrera[20];
float promedio;
char direccion[20];
};
matricula nombre carrera direccion
promedio
alumno

11. main(){
struct alumno a1={120,"Maria","Contabilidad",8.9,"Queretaro"},a2;
printf("nIngrese la matricula del alumno 2:");
scanf("%d",&a2.matricula);
fflush(stdin);
printf("nIngrese el nombre del alumno 2:");
gets(a2.nombre);
printf("nIngrese la carrera del alumno 2:");
gets(a2.carrera);
printf("nIngrese el promedio del alumno 2:");
scanf("%f",&a2.promedio);
fflush(stdin);
printf("nIngrese la direccion del alumno 2:");
gets(a2.direccion);
printf("nDatos del alumno 1n");
printf("%dn",a1.matricula);
puts(a1.nombre);
puts(a1.carrera);
printf("%.2fn",a1.promedio);
puts(a1.direccion);
printf("nDatos del alumno 2n");
printf("%dn",a2.matricula);
puts(a2.nombre);
puts(a2.carrera);
printf("%.2fn",a2.promedio);
puts(a2.direccion);
getch();
}

12. Actividad
CODIGOA marca modelo anyo placa
Defina estructuras para los siguientes datos y escriba un ejemplo de inicialización
de una variable con llaves y campo por campo.
Registro de automóviles
Cliente de videoclub
nombre direccion telefono
Licencia de manejo
nombres apellidoPaterno apellidoMaterno fechaDesde fechaVencimiento
nacionalidad grupoSanguineo Tipolicencia restricciones donaOrganos
direccion
adeuda
Tarjeta de crédito
nombre fechaVencimiento numeroTarjeta saldo limite
codigocl
cedula

13. struct
struct persona
{
char nombre[20];
int edad;
float peso;
} yo,tu,ellos[10];
struct persona el={“Antonio López”,31,80};
struct persona *ella, todos[20];
Programación en C 13

14. Copia de estructuras
El operador = se puede utilizar para asignar todos los campos de una estructura
a otra.
Ejemplo:
struct libro{
char titulo[30], autor[30], editorial[15];
int anyo,edicion;
};
main(){
libro a = {“El Quijote”,”Cervantes”,”Limusa”,1987,2},b;
b = a;//copia todos los datos de a en b
}

15. Programación en C 15
ARREGLOS DE ESTRUCTURAS
ARREGLOS DE ESTRUCTURAS
Supongamos nuestra estructura:
struct usuario
y que deseamos declarar N usuarios, se sucitaria lo
siguiente:
struct usuario{
char nombre[30];
char calle[40];
char cuidad[20];
char region[3];
char fono[7];
int edad;
} user1,user2,..., userN;
Lo cual para acceder a cada variable se traduce en algo
realmente complejo; Para resolver esta complejidad
podemos utilizar un arreglo.
struct usuario{
char nombre[30];
char calle[40];
char cuidad[20];
char region[3];
char fono[7];
int edad;
}user[N];

16. Programación en C 16
Por lo tanto se puede definir un arreglo de estructuras de la
forma anterior o de la siguiente forma. struct usuario user[N];
lo cual es equivalente (a esta forma de almacenamiento en
memoria principal se le denomina
tabla).
Para poder acceder a algun elemento del arreglo, se indica el
nombre del arreglo, el índice del
arreglo y el elemento de la estructura.
ARREGLOS DE ESTRUCTURAS
ARREGLOS DE ESTRUCTURAS
Por ejemplo:
for(i=0;i<N ;i++)
{
printf("Ingrese el nombre para
user[%d] n",i);
gets(user[i].nombre);
}

17. TAMAÑO DE UNA ESTRUCTURA

18. struct
El acceso a los campos de una estructura
se hace por medio de un punto (.) o de una
flecha (->) si es un puntero a estructura.
struct persona el, *ella, todos[20];
printf(“Su nombre %sn”,el.nombre);
todos[2].edad=20;
ella=&todos[2];
printf(“La edad de ella es %dn”,ella->edad);
Programación en C 18

19. Estructuras y apuntadores
Para acceder a una estructura mediante un apuntador se utiliza la siguiente notación:
(*estructura).campo o estructura->campo
Es necesario crear mediante new la estructura antes de usarla.
Ejemplo:
struct alumno{
int matricula;
char nombre[20];
char carrera[20];
float promedio;
char direccion[20];
};
main(){
alumno *a;
a = new(struct alumno);
(*a).matricula = 234; a->matricula = 234;
strcpy((*a).nombre,"Juan Perez"); strcpy(a->nombre,"Juan Perez");
strcpy((*a).carrera,"Mate"); strcpy(a->carrera,"Mate");
(*a).promedio = 6.7; a->promedio = 6.7;
strcpy((*a).direccion,"Lomas 34"); strcpy(a->direccion,"Lomas 34");
}

20. Actividad Laboratorio
Actividad Laboratorio
Variables generales: Nombre, Apellido, Edad ,nota1, nota2, nota3,
promedio.
1. Calcular y mostrar el promedio de las edades de todos los
estudiantes.
2. Mostrar los datos de los estudiantes mayores de edad (edad >=
18).
3. Mostrar los datos del estudiante que obtuvo el promedio mayor.
4. Mostrar los datos del estudiante que obtuvo la nota mas baja en
promedio.
5. Mostrar los datos del estudiante que obtuvo la nota mas baja en
el campo nota1

21. ESTRUCTURAS ANIDADAS
Programación en C 21
Una estructura puede estar dentro de otra estructura a esto se le
conoce como anidamiento o estructuras anidadas. Las estructuras
anidadas sirven para tener un código más claro y ordenado
Y luego necesitamos una nueva estructura en nuestro programa:
struct cliente /* creamos una estructura llamada
cliente */
{
char nombre_cliente[25];
char direccion[25];
char ciudad[20];
char provincia[20];
long int codigo_postal;
double saldo;
}; /*
struct empleado /* creamos una estructura
llamado empleado*/
{
char nombre_empleado[25];
char direccion[25];
char ciudad[20];
char provincia[20];
long int codigo_postal;
double salario;
};
Podemos ver que tenemos datos muy similares en nuestras estructuras, asi que podemos crear una sola estructura
llamada infopersona con estos datos idénticos:
Podemos ver que tenemos datos muy similares en nuestras estructuras, asi que podemos crear una sola estructura
llamada infopersona con estos datos idénticos:
struct infopersona /* creamos la estructura que contiene
datos parecidos */
{
char direccion[25];
char ciudad[20];
char provincia[20];
long int codigo_postal;
};

22. Programación en C 22
ESTRUCTURAS ANIDADAS
Ahora creamos las nuevas estructuras anteriores, anidando la
estructura necesaria:
struct empleado /* se crea nuevamente la
estructura */
{
char nombre_empleado[25];
/* creamos direcc_empleado con "struct"
del tipo "estructura infopersona" */
struct infopersona direcc_empleado;
double salario;
};
struct empleado /* se crea nuevamente la
estructura */
{
char nombre_empleado[25];
/* creamos direcc_empleado con "struct"
del tipo "estructura infopersona" */
struct infopersona direcc_empleado;
double salario;
};
struct cliente /* se crea nuevamente la
estructura */
{
char nombre_cliente[25];
/* creamos direcc_cliente con "struct" del
tipo "estructura infopersona" */
struct infopersona direcc_cliente;
double saldo;
};
struct cliente /* se crea nuevamente la
estructura */
{
char nombre_cliente[25];
/* creamos direcc_cliente con "struct" del
tipo "estructura infopersona" */
struct infopersona direcc_cliente;
double saldo;
};

23. Programación en C 23
ESTRUCTURAS ANIDADAS
int main(void)
{
/* creamos un nuevo cliente */
struct cliente MiCliente;
/*inicializamos un par de datos de Micliente */
strcpy(MiCliente.nombre_cliente,"Jose Antonio");
strcpy(MiCliente.direcc_cliente.direccion, "Ramon Campaña");
/* notese que se agrega direcc_cliente haciendo referencia
* a la estructura infopersona por el dato direccion
*/
/* imprimimos los datos */
printf("n Cliente: ");
printf("n Nombre: %s", MiCliente.nombre_cliente);
/* notese la forma de hacer referencia al dato */
printf("n Direccion: %s", MiCliente.direcc_cliente.direccion);
/* creamos un nuevo empleado */
struct empleado MiEmpleado;
/*inicializamos un par de datos de MiEmplado */
strcpy(MiEmpleado.nombre_empleado,"Miguel Angel");
strcpy(MiEmpleado.direcc_empleado.ciudad,"Guayaquil");
/* para hacer referencia a ciudad de la estructura infopersona
* utilizamos direcc_empleado que es una estructura anidada
*/
/* imprimimos los datos */
printf("n");
printf("n Empleado: ");
printf("n Nombre: %s", MiEmpleado.nombre_empleado);
/* notese la forma de hacer referencia al dato */
printf("n Ciudad: %s", MiEmpleado.direcc_empleado.ciudad);
return 0;
}

24. Ejemplo
Ejemplo de estructuras anidadas
struct fecha{
int dia,mes,anyo;
};
struct persona{
char nombre[20];
char apellido[20];
fecha nacimiento;
int edad;
int sexo;
char CURP[19];
char telefono[20];
};
nombre apellido nacimiento edad sexo CURP telefono
dia mes anyo

25. 25
Ejercicio
Cree una estructura anidada para guardar los datos de un ciudadano:
Nombre, Fecha de nacimiento (año, mes, dia)
#include <stdio.h>
#include <stdlib.h>
#define NOM 20
/**********************************
* Declaramos las estructuras fuera de la funcion main
*----------------------------------------------------------*/
struct fecha_nacimiento
{
int dia;
int mes;
int anio;
};
struct datos_personales
{
char nombre[NOM];
struct fecha_nacimiento nacer;
};
int main ()
{
struct datos_personales introducir;
printf("Nombre: ");
gets (introducir.nombre);
printf("Fecha nacimiento:n");
printf("Dia: ");
scanf("%d",&introducir.nacer.dia);
printf("Mes: ");
scanf("%d",&introducir.nacer.mes);
printf("Anio: ");
scanf("%d",&introducir.nacer.anho);
}

29. Funciones de tipo estructura
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct dir{
char calle[20];
int numero;
char colonia[20];
int cp;
};
dir dameDir(){
dir a={"alamo",43,"lomas",78000};
return a;
}
main(){
dir b;
b = dameDir();
printf("calle: %s %dn",b.calle,b.numero);
printf("colonia: %sn",b.colonia);
printf("CP: %dn",b.cp);
getch();
}
Una función puede regresar una
estructura

30. Las estructuras se pasan como parámetros a las funciones de la
misma forma que las variables de tipo simple.
Función para escribir datos de un alumno:
void escribeAlumno(struct alumno a){
printf("nDatos del alumnon");
printf("%dn",a.matricula);
puts(a.nombre);
puts(a.carrera);
printf("%.2fn",a.promedio);
puts(a.direccion);
}
Funciones con parámetros de
estructuras

31. Función para leer un alumno:
void lectura(struct alumno *a){
printf("nIngrese la matricula del alumno:");
scanf("%d",&(*a).matricula);
fflush(stdin);
printf("nIngrese el nombre del alumno:");
gets(a->nombre);
printf("nIngrese la carrera del alumno:");
gets((*a).carrera);
printf("nIngrese el promedio del alumno:");
scanf("%f",&a->promedio);
fflush(stdin);
printf("nIngrese la direccion del alumno:");
gets(a->direccion);
}
(*estructura).campo  estructura->campo

32. UNION

33. union
Un union es similar a un struct, pero todos
los campos comparten la misma memoria.
Programación en C 33
struct datos
{
int a,b;
int x[2];
char c;
} d;
union datos
{
int a,b;
int x[2];
char c;
} d;
d.a
d.b
d.x[0]
d.x[1]
d.c
d.a
d.x
d.b
d.c

34. UNION

35. UNION

36. USO DE UNION

37. Uniones
Una unión es una estructura en la que se comparte una región de memoria
para almacenar datos de tipos distintos.
El tamaño de la unión es igual al del tipo de datos más grande.
union prueba{
int a;
float b;
char c;
};
main(){
prueba x;
x.a = 5;
printf("a= %d, b= %f, c= %cn",x.a,x.b,x.c);
x.b = 5.0;
printf("a= %d, b= %f, c= %cn",x.a,x.b,x.c);
x.c = '5';
printf("a= %d, b= %f, c= %cn",x.a,x.b,x.c);
getch();
}
b
prueba
c
a
a= 5, b= 0.000000, c= ♣
a= 1084227584, b= 5.000000, c=
a= 1084227637, b= 5.000025, c= 5
a= 5, b= 0.000000, c= ♣
a= 1084227584, b= 5.000000, c=
a= 1084227637, b= 5.000025, c= 5

38. Aplicaciones de Union

39. Aplicaciones de Union

40. Ejemplo
struct fecha{
int dia,mes,anyo;
};
struct persona{
char nombre[20],apellido[20];
fecha nacimiento;
char sexo;
union{
struct {
float peso,estatura;
}varon;
struct {
int medidas[3];
}mujer;
};
};

41. ENUMERACIONES
Una enumeración es un conjunto de constantes positivas con nombre, que
especifica todos los valores válidos que una variable de este tipo puede tener
Es decir, cada una de las constantes de la enumeración corresponden a un entero,
por lo que pueden usarse en cualquier expresión entera.
Las enumeraciones se definen de forma parecida a las estructuras con la palabra
clave enum que indica el comienzo de un tipo enumerado.
enum etiqueta {lista_enumeraciones} lista_variables;
Donde etiqueta y lista_variables son opcionales como las estructuras

42. ENUMERACIONES

43. ENUMERACIONES

44. LECTURA Y ESCRITURA DE ENUMERACIONES

45. LECTURA Y ESCRITURA DE ENUMERACIONES

46. enum lugar{
primero,
segundo,
tercero
};
lugar pepe=primero;
int vencedor=pepe;
lugar juan=1;
Determine si existe errores en las siguientes definiciones