Anda di halaman 1dari 8

Exámen de LP.

Junio 2005

1. (1 punto) Detecta los posibles errores en los siguientes segmentos de programa e intenta corregirlos razonando
su corrección:
char op ;
switch ( op ) {
case ”v” : cout<<” V i s u a l i z a r ” ;
case ” c ” : cout<<” Cr ea r ” ;
char ∗ v e c t o r ;
i f ( ( v e c t o r=new char ∗ [5])==NULL)
cout<<” E r r o r . F a l t a de memoria ” ;
else crear ( vector [ 2 ] ) ;
break ;
}
void f u n c i o n ( ) {
struct c a n c i o n
{ char t i t u l o [ ] ;
enum { rock , pop , c o p l a , l i g e r o } e s t i l o ;
unsigned i nt u n i d a d e s ; }
extern c a n c i o n c1 ;
s t a t i c i nt c o d i g o ( 1 ) ;
.....
cout<<” E s t i l o de c a n c i o n : ”<<c1 . e s t i l o ;
}

Solución:

1. Los casos estan entre comillas.


2. Deberı́a haber un break después del primer caso

3. vector es un char* y new está creando un array de punteros a char, al que apunta vector, deberı́a
declararse como char ** vector
4. No parece muy lógico que la función crear reciba el tercer elemento del vector como parámetro
5. El array titulo no tiene un tamaño
6. Al declarar struct cancion dentro de funcion, no puede haber un elemento extern de ese tipo
7. Falta el punto y coma después de la llave de la estructura

2. (1 punto) Describe la salida proporcionada por los siguientes trozos de código:


(a) i nt &cambiar ( i nt &a , i nt &b ) ;
i nt main ( )
{
i nt i ( 3 ) , j ( 5 ) ;
cambiar ( i , j )= 1 5 ;
cout<<i <<ends<<j ;
return 0 ;
}
i nt &cambiar ( i nt &a , i nt &b )
{ i f ( a<b ) return a ;
e l s e return b ; }

Solución:
La función cambiar devuelve una referencia a un entero, el menor de los dos que recibe. Devolverá una
referencia a su parámetro a, al cual le enviamos la referencia a i. Al ejecutarse la función, i queda con
el valor asignado de 15. La salida será:

Página 1 de 8
Exámen de LP. Junio 2005

15 5

(b) void main ( )


{
deque<int> d ;
deque<int > : : i t e r a t o r i t e ;
for ( i nt i =0; i <10; i ++){
d . push ba ck ( i ) ;
d . push front ( i );}
d . pop front ( ) ;
d . pop back ( ) ;
d . e r a s e ( d . b e g i n ()+ 1 ) ;
d . e r a s e ( d . end ()− 1 ) ;
for ( i t e= d . b e g i n ( ) ; i t e !=d . end ( ) ; i t e ++)
cout <<∗i t e <<” ” ;
cout<<e n d l ;
}

Solución:
En este caso solo hay que tener en cuenta que el método end() de deque devuelve el elemento que está uno
después del último, ası́ que al borrar d.end()-1 estamos borrando el último. Primero agregamos al
principio y al final desde el 0 al 9 incluidos.
9 8 7 6 5 4 3 2 1 0 0 12 34 56 789
Luego quitamos el primero ( el 9)
8 7 6 5 4 3 2 1 0 0 1 23 456 78 9
Quitamos el último ( el otro 9)
8 7 6 5 4 3 2 1 0 0 1 234 567 8
Borramos el primero + 1 ( aquı́ sı́, begin() devuelve el primer elemento) que es el 7
8 6 5 4 3 2 1 0 0 1 23 456 78
Borramos end()-1, es decir, el último, o sea, el 8
8 6 5 4 3 2 1 0 0 1 234 567
Desde el principio hasta uno antes de end(), es decir, hasta el último elemento
8 6 5 4 3 2 1 0 0 1 234 567

3. (1 punto) Implementa un programa que contenga una función (eliminar_caracteres) a la que se le pasa
una cadena de caracteres y dos caracteres previamente leı́dos desde el teclado. Dicha función debe devolver
una cadena que contenga los caracteres de la cadena original eliminando aquellos comprendidos entre los dos
caracteres recibidos (orden alfabético). La función debe ser implementada usando sólo aritmética de punteros
(sin indexar los punteros ni los vectores), y sin usar las funciones predefinidas para cadenas (strlen, strcmp,
etc). Se supone que el tamaño máximo de la cadena de caracteres es de 79, y que debe ser tratada como un vector
de caracteres (p.e. para la cadena “laboratorio de programacion” y los caracteres ‘b’ y ‘o’, la cadena resultante
serı́a “aratr prraa”).

Solución:

#include <i o s t r e a m>


using namespace s t d ;

Página 2 de 8
Exámen de LP. Junio 2005

char ∗ e l i m i n a r c a r a c t e r e s ( char ∗ cadena , char a , char b ) ;


i nt main ( void ) {
char f r a s e [ 8 0 ] ;
char desde , h a s t a ;
co ut << ” t e c l e a l a cadena ” ;
cin . g e tl i n e ( frase , 80);
co ut << e n d l << ” t e c l e a l o s c h a r s desde y h a s t a : ” ;
c i n >> desde >> h a s t a ;
co ut << e l i m i n a r c a r a c t e r e s ( f r a s e , desde , h a s t a ) << e n d l ;
}
char ∗ e l i m i n a r c a r a c t e r e s ( char ∗ cadena , char a , char b ) {
char c , ∗ r e t=cadena , ∗p1=cadena , ∗ p2=cadena ;
while ( ( c = ∗ p2 )!= 0 ) {
i f ( c < a | | c > b){
∗p1++ = c ;
}
p2++;
}
∗ p1 = 0 ;
return r e t ;
}

4. (2 puntos) Se dispone de dos ficheros con las siguientes estructuras:


const i nt tam1 ( 3 0 ) ;
const i nt tam2 ( 1 2 ) ;
struct empleado
{
char nombre [ tam1 ] ;
unsigned i nt edad ;
};
struct empresa
{
char nombre [ tam1 ] ;
char CIF [ tam2 ] ;
};

La relación que existe entre ambos ficheros es la siguiente: la empresa en la que trabaja el empleado del primer
registro del fichero empleados se encuentra en el primer registro del fichero empresas, para el empleado del
segundo registro del fichero empleados se usara el segundo registro del fichero empresas, y ası́ sucesivamente.
Implementa una función que mezcle ambos ficheros de la siguiente forma: se debe crear otro fichero denominado
activos que contenga la información de cada empleado junto con la información de la empresa en que trabaja,
pero sólo de aquellos empleados cuya edad sea menor de 60 años.

Solución:

#include <f s t r e a m>


#include <i o s t r e a m>
using namespace s t d ;
i nt c r e a r f i c h e r o s ( void ) ;
void m e z c l a r f i c h e r o s ( void ) ;
void m o s t r a r a c t i v o s ( void ) ;
const i nt TAM NOMBRE( 3 0 ) ;
const i nt TAM CIF ( 1 2 ) ;
struct empleado {
char nombre [TAM NOMBRE ] ;

Página 3 de 8
Exámen de LP. Junio 2005

unsigned i nt edad ;
};
struct empresa{
char nombre [TAM NOMBRE ] ;
char c i f [ TAM CIF ] ;
};
struct a c t i v o {
struct empleado empleado ;
struct empresa empresa ;
};
void m e z c l a r f i c h e r o s ( ) {
i f s t r e a m empleados , empr esa s ;
ofstream activos ;
empleados . open ( ” empleados . dat ” , i o s : : i n | i o s : : b i n a r y ) ;
i f ( ! empleados ) return ;
empr esa s . open ( ” empr esa s . dat ” , i o s : : i n | i o s : : b i n a r y ) ;
i f ( ! empr esa s ) return ;
a c t i v o s . open ( ” a c t i v o s . dat ” , i o s : : out | i o s : : b i n a r y ) ;
i f ( ! a c t i v o s ) return ;
empleado empl ;
empresa empr ;
activo act ;
while ( ( empleados . r ea d ( ( char ∗ ) &empl , s i z e o f ( empleado ) ) && ! empleados . e o f ( ) ) ) {
empr esa s . r ea d ( ( char∗)&empr , s i z e o f ( empresa ) ) ;
i f ( empl . edad < 6 0 ){
s t r c p y ( a c t . empleado . nombre , empl . nombre ) ;
a c t . empleado . edad = empl . edad ;
s t r c p y ( a c t . empresa . nombre , empr . nombre ) ;
s t r c p y ( a c t . empresa . c i f , empr . c i f ) ;
a c t i v o s . w r i t e ( ( char ∗ ) &a ct , s i z e o f ( a c t i v o ) ) ;
}
}
activos . close ( ) ;
empleados . c l o s e ( ) ;
empr esa s . c l o s e ( ) ;
}

5. (3 puntos) Implementa la clase conjunto de caracteres, teniendo en cuenta que debe utilizar espacio de alma-
cenamiento dinámico, e implementa lo necesario para que el código siguiente sea correcto:
main ( ) {
c o n j u n t o t e r m i n a l e s ( ” abc ” ) ;
conjunto v a r i a b l e s , otro ;
terminales . anadir ( ’d ’ ) ;
cout<<t e r m i n a l e s ;
terminales . borrarelto ( ’ c ’ ) ;
cout<<t e r m i n a l e s ;
v a r i a b l e s . anadir ( ’S ’ ) ;
v a r i a b l e s . a n a d i r ( ’A ’ ) ;
conjunto simbolos ( v a r i a b l e s ) ;
o t r o= ’ : ’+t e r m i n a l e s ;
s i m b o l o s+o t r o ;
cout<<s i m b o l o s ;
}

Página 4 de 8
Exámen de LP. Junio 2005

Solución:

#include <i o s t r e a m>


using namespace s t d ;
class conjunto {
public :
conjunto ( ) ;
c o n j u n t o ( const c o n j u n t o &);
c o n j u n t o ( char ∗ ) ;
void a n a d i r ( char c ) ;
void a n a d i r ( const c o n j u n t o &c ) ;
void b o r r a r e l t o ( char c ) ;
c o n j u n t o & operator=(const c o n j u n t o &b ) ;
fri end o str ea m& operator << ( o str ea m &out , const c o n j u n t o &c ) ;
private :
char ∗ da ta ;
i nt l e n ;
i nt s i z e ;
};
conjunto : : conjunto (){
size = 10;
da ta = new char [ s i z e ] ;
da ta [ 0 ] = 0 ;
len = 0;
}
c o n j u n t o : : c o n j u n t o ( const c o n j u n t o & c ) {
size = c . size ;
da ta = new char [ s i z e ] ;
len = c . len ;
i nt n ;
for ( n=0; n<l e n ; n++){
da ta [ n ] = c . da ta [ n ] ;
}
da ta [ n ] = 0 ;
}
c o n j u n t o : : c o n j u n t o ( char ∗ c ) {
len = s tr len ( c ) ;
s i z e = l e n +1;
da ta = new char [ s i z e ] ;
i nt n ;
for ( n=0; n<l e n ; n++){
da ta [ n ] = c [ n ] ;
}
da ta [ n ] = 0 ;
}
void c o n j u n t o : : a n a d i r ( char c ) {
char ∗ newdata ;
l e n ++;
i f ( l e n >= s i z e ) {
s i z e ∗= 2 ;
newdata = new char [ s i z e ] ;
for ( i nt n=0; n<l e n ; n++){
newdata [ n ] = da ta [ n ] ;
}
delete [ ] da ta ;
da ta = newdata ;
}

Página 5 de 8
Exámen de LP. Junio 2005

da ta [ l e n −1] = c ;
da ta [ l e n ] = 0 ;
}
void c o n j u n t o : : a n a d i r ( const c o n j u n t o &c ) {
char ∗ newdata ;
l e n+=c . l e n ;
i f ( len > s i z e ){
s i z e += l e n ;
newdata = new char [ s i z e ] ;
for ( i nt n=0; n<l e n ; n++){
newdata [ n ] = da ta [ n ] ;
}
delete [ ] da ta ;
da ta = newdata ;
}
s t r c a t ( data , c . da ta ) ;
}
void c o n j u n t o : : b o r r a r e l t o ( char c b o r r a r ) {
char c , ∗ p1=data , ∗ p2=da ta ;
while ( ( c = ∗ p2 )!= 0 ) {
i f ( c != c b o r r a r )
∗p1++ = c ;
else
l e n −−;
p2++;
}
∗ p1 = 0 ;
}
c o n j u n t o& c o n j u n t o : : operator= ( const c o n j u n t o &b ) {
char ∗ newdata ;
len = b . len ;
size = b. size ;
i nt n ;
newdata = new char [ s i z e ] ;
for ( n=0; n<l e n ; n++){
newdata [ n ] = b . da ta [ n ] ;
}
newdata [ n ] = 0 ;
delete [ ] da ta ;
da ta = newdata ;
return ∗ t h i s ;
}
o str ea m& operator<< ( o str ea m &out , const c o n j u n t o &c ) {
out << c . da ta ;
return out ;
}
c o n j u n t o operator+ ( const c o n j u n t o &a , const c o n j u n t o &b ) {
c o n j u n t o tmp ( a ) ;
tmp . a n a d i r ( b ) ;
return tmp ;
}
c o n j u n t o operator+ ( char c , const c o n j u n t o &a ) {
c o n j u n t o tmp ( a ) ;
tmp . a n a d i r ( c ) ;
return tmp ;
}

Página 6 de 8
Exámen de LP. Junio 2005

6. (2 puntos) Implementa la clase persona, que contenga al menos una variable DNI y disponga de un constructor
parametrizado. A partir de ella, define la clase alumno, conteniendo al menos una variable codigo y un constructor
paramétrizado, y la clase profesor, conteniendo al menos una variable despacho y un constructor parametrizado.
Después, define la clase becario que herede a partir de las clases alumno y profesor, conteniendo una variable
materia. Es decir la definición de objetos de la clase becario serı́a similar a:
b e c a r i o b1 ( ” 12345678A” , 1 0 7 1 , ”D−411” , ”LP” ) ;
b e c a r i o b2 ( ” 87654321Z” , 1 2 3 9 , ”D−313” , ”SM” ) ;

Solución:

#include <i o s t r e a m>


using namespace s t d ;
c l a s s P er so na{
public :
P er so na ( char ∗ d n i ) {
s t r c p y ( P er so na : : dni , d n i ) ;
}
protected :
char d n i [ 1 0 ] ;
};
c l a s s Alumno : v i r t u a l public P er so na{
public :
Alumno ( char ∗ dni , i nt c o d i g o )
: P er so na ( d n i ) , c o d i g o ( c o d i g o ) {
}
protected :
i nt c o d i g o ;
};

c l a s s P r o f e s o r : v i r t u a l public P er so na {
public :
P r o f e s o r ( char ∗ dni , char ∗ despa cho )
: P er so na ( d n i ) {
s t r c p y ( this −>despacho , despa cho ) ;
}
protected :
char despa cho [ 6 ] ;
};
c l a s s B e c a r i o : public Alumno , public P r o f e s o r {
public :
B e c a r i o ( char ∗ dni , i nt c o d i g o , char ∗ despacho , char ∗ m a t e r i a )
: P er so na ( d n i ) , Alumno ( dni , c o d i g o ) , P r o f e s o r ( dni , despacho ) {
s t r c p y ( this −>ma ter ia , m a t e r i a ) ;
}
fri end o str ea m & operator << ( o str ea m& out , B e c a r i o &b ) ;
private :
char m a t e r i a [ 3 ] ;
};
o str ea m & operator << ( o str ea m& out , B e c a r i o &b ) {
out << ” DNI : ”<< b . d n i << ” Codigo : ” << b . c o d i g o
<< ” Despacho : ” <<b . despa cho << ” Ma ter ia : ” <<b . ma ter ia<< e n d l ;
return out ;
}
i nt main ( void ) {
B e c a r i o b1 ( ” 12345678A” , 1 0 7 1 , ”D−411” , ”LP” ) ;
B e c a r i o b2 ( ” 87654321Z” , 1 2 3 9 , ”D−313” , ”SM” ) ;
co ut << b1 << b2<< e n d l ;

Página 7 de 8
Exámen de LP. Junio 2005

Página 8 de 8