¡Descarga Tema 4 - Datos estructurados y más Apuntes en PDF de Ingeniería del Software solo en Docsity!
UNIVERSIDAD DE MALAGA
DPTO. DE LENGUAJES Y C. DE LA COMPUTACION
E.T.S. DE INGENIERIA INFORMATICA
FUNDAMENTOS DE LA PROGRAMACIÓN
TTEE
MMAA
IIVV
TIPOS DE DATOS ESTRUCTURADOS IV.1. Registros.IV.1.1. Tipo de Datos
struct
IV.1.2. Registros como Parámetros.IV.1.3. Ejemplo con registros.
IV.2. Arrays.
IV.2.1. Tipo de Datos
array
IV.2.2. Arrays como Parámetros.
IV.2.2.1.
Ejemplo con arrays unidimensionales.
IV.2.3. Problemas comunes al trabajar con arrays.IV.2.4. Utilidad de los arrays.IV.2.5. Arrays Multidimensionales.
IV.2.5.
.Ejemplo con Arrays Multidimensionales.
IV.2.6. Arrays Abiertos como Parámetros.
IV.2.6.
. Ejemplo de Arrays Abiertos.
IV.3. Cadenas de caracteres.
IV.3.1. Tipo de datos
string
IV.3.2.
String
s como Parámetros.
IV.3.2.
. Ejemplo con string
IV.4. Resolución de Problemas usando Tipos Estructurados
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
En el tema 2 de esta asignatura Fundamentos de la Programación hemos estudiado los tiposde datos simples en C++. En este tema abordaremos los tipos de datos estructurados, es decir,aquellos que se definen como composición de otros tipos de datos ya definidos, ya seansimples o estructurados. En C++ los tipos estructurados son el registro, el tipo
array
y la
cadena de caracteres. IV.1.
Registros
Un registro es una colección de elementos que pueden ser de tipos distintos. O lo que es lomismo, en la estructura registro no existe un único tipo base. A cada componente de laestructura se le llama campo, y podrá ser de cualquier tipo (simple o estructurado). IV.1.
Tipo de Datos
struct
Para definir un tipo registro
se utilizará la palabra reservada
struct
seguida del
identificador del tipo y de la relación de componentes entre llaves, terminada en ';'. Para cadacomponente se indica el tipo e identificador del componente terminado en ';'. Ejemplo:
//^
tipo
enumerado enum
Tmes
enero,
febrero,
marzo,
abril,
mayo,
junio,
Julio,
agosto, sepiembre,
octubre,
noviembre, diciembre
};//^
tipo
registro struct TFecha {
unsigned
dia; Tmes
mes; unsigned
agno;
Una vez definido un tipo registro se pueden declarar variables y constantes de dicho
tipo:
const
TFecha
HOY={16,
diciembre,
TFecha f_nac,f_ant;
Los identificadores dia, mes y agno representan los nombres de los elementos
componentes del registro TFecha, denominados campos. Los nombres de los campos de unregistro son locales a él, por lo que no hay conflicto con otros nombres en el programa.
Una referencia a un campo de un registro consiste en el nombre de la variable (o
constante) registro y el nombre del campo, separados por un punto.
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
Se puede acceder a un componente concreto del registro de forma directa, de forma
que con un campo de un registro se podrá hacer cualquier operación admisible para el tipo dedicho campo, como la operación de asignación:
f_nac.dia
=^ 5 ;
f_nac.mes
=^ enero; f_nac.agno
=^
Con respecto a operaciones con registros completos, es posible asignar registros
completos si son del mismo tipo:
f_ant
=^ f_nac;
Así como inicializar una variable o una constante de tipo registro:
TFecha
f_nac =
{^
marzo,
Pero sin embargo, C++ no permite realizar comparaciones de igualdad o desigualdad
entre registros:
if^ (f_ant
==^
f_nac )
{^
}^
//^
ERROR
if^ (f_ant
!=^
f_nac )
{^
}^
//^
ERROR
if^ (f_ant
<^
f_nac )
{^
}^
//^
ERROR
Tampoco permite la lectura y escritura directa sobre dispositivos de E/S estándares.
Este tipo de operaciones debe realizarse componente a componente.
Los campos de un registro pueden ser de cualquier tipo, simple o estructurado:
enum
TMes
{^ enero
,^ febrero
,^ marzo
,^ abril
,^ mayo
,^ junio
,^ julio
,^ agosto
septiembre
,^ octubre
,^ noviembre
,^ diciembre
struct
TFecha
unsigned
dia
TMes
mes
unsigned
agno
struct
TEmpleado
unsigned
codigo
float
sueldo
TFecha
fecha_ingreso
;^ //
un registro
dentro
de otro
IV.1.
Registros como Parámetros^ Un registro se puede pasar tanto
por valor
como
por referencia
a un subprograma
Sin embargo, y por motivos de eficiencia, el paso de registros no se suele hacer
por valor
, ya
que es una operación muy costosa tanto en tiempo de CPU como en consumo de memoria,por lo que siempre se suelen pasar
por referencia
, y en el caso de ser un parámetro de
entrada, se pasa
por referencia constante
para evitar que pueda ser modificado y que se siga
cumpliendo que es un dato exclusivamente de entrada. Ejemplo:
void
escribir_fecha(const
TFecha& fech)
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
// escritura
del
registro
campo
a campo
Un registro también puede ser el valor devuelto por una función. Pero por las mismas
razones de eficiencia expuestas anteriormente respecto al paso de parámetros, es convenienteque el valor devuelto por una función no sea de un tipo estructurado. En ese caso, serápreferible construir un procedimiento y que el valor se devuelva como parámetro de salidamediante paso
por referencia
void
leer_fecha(TFecha&
fech)
//^ lectura del
registro
campo a
campo
En resumen, las operaciones que se pueden realizar sobre registros completos son la
asignación, la inicialización de una variable o constante de tipo registro, y el paso comoparámetro a subprogramas, bien por referencia si el parámetro es de salida o entrada/salida opor referencia constante, caso de ser parámetro de entrada IV.1.
Ejemplo con registros
Suponemos definida la siguiente estructura registro que representa un instante de tiempo: struct
TTiempo
unsigned
horas
,minutos
,segundos
}; Ejemplo:
Función para calcular los segundos transcurridos entre dos instantes de
tiempo dados
unsigned
convsegundos
( const
TTiempo
&^ t)
return
t. horas
+^
t.minutos
+^
t.segundos
} unsigned
calcsegundos
( const
TTiempo
&^ t1,
const
TTiempo
&^ t2)
return
convsegundos(t1)-convsegundos(t2);
}
Ejemplo:
Procedimiento para convertir un tiempo expresado en segundos a formato dehoras, minutos, segundos.
void
convtie
mpo ( unsigned
seg,
TTiempo
&^ t)
t.horas
=^ seg /3600; seg=
seg
%^ 3600;
t.minutos
= seg
t.segundos
=^ seg
%^
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
using
namespace
std;
typedef
int
TVector
[10];
//^
indexado
desde
la posición
a la
void
LeerVector
(TVector
&^ v)
//^
lee valores
para
cada
componente
del
vector
for ( unsigned
i=0; i<10;i++){ cout<<
"Introduzca
v["
<<i<<
"]:
cin>>v[i]; } } void
ImprimirVector
( const
TVector
&^ v)
//^
muestra
por
pantalla
los
valores
del
vector
for ( unsigned
i=0; i<10;i++){ cout<<
"v["
<<i<<
"]: "
cout<<v[i]<<endl;; } } int main
()^
TVector
v1; LeerVector(v1);ImprimirVector(v1); return
} IV.2.
Problemas comunes al trabajar con arrays:Inicialización:
Las variables de tipo
array
, al igual que cualquier variable, deben ser
inicializadas,
bien mediante lectura por teclado de cada una de sus componentes o bien
mediante asignaciones componente a componente.
Índice fuera de rango:
Siempre hay que comprobar que se accede a una posición
válida dentro del
array
. El lenguaje de programación C++ no comprueba que el valor del
índice se encuentre dentro del rango válido para acceder a un elemento de un
array
. En caso
de acceso (tanto para consultar su valor, como para modificarlo) fuera del rango válido,pueden ocurrir errores inesperados durante la ejecución del programa. De hecho, puedesuceder que el error se manifieste en otro punto del programa, e incluso que no se manifiestevisiblemente, y que permanezca oculto. Este hecho puede dar lugar a errores muy difíciles dedetectar. IV.2.
Utilidad de los arrays^ Consideremos el siguiente ejemplo: Una empresa tiene en plantilla 20 agentes de
ventas (identificados por números del 1 al 20) que cobran comisión sobre la parte de susoperaciones comerciales que excede los 2/3 del promedio de ventas del grupo.
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
Se necesita un algoritmo que lea el valor de las operaciones comerciales de cada
agente e imprima el número de identificación de aquellos que deban percibir comisión asícomo el valor correspondiente a sus ventas.
Este problema tiene 2 aspectos que juntos lo hacen difícil de programar con los
mecanismos vistos hasta ahora:
Procesamiento similar sobre los datos de cada agente:
^ leer ventas ^ calcular promedio de ventas ^ comparar niveles ^ decidir si debe o no recibir comisión
Se necesita almacenar durante la ejecución del programa los valores de las ventas de
cada agente: para el cálculo del promedio y para la comparación de niveles. Esto implica quenecesitamos 20 variables para retener los valores de las ventas.
Un posible algoritmo sería:
#include
using
namespace
std;
const
float
PORCION=2.0/3.0;
int main
()^
float
ventas1,ventas2,ventas3, ventas4,...ventas20; //^
ventas realizadas
por
cada
agente
float
suma=0.0;
//^
acumulado de
ventas
float
umbral;
//^ valor
minimo
para
obtener comision
cout<<
"Introduzca
las
ventas
del
agente:
"<<endl;
cin>>ventas1;suma=
suma+ventas1; cout<<
"Introduzca
las
ventas
del
agente:
"<<endl;
cin>>ventas2;suma=suma+ventas2;cout<<
"Introduzca
las
ventas
del
agente:
"<<endl;
cin>>ventas3;suma=
suma+ventas3; cout<<
"Introduzca
las
ventas
del
agente:
"<<endl;
cin>>ventas4;suma=
suma+ventas4;... cout<<
"Introduzca
las
ventas
del
agente:
"<<endl;
cin>>ventas20;suma=
suma+ventas20; umbral=
PORCION*(suma/20.0); if^ (ventas1>umbral) {
cout<<
"Ventas
del
Agente
1:^
"<<ventas1;
} if^ (ventas2>umbral)
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
cout<<
"Ventas
del
Agente
2:^
"<<ventas2;
} if^ (ventas3>umbral) {
cout<<
"Ventas
del
Agente
3:^
"<<ventas3;
} if^ (ventas4>umbral)
cout<<
"Ventas
del
Agente
4:^
"<<ventas4;
if^ (ventas20>umbral)
cout<<
"Ventas
del
Agente
"<<ventas20;
return
La escritura de este programa es, como se ve, bastante tediosa. El problema se
agravaría más si en lugar de 20 hubiera 200 agentes de ventas.
Una
mejor
solución
consiste
en
considerar
estas
variables
de
ventas
como
componentes de una estructura de datos
array
. Cada componente tendrá como
índice
asignado el número de identificación del correspondiente agente de ventas.
La definición del tipo
array
sería:
const
unsigned
NUMAGENTES=20;
typedef
float
TVentas
[NUMAGENTES];
posiciones,
indice
desde
La variable de este tipo se declararía dentro del
main
como:
TVentas
ventas;
De forma que ventas[i] almacenará las ventas realizadas por el agente número i. Lo
que va entre corchetes al referirse a un componente de un
array
puede ser cualquier expresión
que al evaluarse dé como resultado un valor del tipo
indice
del
array
Con estos datos nuestro algoritmo podría escribirse:
#include
using
namespace
std; const
float
PORCION=2.0/3.0;
const
unsigned
NUMAGENTES=20;
typedef
float
TVentas
[NUMAGENTES];
posiciones,
indice
desde
void
leerVentas
(TVentas
&^ ventas)
for^
( unsigned
i=0; i<NUMAGENTES;i++)
cout<<
"Introduzca
ventas
del agente "
<<i+1<<
":^ "
cin>>ventas[i]; }
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
} float
calcMedia
( const
TVentas
& ventas)
float
suma=0.0; for ( unsigned
i=0; i<NUMAGENTES;
i++)
suma=
suma+ventas[i];
} return
suma/NUMAGENTES;
} void
imprimir
( const
TVentas
&^ ventas,
float
umbral)
for ( unsigned
i=0; i<NUMAGENTES;
i++)
if^ (ventas[i]>umbral){
cout<<
"Ventas
del
Agente
"<<i+1<<
"^ :"
<<ventas[i];
int main
()^
TVentas
ventas; float
umbral; leerVentas(ventas);umbral=
PORCION*calcMedia(ventas); imprimir(ventas,umbral); return
} IV.2.
Arrays Multidimensionales^ Al definir el tipo
array
intervienen siempre 2 tipos : el tipo
indice
y el tipo
base
. El
tipo
indice
ha de ser un ordinal de cardinalidad finita, pero sobre el tipo
base
no existe
restricción alguna. Al poder usarse cualquier tipo como tipo base de un
array
, esto incluye la
posibilidad de usar tipos estructurados como tipo base de un
array
. De esta forma, en caso de
que el tipo base de un
array
sea a su vez otro
array
, obtendremos
array
s multidimensionales.
Por ejemplo:
const
unsigned
Filas=5;
const
unsigned
Columnas=3;
typedef
int
TVectorFila
[Columnas];
typedef
TVectorFila
TMatriz
[Filas];
matriz
de 5
Vectores
Fila
También es posible declararlo de la siguiente forma:
const
unsigned
Filas=5;
const
unsigned
Columnas=3;
typedef
int
TMatriz
[Filas][Columnas];
matriz
6x
Si declaramos la variable
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
int resultado=0; for ( unsigned
co=0;
co<Columnas;
co++)
resultado+= fila[co]; } return
resultado;
} int sumarCol
( const
TMatriz
&^ mat,
unsigned
co)
int res=0; for ( unsigned
fi=0;
fi<Filas;
fi++)
res=res+
mat[fi][co];
} return
res;
} int main
()^
TMatriz
a; TVectorColumna
b;
TVectorFila
c;
leerMatriz(a); for ( unsigned
fi=0;
fi<Filas;
fi++)
b[fi]= sumarFila(a[fi]); } for ( unsigned
co=0;
co<Columnas;
co++)
c[co]= sumarCol(a,co); } for ( unsigned
fi=0;
fi<Filas;fi++)
escribirFila(a[fi]);cout<<b[fi];cout<<endl; }escribirFila(c); return
} IV.2.
Arrays Abiertos como Parámetros^ Hay situaciones en las que deseamos implementar un subprograma que trabaje con
array
s, independientemente de su tamaño. De forma tal que el tamaño del
array
en el
subprograma (parametro formal) se adecue al tamaño del
array
pasado durante la invocacion
al mismo (parametro real). Para ello, el parámetro formal se declara especificando su tipobase, el identificador y el símbolo
[]^
que indica que dicho parámetro es un
array
sin tamaño
especificado, su tamaño dependerá del tamaño del parámetro real especificado en cadainvocación al subprograma. El tipo base del parámetro real debe coincidir con el delparámetro formal. La información sobre el tamaño del
array
se pierde al pasarlo como
array
abierto, por lo que dicho tamaño se deberá también pasar como parámetro.
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
En caso de pasar
array
s multidimensionales como parámetros abiertos, sólo es posible
poner la primera dimensión sin especificar.
El paso se realiza siempre por referencia sin necesidad de especificar el símbolo
& , y
para asegurar que no sea modificado en caso de información de entrada, se realizará el pasode parámetros
constante
IV.2.6.
Ejemplo de Arrays Abiertos
#include
using
namespace
std;
const
unsigned
TAMANO_
const
unsigned
TAMANO_
typedef
int
Tvector_
[TAMANO_1];
typedef
int
Tvector_
[TAMANO_2];
void
imprimir
( int
n,^
//^
numero
de elementos
const
int
vct[])
// Parámetro
de entrada: vector de
enteros
// paso por
referencia
constante
for ( int
i^
=^ 0;
i^ <^ n;
++i)
cout<<
"^ v["
<< i
"]:
cout
vct[i]
"^ "
}cout
endl;
} void
valores
( int
n,
//^ numero
de elementos
int^
vct[])
//^
vector
de enteros
(paso
por
referencia)
for ( int
i^
=^ 0;
i^ <^ n;
++i)
cout<<
"Introduzca
componente
v["
<<i<<
"]:^
cin
vct[i];
} } int main
Tvector_
vector_1; Tvector_
vector_2; cout<<
"Lectura de
valores
para
el array
"<<endl;
valores(TAMANO_1,
vector_1);
cout<<
"Escritura
de los
valores
del
array
1:^
"<<endl;
imprimir(TAMANO_1,
vector_1);
cout<<
"Lectura de
valores
para
el array
"<<endl;
valores(TAMANO_2,
vector_2);
cout<<
"Escritura
de los
valores
del
array
2:^
"<<endl;
imprimir(TAMANO_2,
vector_2);
return
Sólo es válido declarar
array
s abiertos como parámetros. No es posible declarar
variables como
array
s abiertos.
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
IV.3.
CADENAS DE CARACTERES.
En numerosos programas es frecuente encontrarnos con la necesidad de usar cadenas (osecuencia) de caracteres. Por ejemplo, si queremos implementar una agenda personal, ¿cómorepresentaríamos el nombre de las personas, su dirección, etc. ?En general los lenguajes de programación (y en particular C++) presentan dos posibilidades:ofrecer un tipo Cadena como tipo predefinido en el lenguaje, o programar la idea de cadenacomo una parte más del problema, mediante una estructura
array
cuyo tipo base sea el tipo
char. En C++ el tratamiento de las cadenas de caracteres se puede realizar de estas dos formasdiferentes:
utilizando
el^
tipo
string
proporcionado
por
la
biblioteca
estándar,
o
implementado sobre
array
s de caracteres al estilo "C" utilizando como carácter terminador el
'\0'
. En nuestros programas
siempre
utilizaremos el tipo
string
de la biblioteca estándar.
IV.3.
El tipo de datos
string
Un valor del
tipo predefinido
string
será una secuencia de caracteres de
longitud
indefinida
( aunque
limitada
por
la
implementación).
Representaremos
las
literales
constantes de tipo cadena entre comillas, por ejemplo:“Juan Mena”. Podremos definir tantoconstantes como variables y parámetros.En C++ el tratamiento de las cadenas de caracteres se realiza a través del tipo
string
proporcionado por la biblioteca estándar. Para ello deberemos incluir en nuestro programa lasdefiniciones que de dicho tipo hace la biblioteca estándar mediante la siguiente sentencia alprincipio del programa:
#include
Podremos definir tanto variables como constantes de dicho tipo de la siguiente forma:
const
string
nombre =
"pepe
garcia";
//^
string
constante
string
cadena;
//^
variable
cadena
vacia
string
otro
=^
nombre;
//^
copia
de nombre
Es posible realizar las siguientes operaciones con variables de tipo
string
-^
Asignación
A una variable de tipo
string
se le puede asignar directamente tanto una cadena de
caracteres (o carácter) constante como otra variable de tipo
string
(o de tipo carácter).
const
string
nombre =
"jose";
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
string
cadena; string
nmb; cadena
=^
nombre;
//^
asigna
el valor
de nombre
a^ cadena
-^
Concatenación
de dos cadenas ( + ):
En la concatenación, al menos uno de los dos primeros operandos debe estar
declarado de tipo
string
La operación de concatenación será imprescindible para añadir caracteres a una
cadena porque no es posible acceder fuera del rango de la misma.
cadena
'^
';^
//^
añade
un espacio
al final
de cadena
cadena
"garcia";
cadena
valdra
"jose garcia"
nmb^
=^ cadena
'^ +
"lopez";
nmb
= "jose
garcia
lopez"
nmb^
=^ "pepe"
//^
ERROR
-^
Comparación
lexicográfica:
Es posible comparar variables y constantes de tipo
string
mediante los operadores
relaciones
>^
>=^
<^ <=
) siempre y cuando al menos uno de los operandos esté
declarado como de tipo
string
if (nombre
"jose")
{^
...^
}^ if
(nombre
!= "jose")
{^
if (cadena
>^
nombre)
{^
...^
}^ if
(nombre
>=^
"jose")
{^
if (cadena
<^
nombre)
{^
...^
}^ if
(nombre
<= "jose")
{^
if ("pepe"
"pepe")
{^
...^
}^ //
ERROR
También se puede utilizar la función
compare
que devuelve tres posibles
valores: int^
res; res^
=^ cadena.compare(nombre);//^ si cadena
<^ nombre
res <
//^ si cadena
==^
nombre ->
res ==
//^ si cadena
^ nombre
res >
-^
Longitud: Para saber el número de caracteres de un
string
se utiliza
size
int^
n^ = cadena.size();
-^
Acceso
al i-ésimo carácter de una cadena ([i]), donde i
∈^ [0..nombre.size() - 1]
Se accede a los caracteres que la componen mediante indexación donde el primer
elemento se encuentra en el índice
0 , y el último elemento en el índice
size()-
string
cadena
=^
"pepe
garcia";
// string
constante
char
primera_letra
=^
cadena[0];
// toma
valor
'p'
char
ultima_letra
= cadena[cadena.size()-1];
//^
toma
valor
'a'
cadena[0]
=^
‘P’;
// pone
el^
primer
carácter de
cadena
a ‘P’
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
IV.3.2.
Ejemplo con string
Se desea leer una cadena de caracteres, y copiarla en orden inverso en otra cadena.
#include
#include
using
namespace
std;
void
invertirCadena
( const
string
&^ palabra,
string
&^ invertida)
for ( int
i=palabra.size()-1;i>=0;i--) {
invertida=
invertida+palabra[i];
} int main
string
entrada,
invertida;
cout<<
"Escribir
la palabra:
cin>>entrada;invertirCadena(entrada, invertida);cout<<
"La palabra
"<<entrada<<
"^ invertida
es:
"<<invertida<<endl;
return
} IV.4.
Resolución de Problemas usando Tipos Estructurados
Implementación de una Agenda personal: Se pretende diseñar un programa para la gestión deuna 'agenda'. La información personal que será almacenada es la siguiente:NombreTeléfonoDirección
CalleNúmeroPisoCódigo PostalCiudad
Las operaciones a realizar con dicha agenda serán:
1.^ Añadir los datos de una persona2.^ Acceder a los datos de una persona a partir de su nombre.
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
3.^ Borrar una persona a partir de su nombre.4.^ Modificar los datos de una persona a partir de su nombre.
#include
#include
using
namespace
std;
unsigned
const
MAXPERSONAS
=^
int const
NO_VALIDA
=^ -1;
Indica
posición no
valida
del
array
struct
TDireccion { unsigned
num
string
calle
string
piso
string
cp
string
ciudad
struct
TPersona {
string
nombre
string
tel
TDireccion
direccion
typedef
TPersona
TPersonas
[MAXPERSONAS];
/ Array
de 50 registros
TPersona
struct
TAgenda {
unsigned
num_pers
;^ //número
real
de^
personas
almacenada
TPersonas
pers
;^
//datos
de dichas personas
}; void
Inicializar
(TAgenda
& ag)
ag. num_pers
//^
agenda
con
registros
TPersona
almacenados
}^ void
LeerDireccion
(TDireccion
&^ dir)
cout<<
"Introduzca
calle:
cin>>dir.
calle
cout<<
"Introduzca
número: "
cin>>dir.
num
cout<<
"Introduzca
piso:
cin>>dir.
piso
cout<<
"Introduzca
código
postal: "
cin>>dir.
cp; cout<<
"Introduzca
ciudad: "
cin>>dir.
ciudad
} void
LeerPersona
(TPersona
&^ per)
cout<<
"Introduzca
nombre:
cin>>per.
nombre
cout<<
"Introduzca
telefono:
cin>>per.
tel; LeerDireccion(per.
direccion
}^ void
EscribirDireccion
( const
TDireccion
& dir)
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
cout<<dir.
calle
cout<<dir.
num
cout<<dir.
ciudad
} void EscribirPersona
( const
TPersona
& per)
cout<<
"Nombre:
"<<per.
nombre
cout<<
"Telefono:
"<<per.
tel;
EscribirDireccion(per.
direccion
} int^ BuscarPersona
( const
string
nombre,
const
TAgenda
&^ ag)
/*^ *^
Busca
una
Persona
en la Agenda
*^ Devuelve
su posicion
si se encuentra,
o bien
en otro
caso
unsigned
ind=0; int res; while
((ind <
ag.
num_pers
)^ &&(nombre
ag.
pers
[ind].
nombre
{ind=ind+1;} if^ (ind
<^
ag. num_pers
res=ind; } else {
res=
NO_VALIDA;
} return
res;
} void
AgnadirPersona
( const
TPersona
&^ per,
TAgenda
& ag)
int i; i=BuscarPersona(per.
nombre
,^ ag);
if^ (i^
!=^
NO_VALIDA)
cout<<
"La persona
ya se encuentra
en la^
agenda"
<<endl;
} else {
if^
(ag.
num_pers
==^
MAXPERSONAS)
cout<<
"Agenda
Llena."
<<endl;
} else {
ag.pers
[ag.
num_pers
]^ =
per;
ag.num_pers
=^
ag. num_pers
+^
} void
BorrarPersona
( const
string&
nombre,
TAgenda
& ag)
int i; i=^ BuscarPersona(nombre,
ag);
if^ (i==
NO_VALIDA)
E.T.S. de Ingeniería Informática
Dpto de Lenguajes y C. de la Computación
_______________________________________
Fundamentos de la Programación
Tema IV. Tipos de datos estructurados
{cout<<
"La persona
no^
se encuentra
en^
la^ agenda"
} else {ag.
pers
[i]= ag.
pers
[ag.
num_pers
-1];
ag. num_pers
=^
ag. num_pers
-^ 1;
} void
ModificarPersona
( const
string&
nombre,
const
TPersona
&^ nuevosDatos,
TAgenda
&^ ag) {
int i; i^ = BuscarPersona(nombre,
ag);
if^ (i^
==^
NO_VALIDA)
cout<<
"La persona
no se encuentra
en la^
agenda"
} else
{ag.pers
[i] =^ nuevosDatos;
}
} char^
Menu
char
res; cout<<
"A.-
Anadir
Persona"
<<endl;
cout<<
"B.-
Buscar
Persona"
<<endl;
cout<<
"C.-
Borrar
Persona"
<<endl;
cout<<
"D.-
Modificar
Persona"
<<endl;
cout<<
"X.-
Salir"
<<endl;
do^ {
cout<<
"Introduzca
Opcion:
cin>>res; } while
(res!=
'A'
&&res!=
'B'
&&res!=
'C'
&&res!=
'D'
&&res!=
'X'
return
res;
} int main
TAgenda
ag; char
opcion; TPersona
per; string
nombre; int i; Inicializar(ag); do {
opcion
=^
Menu(); switch
(opcion) { case
('A'
cout<<
"Introduzca
datos
de Persona:
"<<endl;
LeerPersona(per);AgnadirPersona(per,
ag);
break
case
('B'
cout<<
"Introduzca
Nombre"
cin>>nombre;