Exámen de LP.

Septiembre 2006

1. (2 puntos) Detecta los posibles errores en los siguientes segmentos de programa e intenta corregirlos razonando
su corrección:
(a) 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 l a c a n c i o n : ”<<c1 . e s t i l o ;
}

Solución:

En char titulo[]; no se reserva ningún espacio

Falta el ; al final de la estructura cancion
c1 no puede ser extern, pues su tipo se declara dentro

(b) void c a l c u l a r ( )
{ i nt i ( 2 ) , j ( 5 ) ; f l o a t c ( 7 . 2 ) ; void x ;
switch ( i+j −c )
{ case −2: case −1: { cout<<” R e s u l t a d o n e g a t i v o ” ;
break ; }
case 0 : { cout<<” R e s u l t a d o c e r o ” ;
break ; }
}
}
void o b t e n e r ( )
{ char ∗nombre ;
cout<<” I n t r o d u c e tu nombre : ” ; c i n >>nombre ; }

Solución:

x de tipo void, que no sirve para declarar variables

i+j-c se convierte automaticamente a float, y switch necesita un int
nombre no ha reservado espacio

2. (2 puntos) Implementa un programa que contenga una función eliminar_apariciones a la que se le pasan
como argumentos dos cadenas de caracteres previamente leı́das desde teclado y devuelva la primera cadena una
vez se han eliminado en ella las apariciones de la segunda. Si la segunda cadena es mayor que la primera debe
devolver el fin de cadena.
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,...). Se supone que el tamaño máximo de la
cadena de caracteres es de 80, y que debe ser tratada como vector de caracteres.
Ejemplo Para la cadena original “Laboratorio de programación es una asignatura un poco difı́cil y un poco fácil
a la vez” con la cadena a sustituir “un poco” el resultado será: “Laboratorio de programación es una asignatura
difı́cil y fácil a la vez”.

Página 1 de 5
Exámen de LP. Septiembre 2006

Solución:

char ∗ e l i m i n a r ( char ∗ s , char ∗ t ) {

i nt l e n s = 0 ;
i nt l e n t = 0 ;
char ∗ p s = s ;
char ∗ p t = t ;
// c a l c u l a m o s l o n g i t u d e s
while ( ∗ p s++) l e n s ++;
while ( ∗ p t++) l e n t ++;
i f ( l e n s < l e n t ){
return 0 ;
}
p s = s;
p t = t;
char ∗ s i n i c i a l = s ;
char ∗ tmp = new char [ l e n s + 1 ] ;
char ∗ desde = s ;
i nt i g u a l e s = 0 ;
i nt i n d e x = 0 ;
while ( ∗ p s ) { // recorremos l a cadena
i f ( ∗ p s != ∗ p t ) { // s i d i s t i n t o s copiamos
∗ ( tmp+i n d e x++) = ∗ p s ++;
} e l s e { // s i son i g u a l e s . . .
desde = p s ; // anotamos i n i c i o de c o i n c i d e n c i a
// m i e n t r a s c o i n c i d a n avan zo ambos
while ( ( ∗ p t != ’ \0 ’)&& ( ∗ p s++ == ∗ p t ++)){
i g u a l e s ++; // contamos c a n t i d a d de c o i n c i d e n c i a s
}
i f ( i g u a l e s < l e n t ) { // s i no s e c o m p l e t o l a c o i n c i d e n c i a
p s = desde ; // volvemos a t r a s y copiamos
while ( i g u a l e s > 0 ) {
∗ ( tmp + i n d e x++) = ∗ p s ++;
i g u a l e s −−;
}
} e l s e { // s i s e c o m p l e t o d e s p r e c i a m o s v a l o r y segu imos
iguales = 0;
}
p t = t ; // r e i n i c i a m o s a l p r i n c i p i o l a cadena a e l i m i n a r
}
}
∗ (tmp+i n d e x ) = ’ \0 ’ ;
char ∗ f u e n t e= tmp ;
char ∗ d e s t i n o= s i n i c i a l ;
// copiamos t e m p o r a l para d e v o l v e r l o
while ( ∗ d e s t i n o++ = ∗ f u e n t e ++){
// nada
}
delete [ ] tmp ;
return s i n i c i a l ;
}
i nt main ( ) {
char a [ 8 0 ] ;
char b [ 8 0 ] ;
co ut << ”Cadena o r i g i n a l : ” ;
cin . g etline (a , 79);
co ut << ”Cadena a e l i m i n a r : ” ;

Página 2 de 5
Exámen de LP. Septiembre 2006

cin . g e t l i n e (b , 79);
char ∗ r e s u l t = e l i m i n a r ( a , b ) ;
co ut << ” e l i m i n a d a ” << r e s u l t << e n d l ;
}

3. (6 puntos) Teniendo en cuenta la siguiente implementacion (incompleta) de la clase Matriz de enteros:

c l a s s Ma tr iz {
i nt n f i l a s ;
i nt ncolumnas ;
i nt ∗∗ e l e m e n t o s ;
public :
Ma tr iz ( i nt , i nt ) ;
. . . };
Ma tr iz : : Ma tr iz ( i nt f , i nt c ) : n f i l a s ( f ) , ncolumnas ( c )
{
e l e m e n t o s = new i nt ∗ [ n f i l a s ] ;
for ( i nt i =0; i < n f i l a s ; i ++)
e l e m e n t o s [ i ]= new i nt [ ncolumnas ] ;
}
...

(a) (3.5 puntos) Completa esta implementación añadiendo las funciones necesarias para que el siguiente código
sea correcto:
main ( )
{
Ma tr iz ma1 ( 3 , 7 ) , ma2 ( 1 , 1 ) , ma3 ( 2 , 2 ) ;
for ( i nt i =0; i <3; i ++)// I n i c i a l i z a r l o s e l e m e n t o s
for ( i nt j =0; j <7; j ++)
ma1 ( i , j )= 1 ; // Asign ar 1 a l e l e m e n t o i , j
ma1 += 5 ; // Sumar 5 a cada e l e m e n t o
cout<<ma1<<e n d l ;
ma2 = ma3 = 5 ∗ ma1 ; // M u l t i p l i c a r por 5 cada e l e m e n t o
i f (ma2 == ma3 ) cout<<” C o r r e c t o ”<<e n d l ;
i f (ma2 ( 2 , 4 ) ! = ma3 ( 2 , 4 ) ) cout<<” I n c o r r e c t o ”<<e n d l ;
} // Se d e s t r u y e n l o s o b j e t o s ( v a r i a b l e s ) ma1 , ma2 y ma3

Solución:
c l a s s Ma tr iz {
i nt n f i l a s ;
i nt ncolumnas ;
i nt ∗∗ e l e m e n t o s ;
public :
Ma tr iz ( int , i nt ) ;
i nt & operator ( ) ( int , i nt ) ;
void operator +=(i nt ) ;
fri end o str ea m & operator <<(o str ea m & out , const Ma tr iz &);
fri end Ma tr iz operator ∗ ( i nt n , Ma tr iz& m) ;
Ma tr iz & operator = ( const Ma tr iz &);
fri end bool operator == ( const Ma tr iz &, const Ma tr iz &);
˜ Ma tr iz ( ) ;
};
Ma tr iz : : Ma tr iz ( i nt f , i nt c ) : n f i l a s ( f ) , ncolumnas ( c ) {
e l e m e n t o s = new i nt ∗ [ n f i l a s ] ;
for ( i nt i =0; i <n f i l a s ; i ++){

Página 3 de 5
Exámen de LP. Septiembre 2006

e l e m e n t o s [ i ] = new i nt [ ncolumnas ] ;
}
}
i nt & Ma tr iz : : operator ( ) ( i nt f i l a , i nt columna ) {
return e l e m e n t o s [ f i l a ] [ columna ] ;
}
void Ma tr iz : : operator+=(i nt n ) {
for ( i nt f i l a =0; f i l a < n f i l a s ; f i l a ++){
for ( i nt columna=0; columna< ncolumnas ; columna++){
e l e m e n t o s [ f i l a ] [ columna ] +=n ;
}
}
}
o str ea m & operator <<(o str ea m & out , const Ma tr iz & m) {
for ( i nt f i l a =0; f i l a < m. n f i l a s ; f i l a ++){
for ( i nt columna=0; columna< m. ncolumnas ; columna++){
out << m. e l e m e n t o s [ f i l a ] [ columna ] ;
}
out << e n d l ;
}
return out ;
}
Ma tr iz operator ∗ ( i nt n , Ma tr iz& m) {
Ma tr iz r e t (m. n f i l a s , m. ncolumnas ) ;
for ( i nt f i l a =0; f i l a < m. n f i l a s ; f i l a ++){
for ( i nt columna=0; columna< m. ncolumnas ; columna++){
r e t . e l e m e n t o s [ f i l a ] [ columna ] = m. e l e m e n t o s [ f i l a ] [ columna ] ∗ n ;
}
}
return r e t ;
}
Ma tr iz & Ma tr iz : : operator=(const Ma tr iz &m) {
i f ( t h i s==&m) {
return ∗ t h i s ;
}
for ( i nt f i l a =0; f i l a < n f i l a s ; f i l a ++){
delete [ ] e l e m e n t o s [ f i l a ] ;
}
delete [ ] e l e m e n t o s ;
n f i l a s=m. n f i l a s ;
ncolumnas=m. ncolumnas ;
e l e m e n t o s = new i nt ∗ [m. n f i l a s ] ;
for ( i nt f i l a =0; f i l a < n f i l a s ; f i l a ++){
e l e m e n t o s [ f i l a ] = new i nt [ ncolumnas ] ;
}
for ( i nt f i l a =0; f i l a < n f i l a s ; f i l a ++){
for ( i nt columna=0; columna< ncolumnas ; columna++){
e l e m e n t o s [ f i l a ] [ columna ] = m. e l e m e n t o s [ f i l a ] [ columna ] ;
}
}
return ∗ t h i s ;
}
bool operator==(const Ma tr iz & a , const Ma tr iz & b ) {
i f (&a == &b ) return true ;
i f ( a . n f i l a s != b . n f i l a s ) return f a l s e ;
i f ( a . ncolumnas != b . ncolumnas ) return f a l s e ;
for ( i nt f i l a =0; f i l a < a . n f i l a s ; f i l a ++){

Página 4 de 5
Exámen de LP. Septiembre 2006

for ( i nt columna=0; columna< a . ncolumnas ; columna++){

i f ( a . e l e m e n t o s [ f i l a ] [ columna ] != b . e l e m e n t o s [ f i l a ] [ columna ] ) {
return f a l s e ;
}
}
}
return true ;
}
Ma tr iz : : ˜ Ma tr iz ( ) {
for ( i nt f i l a =0; f i l a < n f i l a s ; f i l a ++){
delete e l e m e n t o s [ f i l a ] ;
}
delete [ ] e l e m e n t o s ;
}

(b) (1 punto) Define una clase Tablero que contenga una Matriz de 8 filas por 8 columnas, implementa el
constructor de la clase Tablero.

Solución:
c l a s s Ta bler o {
Ma tr iz m;
public :
Ta bler o ( ) : m( 8 , 8 ) {

}
};

(c) (1.5 puntos) Modifica la declaración de la clase Matriz para convertirla en una clase genérica (los elementos
de la matriz puedan ser de un tipo T cualquiera), e implementa solamente el constructor de la nueva clase
genérica.

Solución:
template <typename T>
class MatrizGenerica {
i nt n f i l a s ;
i nt ncolumnas ;
T ∗∗ e l e m e n t o s ;
public :
M a t r i z G e n e r i c a ( int , i nt ) ;
};
template <typename T>
Ma tr izGener ica <T> : : M a t r i z G e n e r i c a ( i nt f , i nt c )
: n f i l a s ( f ) , ncolumnas ( c ) {
e l e m e n t o s = new T ∗ [ n f i l a s ] ;
for ( i nt f i l a =0; f i l a < n f i l a s ; f i l a ++){
e l e m e n t o s [ f i l a ] = new T [ ncolumnas ] ;
}
}

Página 5 de 5