PDF de programación - Tema 1. Estructuras - Estructuras de Datos y Algoritmos

Estructuras de Datos

y Algoritmos

Tema 1. Estructuras

CONTENIDO

• CONCEPTO
• ACCESO A MIEMBROS
• ESTRUCTURAS ANIDADAS
• VECTORES DE ESTRUCTURAS
• ESTRUCTURAS Y FUNCIONES

CONCEPTO

Programa para manejar información relativa a
alumnos: Nombre, Apellidos y DNI.

Alternativa 1: Definir una variable del
tipo concreto para cada dato que se desee
manejar

char Nombre[20];
char Apellidos[40];
char DNI[10];
– Inconvenientes:

– La información relacionada con una
misma dispersa en muchas variables.

– Muy difícil de modificar el programa y

adaptarlo a nuevas necesidades
(guardar información de muchos
alumnos).

#include <stdio.h>
int main(void){

char Nombre[20];
char Apellidos[40];
char DNI[10];

printf(“Introduzca los datos\n");
printf(“Nombre :");
gets(Nombre);

printf("\nApellidos :");
gets(Apellidos);

printf("\nDNI :");
gets(DNI);
printf("\n\n\nDatos\n");
printf("Nombre %s\n",Nombre);
printf("Apellidos: %s\n",Apellidos);
printf("Nombre: %s\n",DNI);
return 0;

}

Tema 1. Estructuras - Curso 2017/18

CONCEPTO (II)

Alternativa 2: Definir una estructura de
la siguiente forma:

struct Alumno {
char Nombre[20];
char Apellidos[40];
char DNI[9];

} ;

#include <stdio.h>
struct Alumno {

char Nombre[20];
char Apellidos[40];
char DNI[10];

};
int main(void){

struct Alumno Alumno1;

printf("Datos\n");
printf(“Nombre:");
gets(Alumno1.nombre);
printf("\nApellidos :");
gets(Alumno1.apellidos);
printf("\nDNI :");
gets(Alumno1.dni);
printf("\n\n\nDatos\n");
printf("Nombre %s\n",Alumno1.Nombre);
printf("Apellidos: %s\n",Alumno1.Apellidos);
printf("Nombre: %s\n",Alumno1.DNI);

return 0;

}

Tema 1. Estructuras - Curso 2017/18

CONCEPTO (III)

•

Una estructura permite referenciar mediante un
único nombre de variable un conjunto de datos
que pueden ser de diferente tipo.

– Permite organizar mejor la información que

se encuentra relacionada entre sí.

– Facilita el mantenimiento y modificación

del código.

struct nombre_estructura{

tipo_1 nombre_miembro_1;
tipo_2 nombre_miembro_2;
........
tipo_n nombre_miembro_n;

};

• Donde:

– Permite crear agrupaciones de información

– nombre_estructura

más complejas: (Ejemplo: vector de
estructuras donde se almacenaría la
información de un grupo de alumnos en
UN UNICO VECTOR).

• Nombre dado para identificar esa

estructura en particular.

– tipo_1 nombre_miembro_1;...; tipo_n

nombre_miembro_n;

• Declaraciones de cada uno de los

miembros individuales.

• Los miembros individuales pueden ser:

– Variables simples, punteros,
vectores u otras estructuras.

• Los nombres de los miembros dentro de

una estructura deben ser todos
diferentes.

Tema 1. Estructuras - Curso 2017/18

• Los nombres de miembros de

estructuras diferentes pueden coincidir.

CONCEPTO (IV)

• La definición de la estructura no

reserva espacio en la memoria para
ella, únicamente crea una plantilla
con el formato de la estructura.

• Una vez definida una estructura,

dicha estructura se puede considerar
como un nuevo tipo de dato de
nombre
struct nombre_de_estructura

Ejemplo:

struct Paciente {

char Nombre[100];
unsigned short Edad;
float Peso;

};

int Num;
struct Paciente Paciente1;

Tema 1. Estructuras - Curso 2017/18

CONCEPTO (V)

La declaración de variables de una estructura
se puede realizar de dos maneras:

Definición Alternativa1:

struct Alumno {

Alternativa1: Después de haber
declarado la estructura.

struct nombre_estructura variable1,
variable2,...,variablem ;

Alternativa2: Sobre la propia definición
de la estructura.

struct nombre_estructura
{

tipo_1

nombre_miembro_1;

tipo_2

nombre_miembro_2;

........
tipo_n

nombre_miembro_n;
} variable1, variable2, ..., variablen;

Mejor utilizar la OPCIÓN 1.

char Nombre[20];
char Apellidos[40];
char DNI[10];

};

Declaración opción 1:

struct Alumno Alumno1;

Definición Alternativa2:

struct Alumno {

char Nombre[20];
char Apellidos[40];
char DNI[10];

} Alumno1;

Tema 1. Estructuras - Curso 2017/18

CONCEPTO (VI)

Ejemplo del uso de typedef con una
estructura:

typedef struct {
char Nombre[20];
char Apellidos[40];
char DNI[10];
} tAlumno;

Y a partir de ese momento se podrán declarar
variables:

tAlumno Alumno1;

La sentencia typedef permite dar un nombre
arbitrario a un tipo de datos de C, ya sea un tipo
básico (int, char, ...) o un tipo derivado (struct
paciente, ...)
Utilización del typedef para estructuras:

typedef struct {
tipo_1 nombre_miembro_1;
tipo_2 nombre_miembro_2;

........

tipo_n nombre_miembro_n;
} Nombre_del_Tipo;

Ejemplo del uso del typedef con un tipo básico:

typedef unsigned short tEdad;

Y a partir de ese momento, se podrían declarar
variables:

tEdad Edad;

que sería equivalente a utilizar:

unsigned short Edad;

Tema 1. Estructuras - Curso 2017/18

ACCESO A MIEMBROS

• Cada miembro de una estructura se

procesa como entidad separada.
• A un miembro de una entidad se
accede anexando un punto “.” al
nombre de la variable de tipo
estructura y escribiendo a
continuación el nombre del miembro.

nombre_variable.miembro
• Cuando la estructura está constituida
por estructuras anidadas, el acceso a
miembros de segundo, tercer, etc.
nivel se lleva a cabo siguiendo el
camino desde la variable hasta el
miembro que se desea procesar.

Ejemplo :

#include <stdio.h>
#include <string.h>
typedef struct {

char nombre[20];
char apellidos[40];
char dni[10];

} tDatos;
int main(void)
{

T_DATOS Alumno;
strcpy(Alumno.nombre,”Javier”);
printf(“Introduzca los apellidos de %s”,

Alumno.nombre);

gets(Alumno.apellidos);
strcpy(Alumno.dni,”123456H”);
return 0;

}

Tema 1. Estructuras - Curso 2017/18

ACCESO A MIEMBROS(II)

• Un miembro de una estructura puede ser:

– Una variable simple, un puntero, un vector.
– Una estructura.
Este último caso permite incluir estructuras dentro de
estructuras.

• De este modo es posible estructurar la

•

información en diferentes niveles
dependiendo del grado de relación que
exista.
Supongamos que al ejemplo de la estructura
datos de una Alumno deseamos añadirle su fecha
de nacimiento.
Una fecha de nacimiento contiene tres datos
relacionados entre si: Día, Mes y Anio.
Para modelar esta información podemos hacer
uso de una estructura fecha e incluirla en la
definición de la estructura datos.

typedef struct {

int Mes;
int Dia;
int Anio;
} tFecha;

typedef struct {

char Nombre[20];
char Apellidos[40];
char DNI[10];
tFecha FNacimiento;

} tAlumno;

Declaración de una variable de tipo
tAlumno:
tAlumno Alumno;

Tema 1. Estructuras - Curso 2017/18

ESTRUCTURAS ANIDADAS (I)

Ejemplo 1 :

int main (void) {

#include <stdio.h>
#include <string.h>
typedef struct {

int Dia;
int Mes;
int Anio;

}tFecha
typedef struct {

char Nombre[20];
char Apellidos[40];
char DNI[10];
tFecha FNacimiento;

} tDatos;

tDatos Alumno;
strcpy(Alumno.Nombre,”Antonio”);
strcpy(Alumno.Apellidos,”Pérez”);
strcpy(Alumno.DNI,”123456H”);

printf(“Anio de nacimiento: %s : %s”, Alumno.Nombre,
Alumno.Apellidos);
fflush(stdin);
scanf(“%d”, &(Alumno.FNacimiento.Anio));

printf(“Mes de nacimiento %s:”, Alumno.Nombre);
fflush(stdin);
scanf(“%d”, &(Alumno.FNacimiento.mes));

printf(“Día de nacimiento %s:”, Alumno.Nombre);
fflush(stdin);
scanf(“%d”, &(Alumno.FNacimiento.Dia));
return 0;

}

ESTRUCTURAS ANIDADAS (II)

Ejemplo 2 :

typedef char tCadena20[20];
typedef char tCadena40[40];
typedef char tCadena10[10];

typedef struct {

int Mes;
int Dia;
int Anio;

} tFecha;

typedef struct {

tCadena20 Nombre;
tCadena40 Apellidos;
tCadena10 DNI;
tFecha FNacimiento;

} tDatos;

int main(void){

tDatos Alumno;

strcpy(Alumno.Nombre,”Luis”);
strcpy(Alumno.Apellidos,”Perez”);
strcpy(Alumno.DNI,”123456H”);

Alumno.FNacimiento.mes = 9;
Alumno.FNacimiento.dia = 5;
Alumno.FNacimiento.anio = 1985;
printf(“Los datos de la Alumno son:\n");
printf(“%s
%s:\n“,Alumno.Nombre,Alumno.Apellidos);
printf(“DNI: %s\n“,Alumno.DNI);
printf(“Fecha Nacimiento:
%d/%d%d\n“,Alumno.FNacimiento.Dia,Alumno.F
Nacimiento.Mes,Alumno.FNacimiento.Anio);
return 0;

}

VECTORES DE ESTRUCTURAS (I)

• Declaración igual que un vector de cualquier otro tipo de dato.
• Acceso a sus miembros:

nombre_vector[indice].nombre_miembro

• Al definir un vector de estructuras se reserva espacio en memoria para contener a
las estructuras que componen el vector y se crea un puntero constante (nombre del
vector) que apunta al inicio de dicha zona de memoria. El primer elemento tiene el
índice 0.

• Ejercicio: Diseñar un programa que almacene la información de Nombre,

Apellidos, DNI y fecha de nacimiento de un grupo de 15 alumnos.

• Se debe definir una estructura capaz de recoger la información referente a una Alumno.
• Se debe definir un vector donde cada elemento será del tipo de la estructura definida.

VECTORES DE ESTRUCTURAS (II)

#include <stdio.h>
#define N 15
#define M 20
typedef struct {

int Mes;
int Dia;
int Anio;

} tFecha;

typedef struct {

char Nombre[M];
char Apellidos[M];
char DNI[N];
tFecha FNacimiento;

} tDatos;

int main(void) {

tDatos Alumno[N];
int i;
for (i=0;i<N;i++) {
printf("Datos %d \n“, i +1);
printf(“Nombre :");
gets(Alumno[i].Nombre);

printf("\nApellidos :");
gets(Alumno[i].Apellidos);

printf("\nDNI :");
gets(Alumno[i].DNI);

printf("\nDia de nacimiento :");
fflush(stdin);
scanf(“%d”,&Alumno[i].FNacimiento.Dia);

printf("\nMes de nacimiento :");
fflush(stdin);
scanf(“%d”,&Alumno[i].FNacimiento.Mes);

printf("\nAño de nacimiento :");
fflush(stdin);
scanf(“%d”,&Alumno[cont].FNacimiento.Anio);
}
return 0;

}

ESTRUCTURAS Y PUNTEROS: OPERADOR “->”

• Un puntero a una estructura se declara igual que un puntero a una

variable ordinaria.

tipo_estructura *nombre_variable;

• Para obtener la dirección de una variable de tipo estructura se usa el

operador & al igual que con el resto de variables.

• Para acceder a un elemento de una estructura a través de un puntero se

utiliza el operador de indirección “*”, al igual que con el resto de
variables:

(1) (*nombre_puntero_estructura).