Universidad Autnoma de Nuevo Len

Facultad de Ingeniera Mecnica y Elctrica

Estructura de Datos
Presentacin - Tipos de Estructuras
Profesora: M.C. Blanca Idalia Martnez Cavazos

Equipo: #1 Turno: M4 Fecha de entrega: 06 de septiembre de 2013

Definicin de una estructura Una estructura es un tipo de dato compuesto que permite almacenar un conjunto de datos de diferente tipo. Los datos que contiene una estructura pueden ser de tipo simple (caracteres, nmeros enteros o de coma flotante etc.) o a su vez de tipo compuesto (vectores, estructuras, listas, etc.). A cada uno de los datos o elementos almacenados dentro de una estructura se les denomina miembros de esa estructura y stos pertenecern a un tipo de dato determinado. La definicin de una estructura en C corresponde con la sintaxis siguiente: Struct [nombre_estructura] { Tipo_dato miembro1; Tipo_dato miembro2; }; En esta declaracin aclararemos que: struct:es una palabra reservada de C que indica que los elementos que vienen agrupados a continuacin entre llaves componen una estructura. nombre_estructura:identifica el tipo de dato que se describe y del cual se podrn declarar variables. Se especifica entre corchetes para indicar su opcionalidad. miembro1, miembro2,...: Son los elementos que componen la estructura de datos, deben ser precedidos por el tipo_dato al cual pertenecen. Recordemos que una estructura define un tipo de dato, no una variable, lo que significa que no existe reserva de memoria cuando el compilador est analizando la estructura. Posteriormente habr que declarar variables del tipo definido por la estructura para poder almacenar y manipular datos. La declaracin de variables de un determinado tipo de estructura de datos se puede realizar de dos modos:

Primera: Incluir en la propia definicin de la estructura aquellas variables que se van a emplear en el programa. Esta declaracin de variables implica que el mbito en el que stas son reconocidas ser el mismo que el de la declaracin del tipo de dato estructura.

struct [nombre_estructura] { tipo_dato miembro1; tipo_dato miembro2; . . } variable1,variable2,;

En estos casos, y si no se van a declarar ms variables de este tipo de dato en otros lugares del programa, el nombre_estructura es innecesario, por ello viene entre corchetes. Ejemplo: estructura de una tarjeta bancaria, utilizando esta primera forma: struct { long_int num_tarjeta; chartipo_cuenta; char nombre [80]; float saldo; } cliente1, cliente2; Segunda: Definir el tipo de dato estructura con un nombre determinado y declarar posteriormente las variables de ese tipo de dato. Para ello la estructura se identificar con un nombre de forma obligatoria.

structnombre_estructura { tipo_dato miembro1; tipo_dato miembro2; . . }; structnombre_estructuravar1,var2,;

Ejemplo: estructura de una tarjeta bancaria, utilizando la segunda forma:

struct { long_int num_tarjeta; chartipo_cuenta; char nombre [80]; float saldo; } struct tarjetas cli1, cli2;

Ejemplo de una estructura : /* * * * 2009 * * * * * * * * * */ estructura.c Julio Csar Brizuela <brizuelaalvarado@gmail.com> para el wikilibro "Programacin en C (fundamentos)" bajo licencia FDL, adaptado del Dominio Pblico Nombre Miembro Titulo Artista Precio Total Canciones Tipo char[30] char[25] float int

#include <stdio.h> #include <string.h> /* definimos una estructura para cds */ struct cd { char titulo[30]; char artista[25]; float precio; int canciones; } Cd1 = { /* inicializamos la estructura Cd1 creaa con sus valores * usando las definiciones iniciales*/ "Canciones Bebe", /* titulo */ "Pinocho", /* artista */ 12.50, /* precio */ 16 /* total canciones */ }; int main(void) { struct cd Cd2; /* definimos una nueva estructura llamado cd2 */ /* asignamos valores a los tipos de datos del cd2 */ strcpy(Cd2.titulo, "New Age"); /* la forma de insertar valores a un * tipo char en una estructura es usando strcpy

* de la libreria string.h */ strcpy(Cd2.artista, "Old Man"); Cd2.precio = 15.00; Cd2.canciones = 12; /* la forma de acceder a los valores de una estructura */ /* es usando el "." despues de la definicion del dato*/ printf("\n Cd 1"); printf("\n Titulo: %s ", Cd1.titulo); printf("\n Artista: %s ", Cd1.artista); printf("\n Total Canciones: %d ", Cd1.canciones); printf("\n Precio Cd: %f ", Cd1.precio); printf("\n"); printf("\n Cd 2"); printf("\n Titulo: %s ", Cd2.titulo); printf("\n Artista: %s ", Cd2.artista); printf("\n Total Canciones: %d ", Cd2.canciones); printf("\n Precio Cd: %.2f ", Cd2.precio); /* el .2 que esta entre %f * sirve para mostrar unicamente * 2 decimales despues del punto*/ return 0; } 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. Definamos una estructura en nuestro programa: 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; }; /* las estructuras necesitan punto y coma (;) al final */ 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; }; /* las estructuras necesitan punto y coma (;) al final */ Podemos ver que tenemos datos muy similares en nuestras estructuras, asi que podemos crear una sola estructura llamada infopersona con estos datos idnticos: struct infopersona /* creamos la estructura que contiene datos parecidos */ { char direccion[25]; char ciudad[20]; char provincia[20]; long int codigo_postal; }; /* las estructuras necesitan punto y coma (;) al final */ Y crear 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; }; /* las estructuras necesitan punto y coma (;) al final */ <source lang=c> 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; }; /* las estructuras necesitan punto y coma (;) al final */ Y ac el ejemplo completo con estructuras anidadas: /* * estructura2.c * * Julio Csar Brizuela <brizuelaalvarado@gmail.com> 2009 * * para el wikilibro "Programacin en C (fundamentos)" * bajo licencia FDL, adaptado del Dominio Pblico *

* * * * * * */

Nombre Miembro Titulo Artista Precio Total Canciones

Tipo char[30] char[25] float int

#include <stdio.h> #include <string.h> /* creamos nuestra estructura con datos similares */ struct infopersona { char direccion[25]; char ciudad[20]; char provincia[20]; long int codigo_postal; }; /* las estructuras necesitan punto y coma (;) al final */ /* creamos nuestra estructura empleado */ struct empleado { char nombre_empleado[25]; /* agregamos la estructura infopersona * con nombre direcc_empleado */ struct infopersona direcc_empleado; double salario; }; /* las estructuras necesitan punto y coma (;) al final */ /* creamos nuestra estructura cliente */ struct cliente { char nombre_cliente[25]; /* agregamos la estructura infopersona * con nombre direcc_cliente */ struct infopersona direcc_cliente; double saldo; }; /* las estructuras necesitan punto y coma (;) al final */ 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, "Altos del Cielo"); /* 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,"Madrid"); /* 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; } printf("No es cierto")