Ligadura

1. [001.txt] Se pretende escribir un programa para calcular la nota media de las calificaciones obtenidas en el
examen de la materia LP. Suponemos que hay dos tipos de alumnos que se califican de diferente modo:
alumno del plan viejo, que tiene dos notas, notaC y notaCPP, y su calificación es la nota media de ambas
alumno del plan nuevo, que tiene una única nota y su calificación es dicha nota.
Realizar los siguientes ejercicios:
Definir la clase base alumno, con un constructor parametrizado que reciba el DNI del alumno.
Definir a partir de la clase alumno la clase alumno_planviejo, con un constructor que almacene las dos
notas del alumno y un función calcular_nota() que devuelva la calificación del alumno.
Definir a partir de la clase alumno la clase alumno_plannuevo con un constructor que almacene la nota del
alumno y una función calcular_nota() que devuelva dicha calificación.
Implementar una función calcularnotamedia() que reciba como argumento un vector de punteros a alum-
nos, apuntando a cada uno de los alumnos, del plan viejo o del plan nuevo, y el numero total de alumnos,
y calcule utilizando ligadura dinamica la nota media obtenida por todos los alumnos.
Escribe un programa de ejemplo

Solución:

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

#include <c s t r i n g >
using namespace s t d ;
c l a s s alumno {
public :
alumno ( const char ∗ d n i ) {
s t r c p y ( this−>dni , d n i ) ;
}
v i r t u a l f l o a t c a l c u l a r n o t a ( ) =0;
char d n i [ 1 0 ] ;
};
c l a s s a l u m n o p l a n v i e j o : public alumno {
public :
a l u m n o p l a n v i e j o ( const char ∗ dni , f l o a t notaC , f l o a t notaCPP )
: alumno ( d n i ) , notaC ( notaC ) , notaCPP ( notaCPP ) {
}
float calcular nota () {
return ( notaC+notaCPP ) / 2 ;
}
f l o a t notaC , notaCPP ;

};
c l a s s alumno plannuevo : public alumno {
public :
alumno plannuevo ( const char ∗ dni , f l o a t nota )
: alumno ( d n i ) , nota ( nota ) {
}
float calcular nota () {
return nota ;
}
f l o a t nota ;

};
f l o a t c a l c u l a r n o t a m e d i a ( alumno ∗ alumnos [ ] , int c a n t i d a d ) {
float total = 0;
f or ( int n=0; n< c a n t i d a d ; n++){
t o t a l += alumnos [ n]−> c a l c u l a r n o t a ( ) ;

Página 1 de 10
Ligadura

}
return t o t a l / c a n t i d a d ;
}
int main ( ) {
alumno ∗ a u l a [ 3 ] ;
a u l a [ 0 ] = new a l u m n o p l a n v i e j o ( ” 34000001A” , 9 . 0 , 1 0 . 0 ) ;
a u l a [ 1 ] = new alumno plannuevo ( ” 44433221H” , 1 . 0 ) ;
a u l a [ 2 ] = new a l u m n o p l a n v i e j o ( ” 34000002A” , 9 . 0 , 1 0 . 0 ) ;
c o u t << ” nota media : ” << c a l c u l a r n o t a m e d i a ( aula , 3 )<<e n d l ;
cin . get () ;
}

2. [002.txt] Ligadura dinamica

Crea las clases SistemaDeTransporte y sus herederas: Metro, Avion, Barco y Autobus
Crea un metodo velocidadPunta que devuelva la velocidad punta de cada sistema
Crea un metodo transoceanico que diga si el sistema puede cruzar el oceano. Haz sea necesario redefinir
el método más que en los que sean transoceanicos, es decir, que el método que hereden devuelva false.
Crea un array desde cuyas posiciones puedas manejar 10 sistemas de transporte diferentes.
Crea diez objetos distintos y carga el array con ellos.
Recorre el array para obtener la media de las velocidades punta de los que no sean transoceanicos

Solución:

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

#include <c s t d l i b >
#include <cmath>
using namespace s t d ;
c l a s s SistemaDeTransporte {
public :
v i r t u a l int v e l o c i d a d P u n t a ( ) =0;
v i r t u a l bool t r a n s o c e a n i c o ( ) {
return f a l s e ;
}
};
c l a s s Metro : public SistemaDeTransporte {
int v e l o c i d a d P u n t a ( ) {
return 7 0 ;
}
};
c l a s s Barco : public SistemaDeTransporte {
bool t r a n s o c e a n i c o ( ) {
return true ;
}
int v e l o c i d a d P u n t a ( ) {
return 6 0 ;
}
};
c l a s s Avion : public SistemaDeTransporte {
bool t r a n s o c e a n i c o ( ) {
return true ;
}
int v e l o c i d a d P u n t a ( ) {

Página 2 de 10
Ligadura

return 4 0 0 ;
}
};
c l a s s Autobus : public SistemaDeTransporte {
int v e l o c i d a d P u n t a ( ) {
return 1 0 0 ;
}
};
SistemaDeTransporte ∗ c r e a V e h i c u l o ( ) ;
int main ( ) {
s r an d ( time ( 0 ) ) ; // i n i c i a s e m i l l a a l e a t o r i a (<cmath >)
SistemaDeTransporte ∗ v e h i c u l o s [ 1 0 ] ;
f or ( int n=0;n<10;n++){
vehiculos [ n ] = creaVehiculo () ;
}
int t o t a l =0, numTransoceanicos =0;
f or ( int n=0;n<10;n++){
i f ( ! ( v e h i c u l o s [ n]−> t r a n s o c e a n i c o ( ) ) ) {
t o t a l+= v e h i c u l o s [ n]−> v e l o c i d a d P u n t a ( ) ;
numTransoceanicos++;
}
}
c o u t << ” V e h i c u l o s : ” << numTransoceanicos << e n d l ;
c o u t << ” Media : ”<< t o t a l / numTransoceanicos << e n d l ;
}
SistemaDeTransporte ∗ c r e a V e h i c u l o ( ) {
int a z a r = rand ( ) % 4 ; //numero a l e a t o r i o de 0 a 3
switch ( a z a r ) {
case 0 : return new Barco ( ) ; break ;
case 1 : return new Avion ( ) ; break ;
case 2 : return new Autobus ( ) ; break ;
case 3 : return new Metro ( ) ; break ;
}
return 0 ;
}

3. [003.txt] Hemos organizado una carrera a través del pais. En ella pueden participar coches, motos y cuads. La
reglamentacion obliga a cada participante a pagar una cantidad por la incripción. Para los coches se pagarán 10
euros por cada centı́metro cúbico de motor, para las motos 100 euros por cada kilo de peso y para los cuads una
cuota fija de 3000 euros. Hemos creado una clase Participante, de la que derivan las clases Coche, Moto y Cuad.
Crea una funcion recaudacion que reciba un array de punteros a Participante y el número de participantes
inscritos y te devuelva la recaudación.

Solución:

#include <f s t r e a m >

#include <i o s t r e a m >
using namespace s t d ;
class Participante {
public :
v i r t u a l int p r e c i o ( ) =0;
};
int r e c a u d a c i o n ( P a r t i c i p a n t e ∗ p a r t i c i p a n t e s [ ] , int n u m P a r t i c i p a n t e s ) ;
c l a s s Coche : public P a r t i c i p a n t e {
public :

Página 3 de 10
Ligadura

Coche ( int c c )
: cc ( cc ) {
}
int p r e c i o ( ) ;
private :
s t a t i c const int c u o t a p o r c c = 1 0 ;
int c c ;
};
c l a s s Moto : public P a r t i c i p a n t e {
public :
Moto ( int p e s o )
: peso ( peso ) {
}
int p r e c i o ( ) ;
s t a t i c const int c u o t a p o r k i l o = 1 0 0 ;
private :
int p e s o ;
};
c l a s s Cuad : public P a r t i c i p a n t e {
public :
int p r e c i o ( ) ;
s t a t i c const int c u o t a f i j a= 3 0 0 0 ;
};
int Coche : : p r e c i o ( ) {
return c u o t a p o r c c ∗ c c ;
}
int Moto : : p r e c i o ( ) {
return c u o t a p o r k i l o ∗ p e s o ;
}
int Cuad : : p r e c i o ( ) {
return c u o t a f i j a ;
}
int main ( ) {
Moto m( 3 ) ;
Coche c ( 2 ) ;
Cuad q ;
Participante ∗ inscripcion [ 3 ] ;
i n s c r i p c i o n [ 0 ] = &m;
i n s c r i p c i o n [ 1 ] = &c ;
i n s c r i p c i o n [ 2 ] = &q ;
c o u t << ” T o t a l recaudado : ” << r e c a u d a c i o n ( i n s c r i p c i o n , 3 ) << e n d l ;
}
int r e c a u d a c i o n ( P a r t i c i p a n t e ∗ p a r t i c i p a n t e s [ ] , int n u m P a r t i c i p a n t e s ) {
int t o t a l ( 0 ) ;
f or ( int n=0; n<n u m P a r t i c i p a n t e s ; n++){
t o t a l += p a r t i c i p a n t e s [ n]−> p r e c i o ( ) ;
}
return t o t a l ;
}

4. [004.txt] En el siguiente programa, indicar cómo se resuelven todos los mensajes (mediante ligadura dinámica
o estática) y qué función se ejecuta (clase base o clase derivada).
class base {
protected :
int b ;
public :

Página 4 de 10
Ligadura

v i r t u a l void mos tr ar ( ) { c o u t << ” b= ” << b << e n d l ; }

void almacenar ( ) { c i n >> b ; }
};
c l a s s d e r i v a d a : public b a s e {
protected :
int d ;
public :
void mos tr ar ( ) { c o u t << ” b= ” << b << ” , d= ” << d << e n d l ; }
void almacenar ( ) { c i n >> b >> d ; }
};
void main ( ) {
b a s e obj1 , ∗p ;
d e r i v a d a obj2 , ∗q ;
p = &o b j 1 ;
p −> almacenar ( ) ;
p −> mos tr ar ( ) ;
q = &o b j 2 ;
q −> almacenar ( ) ;
q −> mos tr ar ( ) ;
p = &o b j 2 ;
p −> almacenar ( ) ;
p −> mos tr ar ( ) ;
}

Solución:

/∗
p−>almacenar : estatica base
p−>mostrar : dinamica base
q−>almacenar : estatica derivada
q−>mostrar : estatica derivada
p−>almacenar : estatica base
p−>mostrar : dinamica derivada

Resumen :
Puntero a . . . Apuntando a . . . Tipo de metodo L i g a d u r a Se e l i g e
−−−−−−−−−−−−− −−−−−−−−−−−−−−− −−−−−−−−−−−−−−− −−−−−−−− −−−−−−−−
base base normal Estatica base
base base virtual Dinamica b a s e
base derivada normal Estatica base
base derivada virtual Dinamica d e r i v a d a ! !
derivada derivada normal Estatica derivada
derivada derivada virtual Estatica derivada
∗/

5. [005.txt] Se pretende escribir un programa para calcular las nóminas de una empresa en la que hay dos tipos
de empleados: comerciales y mecánicos. Todos ellos cobran un salario base, que en el caso de un mecánico se
incrementa en 6 euros por hora extra trabajada y en el de un comercial se incrementa con un porcentaje del
5 % sobre las ventas de cada mes. Si CalcularSueldo( ) calcula el salario mensual de cada empleado, para
calcular la nómina de los empleados de la empresa se puede utilizar una función SumarSueldos( ) que recibe
como argumento un vector de punteros a empleados apuntando a los diferentes comerciales y mecánicos de la
empresa y el número total de empleados, y calcula la suma total de los sueldos de los empleados.

Define la clase empleado cuyo constructor reciba como argumento el sueldo base. Define a partir de ella las
clases comercial y mecánico, que reciban además el porcentaje de ventas y las horas extra respectivamente.
Implementa la función SumarSueldos() de tal manera que utilice ligadura dinámica.

Página 5 de 10
Ligadura

Escribe un programa de ejemplo.

Solución:

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

using namespace s t d ;
c l a s s Empleado{
public :
Empleado ( f l o a t s u e l d o B a s e )
: sueldoBase ( sueldoBase ) {
}
v i r t u a l f l o a t c a l c u l a r S u e l d o ( ) =0;
protected :
float sueldoBase ;
};
c l a s s C o m e r c i a l : public Empleado{
public :
Comercial ( float sueldoBase , float ventasMensuales )
: Empleado ( s u e l d o B a s e ) , v e n t a s M e n s u a l e s ( v e n t a s M e n s u a l e s ) {
}
float calcularSueldo () {
return s u e l d o B a s e +( v e n t a s M e n s u a l e s ∗ 5 / 1 0 0 ) ;
}
private :
float ventasMensuales ;
};
c l a s s Mecanico : public Empleado{
public :
Mecanico ( f l o a t s u e l d o B a s e , f l o a t h o r a s E x t r a )
: Empleado ( s u e l d o B a s e ) , h o r a s E x t r a ( h o r a s E x t r a ) {
}
float calcularSueldo () {
return s u e l d o B a s e +( h o r a s E x t r a ∗ 6 ) ;
}
private :
float horasExtra ;
};

f l o a t sumarSueldos ( Empleado ∗∗ p l a n t i l l a , int numTrabajadores ) {

f l o a t r e t =0;
f or ( int n = 0 ; n< numTrabajadores ; n++){
r e t += p l a n t i l l a [ n]−> c a l c u l a r S u e l d o ( ) ;
}
return r e t ;
}

int main ( ) {
Empleado ∗ empresa [ 3 ] ;
empresa [ 0 ] = new C o m e r c i a l ( 1 0 0 0 , 1 0 0 0 0 ) ;
empresa [ 1 ] = new Mecanico ( 2 0 0 0 , 1 0 ) ;
empresa [ 2 ] = new C o m e r c i a l ( 8 0 0 , 1 0 0 0 0 0 0 ) ;
f l o a t t o t a l = sumarSueldos ( empresa , 3 ) ;
c o u t << ” T o t a l nomina : ”<< t o t a l <<e n d l ;
}

6. [006.txt] Suponiendo que se tiene implementada una clase Fecha, con un constructor que recibe tres argumen-
tos: dı́a, mes y año:

Página 6 de 10
Ligadura

Define la clase Persona, con una variable dni y otra fecha\_nacimiento. Implementa el constructor de la
clase y una función visualizar.
A partir de la clase Persona define las clases Alumno y Profesor. Define variables especı́ficas para cada
clase e implementa un constructor y una función visualizar para cada una.
Escribir un ejemplo de ligadura dinámica que haga uso de la función visualizar.

Solución:

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

using namespace s t d ;
c l a s s Fecha {
public :
Fecha ( int dia , int mes , int anno )
: d i a ( d i a ) , mes ( mes ) , anno ( anno ) {

}
int dia , mes , anno ;
};
ostream & operator << ( ostream & os , Fecha &f ) {
o s << f . d i a << ”/” << f . mes << ”/”<< f . anno ;
return o s ;
}
c l a s s Persona {
public :
long d n i ;
Fecha f e c h a n a c i m i e n t o ;
Persona ( long dni , int dia , int mes , int anno )
: f e c h a n a c i m i e n t o ( dia , mes , anno ) , d n i ( d n i ) {
}
v i r t u a l void v i s u a l i z a r ( ) {
c o u t << ” d n i : ” << d n i << e n d l ;
c o u t << ” f e c h a : ” << f e c h a n a c i m i e n t o << e n d l ;
}
};
c l a s s Alumno : public Persona {
public :
long e x p e d i e n t e ;
Alumno ( long e x p e d i e n t e , int dni , int dia , int mes , int anno )
: Persona ( dni , dia , mes , anno ) , e x p e d i e n t e ( e x p e d i e n t e ) {
}
void v i s u a l i z a r ( ) {
Persona : : v i s u a l i z a r ( ) ;
c o u t << ” e x p e d i e n t e : ” << e x p e d i e n t e << e n d l ;
}
};
c l a s s P r o f e s o r : public Persona {
public :
float sueldo ;
P r o f e s o r ( f l o a t s u e l d o , int dni , int dia , int mes , int anno )
: Persona ( dni , dia , mes , anno ) , s u e l d o ( s u e l d o ) {
}
void v i s u a l i z a r ( ) {
Persona : : v i s u a l i z a r ( ) ;
c o u t << ” s u e l d o : ” << s u e l d o << e n d l ;
}
};
int main ( void ) {

Página 7 de 10
Ligadura

Persona ∗ p ;
p = new Alumno ( 1 0 0 0 , 2 3 4 3 2 , 2 , 2 , 2 0 0 6 ) ;
p−>v i s u a l i z a r ( ) ;
p = new P r o f e s o r ( 9 8 8 4 3 , 6 5 4 3 , 3 0 , 1 2 , 1 9 9 9 ) ;
p−>v i s u a l i z a r ( ) ;
}

7. [007.txt] Para un programa de gestión de una Librerı́a se tienen las clases siguientes:
c l a s s Autor {
private :
s t r i n g nombre ;
public :
Autor ( const s t r i n g &n ) {nombre=n ; }
s t r i n g getNombre ( ) { return nombre ; }
};
class Publicacion {
private :
s t r i n g codigo ;
public :
P u b l i c a c i o n ( const s t r i n g &c ) { c o d i g o=c ; }
s t r i n g g e t C o d i g o ( ) { return c o d i g o ; }
v i r t u a l int c a l c u l a r E j e m p l a r e s ( ) =0;
};

Define una clase Libro que contenga un Autor y que herede a partir de la clase Publicacion. Añade también
a la clase una variable numEjemplares para almacenar el número de ejemplares de cada libro que existen
en la librerı́a. Implementa un constructor donde se le pasen (al menos) el número concreto de ejemplares
de ese libro y una función calcularEjemplares que devuelva el número de ejemplares de ese libro.
A partir de la clase Publicacion define una clase Revista con dos variables volumenes y numeros. Imple-
menta un constructor al que se le pasen (al menos) el número de volúmenes de los que consta la revista y
los números de cada volumen y una función calcularEjemplares que devuelva el numero de ejemplares de
esa revista (p.e. si volumenes es 4 y numeros 6 el total de ejemplares será 24).
Implementa una función calcularInventario( ) que reciba como argumento un vector de punteros a
publicación, apuntando a cada uno de los libros o revistas de la librerı́a y calcule utilizando ligadura
dinámica el total de ejemplares de la librerı́a.
Escribe un programa de prueba.

Solución:

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

using namespace s t d ;
c l a s s Autor {
private :
s t r i n g nombre ;
public :
Autor ( const s t r i n g &n ) {nombre=n ; }
s t r i n g getNombre ( ) { return nombre ; }
};
class Publicacion {
private :
s t r i n g codigo ;
public :
P u b l i c a c i o n ( const s t r i n g &c ) { c o d i g o=c ; }

Página 8 de 10
Ligadura

s t r i n g g e t C o d i g o ( ) { return c o d i g o ; }
v i r t u a l int c a l c u l a r E j e m p l a r e s ( ) =0;
};
c l a s s L i b r o : public P u b l i c a c i o n {
Autor a u t o r ;
int numEjemplares ;
public :
L i b r o ( s t r i n g c o d i g o , s t r i n g nombre , int n )
: P u b l i c a c i o n ( c o d i g o ) , a u t o r ( nombre ) , numEjemplares ( n ) {
}
int c a l c u l a r E j e m p l a r e s ( ) {
return numEjemplares ;
}
};
c l a s s R e v i s t a : public P u b l i c a c i o n {
int volumenes ;
int numEjemplares ;
public :
R e v i s t a ( s t r i n g c o d i g o , int n , int v )
: P u b l i c a c i o n ( c o d i g o ) , volumenes ( v ) , numEjemplares ( n ) {
}
int c a l c u l a r E j e m p l a r e s ( ) {
return numEjemplares ∗ volumenes ;
}
};
int c a l c u l a r I n v e n t a r i o ( P u b l i c a c i o n ∗ p u b l i c a c i o n e s [ ] , int n u m P u b l i c a c i o n e s ) {
int t o t a l = 0 ;
f or ( int n=0; n<n u m P u b l i c a c i o n e s ; n++){
t o t a l+=p u b l i c a c i o n e s [ n]−> c a l c u l a r E j e m p l a r e s ( ) ;
}
return t o t a l ;
}
int main ( ) {
Publicacion ∗ l i b r e r i a [ 3 ] ;
l i b r e r i a [ 0 ] = new L i b r o ( s t r i n g ( ” aaa ” ) , s t r i n g ( ” l a colmena ” ) , 2 ) ;
l i b r e r i a [ 1 ] = new R e v i s t a ( s t r i n g ( ”XXX” ) , 2 , 3 ) ;
l i b r e r i a [ 2 ] = new L i b r o ( s t r i n g ( ”bbb” ) , s t r i n g ( ” e l q u i j o t e ” ) , 8 ) ;
c o u t << c a l c u l a r I n v e n t a r i o ( l i b r e r i a , 3 ) ;
}

8. [008.txt] Crea una clase Empresario, con un id de tipo int y un método trabajar y agrega un constructor
parametrizado. Ahora crea dos tipos de Empresario:
Carpintero, que en el metodo trabajar heredado muestre su id y la frase ”Clavando puntas”
Electricista, que en el método heredado heredado muestre su id y la frase ”Pelando cables”
Crea un array de 2 punteros a Empresarios, y llénalo con las direcciones de un Empresario de cada tipo.
Recorre el array para hacer que todos trabajen.

Solución:

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

using namespace s t d ;

c l a s s Empresario {

Página 9 de 10
Ligadura

public :
Empresario ( int i d ) ;
int i d ;
v i r t u a l void t r a b a j a r ( ) =0;
};
Empresario : : Empresario ( int i d ) : i d ( i d ) {}

c l a s s C a r p i n t e r o : public Empresario {
public :
C a r p i n t e r o ( int i d ) ;
void t r a b a j a r ( ) ;
};
C a r p i n t e r o : : C a r p i n t e r o ( int i d ) : Empresario ( i d ) {}
void C a r p i n t e r o : : t r a b a j a r ( ) {
c o u t << i d << ” Clavando puntas ”<< e n d l ;
}

c l a s s E l e c t r i c i s t a : public Empresario {
public :
E l e c t r i c i s t a ( int i d ) ;
void t r a b a j a r ( ) ;
};
E l e c t r i c i s t a : : E l e c t r i c i s t a ( int i d ) : Empresario ( i d ) {}
void E l e c t r i c i s t a : : t r a b a j a r ( ) {
c o u t << i d << ” Pelando c a b l e s ”<< e n d l ;
}
int main ( ) {
Empresario ∗ empresa [ 2 ] ;
empresa [ 0 ] = new C a r p i n t e r o ( 1 ) ;
empresa [ 1 ] = new E l e c t r i c i s t a ( 2 ) ;
empresa [0]−> t r a b a j a r ( ) ;
empresa [1]−> t r a b a j a r ( ) ;
}

Página 10 de 10