ICAI – 1º Grado en Ingeniería en

Tecnologías Industriales

Fundamentos de Informática

Tema 9
Estructuras de datos

Fundamentos de Informática Tema 1: Introducción, Arquitectura Básica y Sistemas Operativos

ICAI – 1º Grado en Ingeniería en Tecnologías Industriales 1
 Índice
• Problemática
• ¿Qué es una estructura de datos?
• Declaración y definición de estructuras
• La sentencia typedef
• Procesamiento de estructuras: acceso a los miembros de una
estructura
– Operador “.”
• Estructuras anidadas
• Vectores de estructuras
• Estructuras y punteros
– Operador “->”
• Estructuras y funciones

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 2

 ¿Qué tenemos hasta ahora?
• Hasta el momento se han utilizado variables con las siguientes
características:
– Variables simples
• int, char, float, double, long.
• Guardan UN ÚNICO dato (que debe coincidir con el tipo de datos con el que se
ha declarado la variable).
– Variables de tipo puntero
• Guardan una dirección de memoria que puede ser utilizada para APUNTAR a
un dato del tipo definido en la declaración del puntero.
– Vectores
• Unidimensionales (vectores), bidimensionales (matrices), multidimensionales.
• int, char, float, double, long.
• Guardan VARIOS datos, todos ellos del mismo tipo.
– Coinciden con el tipo de datos con el que se ha definido el vector.

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 3

 ¿Cómo resolveríamos...?
• Supongamos que queremos crear un programa que nos permita
manejar información relacionada con una persona:
– Nombre, Apellidos y DNI.
• Solución 1:
– Me defino una variable del tipo específico por cada uno de los datos que
quiera que mi programa maneje.

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

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 4

 Un programa para manejar esta definición de datos
Solución 1:
#include <stdio.h>
#define N 20
#define M 40
#define K 10
int main(void) {
char nombre[N];
char apellidos[M];
cha dni[K];

printf("Dame los datos de la persona\n");

printf("Dame el nombre:");
fgets(nombre, N, stdin);

printf("Dame los apellidos:");

fgets(apellidos, M, stdin);

printf("Dame el DNI:");
fgets(dni, K, stdin);
printf("\nDatos Personales\n");
printf("Nombre % s\n",nombre);
printf("Apellidos: %s\n",apellidos);
printf("Nombre: % s\n",dni);
return 0;
Fundamentos de }Informática ICAI – 1º GITI Tema 9: Estructuras de datos 5
 Problemas de la solución 1
• La aproximación presentada tiene los siguientes “peros”:
– Toda la información relacionada con una misma persona se encuentra dispersa
en muchas variables.
• El programa sería difícil de mantener y de comprender.
– ¿Cómo podríamos modificar nuestro programa para que, en vez de almacenar
la información relativa a una única persona, pudiera almacenar esa misma
información para 100 personas?
• Modificar el programa y adaptarlo a nuevas necesidades sería complicado.

Solución 2
• Definir una estructura en C de la siguiente forma:
struct persona {
char nombre[N];
char apellidos[M];
char dni[K];
};

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 6

 Un programa para manejar esta definición de datos
#include <stdio.h>
#define N 20
#define M 40
#define K 10
struct persona {
char nombre[N];
char apellidos[M];
char dni[K];
};
int main(void) {
struct persona persona1;

printf("Dame los datos de la persona1\n");

printf("Dame el nombre:");
fgets(persona1.nombre, N, stdin)
printf("Dame los apellidos:");
fgets(persona1.apellidos, M, stdin)
printf("Dame el DNI:");
fgets(persona1.dni, K, stdin)
printf("\nDatos Personales\n");
printf("Nombre % s\n",persona1.nombre);
printf("Apellidos: %s\n",persona1.apellidos);
printf("Nombre: % s\n",persona1.dni);
return 0;
}
Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 7
 ¿Qué es una estructura?

• Una estructura en C es un conjunto de datos NO HOMOGÉNEO.

– Una estructura nos permite referenciar mediante un único nombre de
variable un conjunto de datos que pueden ser de diferentes tipos.
– El uso de estructuras nos permite tener mucho más organizada la información
que se encuentra relacionada entre sí.
• Facilita el mantenimiento y modificación del código.
– El uso de estructuras, además, permite la creación de agrupaciones de
información mucho más complejas:
• Ejemplo: Un vector de estructuras donde podríamos tener almacenada la
información completa de un grupo de personas en UN ÚNICO VECTOR.

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 8

 Definición de una estructura
• La definición de una estructura es la siguiente:
struct nombre_estructura {
tipo_1 nombre_miembro_1;
tipo_2 nombre_miembro_2;
........
tipo_n nombre_miembro_n;
};
• Donde:
– nombre_estructura
• Es el nombre dado para identificar esa estructura en particular.
– tipo_1 nombre_miembro_1;...; tipo_n nombre_miembro_n;
• Son las 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.
• Los nombres de miembros de estructuras diferentes pueden coincidir.

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 9

 Definición de una estructura
• La definición de la estructura NO reserva espacio en la memoria para una estructura,
únicamente crea una plantilla con el formato de la estructura.
• Una vez definida una estructura se la considera como un NUEVO TIPO DE DATOS con
nombre
struct nombre_de_estructura
• Por lo tanto, la declaración de variables de tipo estructura se va a realizar de una
manera idéntica a la del resto de variables:
• Ejemplo:
struct paciente {
char nombre[100];
unsigned short edad;
float peso;
unsigned short n_seg_social;
};
/* Declaraciones */
int variable1;
struct paciente paciente1;

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 10

 Declaración de una estructura
• Una vez definida la estructura ya podemos declarar las variables que se
ajustarán a este nuevo tipo.

• La declaración de variables de una estructura:

Después de haber declarado la estructura.

struct nombre_estructura variable1;

struct nombre_estructura variable2;
• Ejemplo:
struct persona {
char nombre[20];
char apellidos[40];
char dni[10];
};
• Declaración:
struct persona persona1;
Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 11
 La sentencia typedef
• 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, ...)
• A partir del momento en que se utiliza el typedef, ya se puede utilizar ese nombre
como un nuevo tipo.
• 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 T_WORD;
Y a partir de ese momento, se podrían declarar variables:
T_WORD edad;
que sería equivalente a utilizar: unsigned short edad;

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 12

 La sentencia typedef
• Ejemplo del uso de typedef con una estructura:
typedef struct {
char nombre[20];
char apellidos[40];
char dni[10];
} T_PERSONA;

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

T_PERSONA persona1;

Atención:
En este curso, vamos a utilizar la sentencia typedef para la definición de las
estructuras pues facilita la legibilidad del código.

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 13

 Procesamiento de estructuras: Operador “.”

Acceso a los miembros de una estructura

• Los miembros de una estructura se procesan de modo individual.
– Cada miembro se procesa como una entidad separada.
• Para acceder a los miembros de una estructura se usa el operador punto “.”
• 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
al que se desea acceder.
nombre_variable.miembro
• Si la estructura estuviera formada por estructuras anidadas, el acceso a
miembros de segundo, tercer, etc. nivel se lleva a cabo describiendo el camino
desde la variable hasta el miembro que se desea procesar.
• Una vez que se accede a un miembro de una estructura, su uso es idéntico al de
las demás variables.

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 14

 Procesamiento de estructuras
• Ejemplo :

#include <stdio.h>
#include <string.h>
typedef struct {
char nombre[20];
char apellidos[40];
char dni[10];
} T_PERSONA;
int main(void) {
T_PERSONA persona;

strcpy(persona.nombre,”Javier”);

printf(“Introduzca los apellidos de % s: ”, persona.nombre);

fgets(persona.apellidos, 40, stdin);

strcpy(persona.dni,”123456H”);
return 0;
}

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 15

 Estructuras anidadas
• 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 persona”
deseamos añadirle su fecha de nacimiento.
– Una fecha de nacimiento contiene tres datos relacionados entre sí:
• Día, mes y año.
• Para modelar esta información podemos hacer uso de una estructura para la
fecha e incluirla en la definición de la estructura T_PERSONA.

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 16

 Estructuras anidadas
• Definición de una estructura que entre sus miembros contiene otra estructura:
typedef struct {
int mes;
int dia;
int anio;
} T_FECHA;

typedef struct {
char nombre[20];
char apellidos[40];
char dni[10];
T_FECHA f_nacimiento;
} T_PERSONA;

Declaración de una variable de tipo T_PERSONA:

T_PERSONA persona;

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 17

 Procesamiento de estructuras anidadas (ejemplo 1)

int main (void) {

T_PERSONA persona;
#include <stdio.h>
strcpy(persona.nombre,”Maria”);
#include <string.h>
strcpy(persona.apellidos,”Garcia”);
typedef struct { strcpy(persona.dni,”123456H”);
int dia;
int mes; printf(“Indique el anio de nacimiento de % s %s”, persona.nombre,
persona.apellidos);
int anio;
scanf(“%d”, &(persona.f_nacimiento.anio));
}T_FECHA;
typedef struct { printf(“Indique el mes de nacimiento de % s”, persona.nombre);
char nombre[20]; scanf(“%d”, &(persona.f_nacimiento.mes));
char apellidos[40];
printf(“Indique el dia de nacimiento de % s”, persona.nombre);
char dni[10];
scanf(“%d”, &(persona.f_nacimiento.dia));
T_FECHA f_nacimiento; return 0;
} T_PERSONA; }

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 18

 Vectores de estructuras
• La verdadera potencia de las estructuras se centra en que permiten definir datos
que podemos combinar de forma mucho más próxima a la realidad.
• Un vector de estructuras se declara de la misma manera que un vector de cualquier
otro tipo de dato.
• Para acceder a los miembros de una estructura que a su vez son un elemento del
vector, será necesario:
nombre_vector[indice].nombre_miembro
• Como cualquier vector, el primer elemento tiene el índice 0.
• Como cualquier vector, al definir un vector de estructuras se reserva espacio
suficiente en la memoria para contener a las estructuras que componen el vector y
se crea un puntero constante (el nombre del vector) que apunta al comienzo de
dicha zona de memoria.

• Ejemplo: Diseñar un programa que guarde la información de nombre, apellidos, dni

y fecha de nacimiento de un grupo de 10 personas.
• Definimos una estructura capaz de recoger la información referente a un individuo.
• Definimos un vector donde cada uno de sus elementos será del tipo de la estructura
definida en el punto anterior.

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 19

 Vectores de estructuras
int main(void) {
T_PERSONA personas[N];
int i;
#include <stdio.h> for (i=0; i<N; i++) {
printf("Dame los datos de la persona %d: “, i +1);
#define N 10
printf("Dame el nombre: ");
#define M 20 fgets(personas[i].nombre, M, stdin);
typedef struct {
printf("Dame los apellidos: ");
int mes;
fgets(personas[i].apellidos, M, stdin);
int dia;
int anio; printf("Dame el DNI: ");
} T_FECHA; fgets(personas[i].dni, N, stdin);

printf("Dame el dia de nacimiento: ");

typedef struct { scanf(“%d”,&personas[i].f_nacimiento.dia);
char nombre[M];
printf("Dame el mes de nacimiento: ");
char apellidos[M];
scanf(“%d”,&personas[i].f_nacimiento.mes);
char dni[N];
T_FECHA f_nacimiento; printf("Dame el año de nacimiento: ");
} T_PERSONA; scanf(“%d”,&personas[i].f_nacimiento.anio);
}
return 0;
}

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 20

 Estructuras y punteros: Operador “->”

• Un puntero a una estructura se declara de la misma manera 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 las
variables:
(1) (*nombre_puntero_estructura).miembro
• Como los punteros a estructuras se usan muy frecuentemente, existe una
notación alternativa para acceder a cada miembro de una estructura
mediante un puntero y es el operador flecha “->”:
(2) nombre_puntero_estructura->miembro
• Por lo tanto, (1) y (2) son equivalentes.

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 21

 Estructuras y punteros

• Ejemplo:
typedef struct {
int dia;
int mes;
int anio;
} T_FECHA;

int main(void) {
T_FECHA fecha1; // Variable de tipo T_FECHA
T_FECHA *p_fecha; // Puntero a variable de tipo T_FECHA

fecha1.dia = 12;
fecha1.mes = 4;
fecha1.anio = 2002;

p_fecha = &fecha1; // el puntero apunta a la variable fecha1

printf(“La fecha es el dia %d, del mes %d del anio %d\n”,

p_fecha->dia, p_fecha->mes, // Notación con operador “.”
(*p_fecha).anio); // Notación con operador “->”

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 22

 Estructuras y punteros
int main(void) {
T_PERSONA persona;
#include <stdio.h>
T_PERSONA *puntero;
#define N 20
#define M 40
printf("Dame los datos de la persona\n");
#define T 10
printf("Dame el nombre: ");
fgets(persona.nombre, N, stdin);
typedef struct {
char nombre[N];
printf("Dame los apellidos: ");
char apellidos[M];
fgets(persona.apellidos, M, stdin);
char dni[T];
} T_PERSONA;
printf("Dame el DNI: ");
fgets(persona.dni, T, stdin);

puntero=&persona;

printf("\n\nDatos Personales\n");
printf("Nombre % s\n", puntero->nombre);
printf("Apellidos: %s\n", puntero->apellidos);
printf("Nombre: % s\n", puntero->dni);
return 0;
}

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 23

 Estructuras y funciones
• Existen dos opciones:
– Paso de estructuras por valor: se realiza una copia del parámetro real en el parámetro formal.
– Paso de estructuras por referencia: se pasa la dirección del comienzo de la estructura.
• Paso de estructuras por valor (es ineficiente pues se realiza una copia de la estructura):
– Se lleva a cabo igual que cuando se pasa por valor una variable a una función.
– Se realiza una copia de la estructura.
– Es un proceso costoso tanto en memoria como en tiempo.
– MEJOR UTILIZAR el paso por referencia.
• Paso de estructuras por referencia (es lo más adecuado):
– Se lleva a cabo de igual forma que cuando pasamos vectores a funciones.
– En este caso es OBLIGATORIO expresar el paso con notación de puntero.
– Será necesario hacer uso del operador (->) dentro de la función para acceder a cada uno de los
miembros de la estructura.

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 24

 Estructuras y funciones (Paso por valor)

#include <stdio.h>
typedef struct {
double real;
double imag;
} T_COMPLEJO;

T_COMPLEJO SumaComp(T_COMPLEJO c1, T_COMPLEJO c2);

int main(void) {
T_COMPLEJO comp1, comp2;
T_COMPLEJO resultado;

printf("Introduzca la parte real del primer complejo: ");

scanf("% lf", &comp1.real);
printf("Introduzca la parte imaginaria del primer complejo: ");
scanf("% lf", &comp1.imag);

printf("Introduzca la parte real del segundo complejo: ");

scanf("% lf", &comp2.real);
printf("Introduzca la parte imaginaria del segundo complejo: ");
scanf("% lf", &comp2.imag);

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 25

 Estructuras y funciones (Paso por valor) (sigue)

/* Viene de la transparencia anterior */

resultado = SumaComp(comp1, comp2);
printf("El resultado de la suma es % lf + % lf j\n", resultado.real, resultado.imag);
return 0;
}

T_COMPLEJO SumaComp(T_COMPLEJO c1, T_COMPLEJO c2) {

T_COMPLEJO res;
Atención, se está devolviendo
res.real = c1.real + c2.real; una estructura completa.
res.imag = c1.imag + c2.imag;
Y se están recibiendo copias
return res; de estructuras completas por
} argumento.
NOTA: En este programa, se hacen copias de las estructuras al hacer el paso por valor de las variables, con el gasto de memoria y de
tiempo que conlleva.

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 26

 Estructuras y funciones (Paso por referencia)

#include <stdio.h>
typedef struct { ¡¡MUCHO MEJOR DE ESTA FORMA!!
double real;
double imag;
}T_COMPLEJO;

void SumaComp(T_COMPLEJO *c1, T_COMPLEJO *c2, T_COMPLEJO *res);

int main(void) {
T_COMPLEJO comp1, comp2;
T_COMPLEJO resultado;

printf("Introduzca la parte real del primer complejo: ");

scanf("% lf", &comp1.real);
printf("Introduzca la parte imaginaria del primer complejo: ");
scanf("% lf", &comp1.imag);

printf("Introduzca la parte real del segundo complejo: ");

scanf("% lf", &comp2.real);
printf("Introduzca la parte imaginaria del segundo complejo: ");
scanf("% lf", &comp2.imag);

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 27

 Estructuras y funciones (Paso por ferencia)
(sigue)

/* Viene de la transparencia anterior */

SumaComp(&comp1, &comp2, &resultado);

printf("El resultado de la suma es % lf + % lf j\n", resultado.real, resultado.imag);

return 0;
}

void SumaComp(T_COMPLEJO *c1, T_COMPLEJO *c2, T_COMPLEJO *res) {

res->real = c1->real + c2->real;
res->imag = c1->imag + c2->imag;
}

NOTA: En este programa no se hace ninguna copia de las variables de tipo estructura, se pasa su referencia.

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 28

 Estructuras y funciones
#include <stdio.h>
typedef struct {
int numero1;
int numero2;
int numero3;
} T_NUMEROS;

int Suma(T_NUMEROS *puntero); /*función para sumar los campos de una estructura*/
int main(void) {
T_NUMEROS numeros;
int resultado;
numeros.numero1=1;
numeros.numero2=2;
numeros.numero3=3;
resultado=Suma(&numeros);
printf(“El resultado de la suma es % d\n”, resultado);
}
int Suma(T_NUMEROS *puntero) {
return (puntero->numero1 + puntero->numero2 + puntero->numero3);
}

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 29

 Vector de estructuras como parámetro de función
(opción 1)

int Buscar1(T_CLIENTE tabla[ ], int ncuenta, T_CLIENTE *reg);

int main(void) {
T_CLIENTE clientes[N];
#include <stdio.h>
T_CLIENTE cliente;
#include<string.h>
int ncuenta;
#define N 3
int existe;
#define TAM 20
/* Se rellena el vector con los N clientes */
typedef struct{
….
char nombre[TAM];
printf(“Introduzca N_ cuenta: de un cliente: “);
int no_cuenta;
scanf(“%d”, &ncuenta);
char tipo_cuenta;
existe = Buscar1(clientes, ncuenta, &cliente);
float saldo;
if (existe == 0) {
} T_CLIENTE;
printf(“Cliente No Existe\n”);
} else { // Buscar1 me deja el resultado en cliente
printf(“%s, %d\n”,cliente.nombre, cliente.no_cuenta);
printf(“%c , % f\n”,cliente.tipo_cuenta, cliente.saldo);
}
return 0;
}

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 30

 Vector de estructuras como parámetro de función
(opción 1)
int Buscar1(T_CLIENTE tabla[ ], int ncuenta, T_CLIENTE *reg) {
int i;
int existe ;
int encontrado;
existe = 0; /*valor 0 devuelto por la función si no existe el cliente*/

/* Inicializaciones */
encontrado = 0; // encontrado y existe valen siempre lo mismo (podríamos usar solo una de las dos)
for(i=0; i<N && encontrado == 0; i++)
if (tabla[i].no_cuenta ==ncuenta) {

}
strcpy(reg->nombre, tabla[i].nombre);
reg->no_cuenta = tabla[i].no_cuenta; *reg = tabla[i];
reg->tipo_cuenta=tabla[i].tipo_cuenta;
reg->saldo = tabla[i].saldo;
encontrado = 1;
existe=1 ; /*valor 1 devuelto por la función si existe el cliente*/
}
}
return(existe);
}

Nota: esta función busca en el vector “tabla” el cliente que tiene ese número de cuenta y devuelve la estructura correspondiente
usando paso por referencia.

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 31

 Vector de estructuras como parámetro de función
(opción 2)

T_CLIENTE Buscar2(T_CLIENTE tabla[ ], int ncuenta);

#include <stdio.h> int main(void) {
#define N 3 T_CLIENTE clientes[N];
#define TAM 20 T_CLIENTE cliente;
typedef struct{ int ncuenta; // se usaría -1 para indicar número de cuenta inválido
char nombre[TAM]; // Leer los N clientes
int no_cuenta; printf(“Introduzca Ncuenta de un cliente: ”);
char tipo_cuenta; scanf(“%d”, &ncuenta); // Faltaría validar para que ncuenta != -1
float saldo; cliente= Buscar2(clientes,ncuenta);
} T_CLIENTE; if (cliente.no_cuenta == -1) { // -1 es el marcador de ncuenta inválida
printf(“Cliente No Existe\n”);
} else {
printf(“%s\n”,cliente.nombre);
printf(“%d\n”,cliente.no_cuenta);
printf(“%c\n”,cliente.tipo_cuenta);
printf(“%f\n”,cliente.saldo);
}
return 0;
}

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 32

 Vector de estructuras como parámetro de función
(opción 2)

T_CLIENTE Buscar2(T_REGISTRO tabla[ ], int ncuenta) {

T_CLIENTE cliente;
int i;
int encontrado;

cliente.no_cuenta = -1 ; /* Inicializaciones */
encontrado = 0;
for(i=0; i<N && encontrado == 0; i++) {
if (tabla[i].no_cuenta == ncuenta) {
cliente=tabla[i];
encontrado = 1;
}
}
return(cliente);
}
Nota: esta función busca en el vector “tabla” el cliente que tiene ese número de cuenta y
devuelve la estructura correspondiente al cliente de forma directa.

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 33

 Estructuras y funciones (ejemplo)
Ejemplo: Cálculo del producto escalar de dos vectores de complejos
Se desea realizar un programa que calcule el producto escalar de dos vectores de números
complejos que el usuario introducirá por el teclado. La dimensión de los vectores será variable,
pidiéndose al usuario al principio del programa.
/* Programa: PVecComp
*
* Descripción: Pide al usuario dos vectores de números 1/5
* complejos y calcula su producto escalar.
*
* Revisión 0.0: 13/3/2002
*
* Autor: El programador estructurado.
*/
#include <stdio.h>
#include <stdlib.h>

/* Declaración de una estructura para contener números complejos */

typedef struct {
double real;
double imag;
} T_COMPLEJO;

/* Prototipos de las funciones */

void LeeVec(T_COMPLEJO v[], int dim);
COMPLEJO ProdEsc(T_COMPLEJO v1[], T_COMPLEJO v2[], int dim);

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 34

 Estructuras y funciones (ejemplo)
int main(void){
T_COMPLEJO *vec1; 2/5
T_COMPLEJO *vec2; /* Vectores introducidos por el usuario */
T_COMPLEJO res; /* Resultado del producto escalar */
int dim; /* Dimensión de los vectores*/

do {
printf("Introduzca la dimensión de los vectores: ");
scanf("%d", &dim);
} while (dim <= 0);

/* Asignación dinámica de memoria a los vectores vec1 y vec2 */

vec1 = (T_COMPLEJO *) calloc(dim, sizeof(T_COMPLEJO));

if (vec1 == NULL) {
printf(“Error asignando memoria a vec1\n“);
} else {
vec2 = (T_COMPLEJO *) calloc(dim, sizeof(T_COMPLEJO));
if (vec2 == NULL) {
printf(“Error asignando memoria a vec2\n“);
free(vec1);
} else {

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 35

 Estructuras y funciones (ejemplo)
3/5

printf("Introduzca los complejos del vector 1\n");

LeeVec(vec1, dim);

printf("Introduzca los complejos del vector 2\n");

LeeVec(vec2, dim);

res = ProdEsc(vec1, vec2, dim);

printf("El producto escalar es: %lf + %lf i\n",

res.real, res.imag);
free(vec2);
}
free(vec1);
}
return 0;
}

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 36

 Estructuras y funciones (ejemplo)
4/5
/* Función: LeeVec()
*
* Descripción: Lee del teclado un vector de números complejos de dimensión dim
*
* Argumentos: T_COMPLEJO v[]: Vector de estructuras de complejos
* donde se escribirán los números introducidos
* por el usuario.
* int dim: Dimensión del vector de complejos.
*/

void LeeVec(T_COMPLEJO v[], int dim) {

int i;

for(i=0; i<dim; i++){

printf("Parte real del elemento %d: ", i);
scanf("%lf", &v[i].real);
printf("Parte imaginaria del elemento %d: ", i);
scanf("%lf", &v[i].imag);
}
}

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 37

 Estructuras y funciones (ejemplo)
/* Función: ProdEsc()
* 5/5
* Descripción: Calcula el producto escalar de dos vectores de números
* complejos
*
* Argumentos: T_COMPLEJO v1[] y T_COMPLEJO v2[]: vectores de complejos.
* int dim: Dimensión de los vectores de complejos.
*
* Valor devuelto: complejo : Resultado del producto escalar.
*/

T_COMPLEJO ProdEsc(T_COMPLEJO v1[],T_COMPLEJO v2[], int dim) {

T_COMPLEJO resul;
int i;

resul.real = 0; /* Inicialización del resultado */

resul.imag = 0;

for(i=0; i<dim; i++){

resul.real += v1[i].real*v2[i].real - v1[i].imag*v2[i].imag;
resul.imag += v1[i].real*v2[i].imag + v1[i].imag*v2[i].real;
}
return resul;
}

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 38

 Ejercicios:
• Ejercicio 1: Escribir un programa para guardar los datos de un producto de una
empresa. Cada producto tiene estos campos: nombre(una cadena), precio(un
float), fecha de compra(una estructura de tipo T_FECHA).

• Ejercicio 2: Ampliar el ejercicio 1 para guardar los datos de n productos en un

vector de estructuras. Y posteriormente, escribir los datos de los productos en la
pantalla. El programa debe tener estas funciones:
1) función de lectura de los datos:
void Leer_productos( T_PRODUCTO productos[], int n ) ;
2) función para mostrar los datos:
void Mostrar_productos(T_PRODUCTO productos[], int n) ;

Fundamentos de Informática ICAI – 1º GITI Tema 9: Estructuras de datos 39

Escuela Técnica Superior de Ingeniería ICAI
Alberto Aguilera 25
28015 Madrid
Tel +34 91 542 28 00
Fax + 34 91 542 31 76
Iwww.icai.comillas.edu

www.comillas.edu