Exámen de LP.

Junio 2007 (Práctica)

1. Dadas las siguientes estructuras y declaraciones:

# include <i o s t r e a m >
using namespace s t d ;
const unsigned i nt MAXFAMILIAS ( 10 ) ;
const unsigned i nt MAXNOMBRE ( 30 ) ;
const unsigned i nt MAXDIRECCION ( 50 ) ;
struct g a s t o {
float gastosTransporte ;
float gastosVivienda ;
float gastosAlimentacion ;
};
struct f a m i l i a {
char nombre [ MAXNOMBRE ] ;
enum TDo micilio { c a l l e , p l a z a , a v e n i d a } t i p o D o m i c i l i o ;
char d i r e c c i o n [ MAXDIRECCION ] ;
unsigned i nt numeroMiembros ;
gasto gastosFamilia ;
};
struct s e t F a m i l i a s {
f a m i l i a f a m i l i a s [ MAXFAMILIAS } ;
i nt numFamilias ; // Numero t o t a l de f a m i l i a s e x i s t e n t e s en e l v e c t o r f a m i l i a s
};

(a) Implementar una función que devuelva los datos de una familia completa, leı́dos por teclado dentro de la
propia función.

Solución:
familia leeFamilia (){
familia ret ;
i nt t i p o D i r ;
co ut << ”Nombre : ” ;
c i n . g e t l i n e ( r e t . nombre , MAXNOMBRE) ;
co ut << ” Tipo d i r e c c i o n ( 0 : c a l l e , 1 : p l a z a , 2 : avda ) : ” ;
c i n >> t i p o D i r ;
switch ( t i p o D i r ) {
case f a m i l i a : : c a l l e :
ret . tipoDomicilio = familia : : c a l l e ;
break ;
case f a m i l i a : : p l a z a :
ret . tipoDomicilio = fa mi l i a : : plaza ;
break ;
case f a m i l i a : : a v e n i d a :
r e t . tipoDomicilio = f a m i l i a : : avenida ;
break ;
}
cin . ignore ( ) ;
co ut << ” D i r e c c i o n : ” ; c i n . g e t l i n e ( r e t . d i r e c c i o n , MAXDIRECCION ) ;
co ut << ”Numero de miembros : ” ; c i n >> r e t . numeroMiembros ;
co ut << ” Ga sto s t r a n s p o r t e : ” ; c i n >> r e t . g a s t o s F a m i l i a . g a s t o s T r a n s p o r t e ;
co ut << ” Ga sto s v i v i e n d a : ” ; c i n >> r e t . g a s t o s F a m i l i a . g a s t o s V i v i e n d a ;
co ut << ” Ga sto s a l i m e n t a c i o n : ” ; c i n >> r e t . g a s t o s F a m i l i a . g a s t o s A l i m e n t a c i o n ;
cin . ignore ( ) ;
return r e t ;
}

(b) Implementar una función que añada al array estático de familias una familia recibida como argumento,
siempre y cuando el nombre de esta familia no exista en dicho array. Además, el array debe mantenerse

Página 1 de 4
Exámen de LP. Junio 2007 (Práctica)

ordenado alfabéticamente por el nombre de las familias. La función debe ser implementada utilizando sólo
aritmética de punteros (sin indexar los punteros ni los vectores), y sin usar las funciones predefinidas para
cadenas (strlen, strcmp, etc), a la hora de tratar el vector de caracteres nombre para la comparación y la
ordenación. Sı́ se puede indexar el array familias [MAXFAMILIAS].

Solución:
void a g r e g a r F a m i l i a ( f a m i l i a f ) {
i nt pos = 0 ;
i nt d i f = 0 ;
while ( pos < v e c i n d a r i o . numFamilias ) {
i f ( comparar ( f . nombre , v e c i n d a r i o . f a m i l i a s [ pos ] . nombre ) == 0 ) {
co ut << ” F a m i l i a e x i s t e n t e : ” << f . nombre << e n d l ;
return ;
}
pos++;
}
v e c i n d a r i o . f a m i l i a s [ v e c i n d a r i o . numFamilias ] = f ;
v e c i n d a r i o . numFamilias++;

i f ( v e c i n d a r i o . numFamilias < 2 ) {
return ;
}
bool o r dena do s ;
do{
i nt uno =0 , o t r o =1;
o r dena do s = true ;
while ( o t r o < v e c i n d a r i o . numFamilias ) {
i f ( ( comparar ( v e c i n d a r i o . f a m i l i a s [ uno ] . nombre , v e c i n d a r i o . f a m i l i a s [ o t r o ] . nombre
f a m i l i a tmp = v e c i n d a r i o . f a m i l i a s [ uno ] ;
v e c i n d a r i o . f a m i l i a s [ uno ] = v e c i n d a r i o . f a m i l i a s [ o t r o ] ;
v e c i n d a r i o . f a m i l i a s [ o t r o ] = tmp ;
o r dena do s = f a l s e ;
}
uno++;
o t r o ++;
}
} while ( ! o r dena do s ) ;
}
i nt comparar ( char ∗ a , char ∗ b ) {
i nt d i f f = 0 ;
while ( true ) {
i f ( ( d i f f = ∗ a − ∗b++) != 0 | | ( ! ∗ a++)){
break ;
}
}
return d i f f ;
}

2. Dadas las siguientes estructuras y declaraciones:

# include <i o s t r e a m >
using namespace s t d ;
const unsigned i nt MAXFAMILIAS ( 10 ) ;
const unsigned i nt MAXNOMBRE ( 30 ) ;
const unsigned i nt MAXDIRECCION ( 50 ) ;
struct g a s t o {
float gastosTransporte ;
float gastosVivienda ;

Página 2 de 4
Exámen de LP. Junio 2007 (Práctica)

float gastosAlimentacion ;
};
struct f a m i l i a {
char nombre [ MAXNOMBRE ] ;
enum TDo micilio { c a l l e , p l a z a , a v e n i d a } t i p o D o m i c i l i o ;
unsigned i nt numeroMiembros ;
gasto gastosFamilia ;
s t r i n g ∗ nombreMiembros ;
};

(a) Convertir las estructuras de datos gasto y familia en clases.

Solución:

class gasto {
public :
float gastosTransporte ;
float gastosVivienda ;
float gastosAlimentacion ;
};
class f a m i l i a {
public :
char nombre [ MAXNOMBRE ] ;
enum TDo micilio { c a l l e , p l a z a , a v e n i d a } t i p o D o m i c i l i o ;
unsigned i nt numeroMiembros ;
gasto gastosFamilia ;
s t r i n g ∗ nombreMiembros ;
};

(b) Implementar las funciones necesarias para que el siguiente código se ejecute de forma correcta:
i nt main ( ) {
// El primer argumento d e l c o n s t r u c t o r c o r r e s p o n d e a l nombre de l a f a m i l i a ,
// e l segu n do a l t i p o de d o m i c i l i o , e l t e r c e r o a l numero de miembros , y l o s 3
// u l t i m o s argumentos c o r r e s p o n d e n a l o s g a s t o s .
// Por d e f e c t o , l o s a t r i b u t o s s e i n i c i a l i z a r a n :
// Nombre : cadena v a c i a
// Tipo de D o m i c i l i o : c a l l e
// Numero de miembros : 2
// Nombre de l o s miembros : cadena v a c i a
// Gast os ( cada uno de e l l o s ) : 0 . 0

f a m i l i a f 1 ( ”Romero” , c a l l e , 2 , 5 0 , 5 0 0 , 600 ) ;
f a m i l i a f 2 ( ”Lamas” , p l a z a , 1 ) ;
f2 = f1 ;
co ut << f 2 ;
return 0 ;
}

Solución:
#include <i o s t r e a m>
using namespace s t d ;
const unsigned i nt MAXFAMILIAS ( 10 ) ;
const unsigned i nt MAXNOMBRE ( 30 ) ;
const unsigned i nt MAXDIRECCION ( 50 ) ;
class gasto {
public :

Página 3 de 4
Exámen de LP. Junio 2007 (Práctica)

float gastosTransporte ;
float gastosVivienda ;
float gastosAlimentacion ;
};
class f a m i l i a {
public :
char nombre [ MAXNOMBRE ] ;
enum TDo micilio { c a l l e , p l a z a , a v e n i d a } t i p o D o m i c i l i o ;
unsigned i nt numeroMiembros ;
gasto gastosFamilia ;
s t r i n g ∗ nombreMiembros ;
f a m i l i a ( const char ∗ nombre=” ” , TDo micilio t i p o D o m i c i l i o = c a l l e , i nt numeroMiemb
s t r c p y ( this −>nombre , nombre ) ;
this −>t i p o D o m i c i l i o = t i p o D o m i c i l i o ;
this −>numeroMiembros = numeroMiembros ;
this −>g a s t o s F a m i l i a . g a s t o s T r a n s p o r t e = gastoT ;
this −>g a s t o s F a m i l i a . g a s t o s V i v i e n d a= gastoV ;
this −>g a s t o s F a m i l i a . g a s t o s A l i m e n t a c i o n = gastoA ;
this −>nombreMiembros = new s t r i n g [ numeroMiembros ] ;
for ( i nt n=0; n<numeroMiembros ; n++){
nombreMiembros [ n ] = ” ” ;
}
}
f a m i l i a & operator=(const f a m i l i a& c o p i a ) {
s t r c p y ( nombre , c o p i a . nombre ) ;
tipoDomicilio = copia . tipoDomicilio ;
numeroMiembros = c o p i a . numeroMiembros ;
gastosFamilia = copia . gastosFamilia ;
delete [ ] nombreMiembros ;
this −>nombreMiembros = new s t r i n g [ numeroMiembros ] ;
for ( i nt n=0; n<numeroMiembros ; n++){
nombreMiembros [ n ] = c o p i a . nombreMiembros [ n ] ;
}
}
˜ familia (){
delete [ ] nombreMiembros ;
}
};
o str ea m & operator << ( o str ea m & o , f a m i l i a & f ) {
o << ”Nombre : ” << f . nombre << e n d l ;
o << ”Num. miembros : ” << f . numeroMiembros << e n d l ;
o << ” Ga sto s t r a n s p o r t e : ” << f . g a s t o s F a m i l i a . g a s t o s T r a n s p o r t e << e n d l ;
o << ” Ga sto s v i v i e n d a : ” << f . g a s t o s F a m i l i a . g a s t o s V i v i e n d a << e n d l ;
o << ” Ga sto s a l i m e n t a c i o n : ” << f . g a s t o s F a m i l i a . g a s t o s A l i m e n t a c i o n << e n d l ;
o << ” Miembros : ” << e n d l ;
for ( i nt n=0; n < f . numeroMiembros ; n++){
o << f . nombreMiembros [ n ] << e n d l ;
}
return o ;
}

Página 4 de 4