Plantillas

1. [001.txt] Crea una clase que se llame Pila, basada en una lista enlazada, que permita mantener una pila de
enteros. Haz métodos push y pop, que permitan agregar y borrar enteros.

Solución:
#include <i o s t r e a m >
using namespace s t d ;
c l a s s Nodo{
int v a l u e ;
Nodo∗ next ;
public :
Nodo ( int v a l u e ) ;
void s e t N e x t ( Nodo∗ next ) ;
Nodo ∗ getNext ( ) ;
int g e t V a l u e ( ) ;
void s e t V a l u e ( int v a l u e ) ;
};
Nodo : : Nodo ( int v a l u e )
: v a l u e ( v a l u e ) , next ( 0 ) {
}
Nodo ∗ Nodo : : getNext ( ) {
return next ;
}
void Nodo : : s e t N e x t ( Nodo∗ next ) {
this−>next = next ;
}
int Nodo : : g e t V a l u e ( ) {
return v a l u e ;
}
void Nodo : : s e t V a l u e ( int v a l u e ) {
this−>v a l u e=v a l u e ;
}
class Pila {
Nodo∗ s t a r t ;
public :
Pila () ;
Nodo ∗ g e t S t a r t ( ) ;
void push ( int n ) ;
int pop ( ) ;
};
Pila : : Pila ()
: start (0) {
}
Nodo ∗ P i l a : : g e t S t a r t ( ) {
return s t a r t ;
}
void P i l a : : push ( int n ) {
Nodo ∗ newNode = new Nodo ( n ) ;
newNode−>s e t N e x t ( s t a r t ) ;
s t a r t = newNode ;
}
int P i l a : : pop ( ) {
if ( start ){
int r e t = s t a r t −>g e t V a l u e ( ) ;
Nodo∗ tmp = s t a r t ;
s t a r t = s t a r t −>getNext ( ) ;
delete tmp ;
return r e t ;

Página 1 de 5
Plantillas

} else {
c o u t << ” Error , p i l a v a c i a ” << e n d l ;
return 0 ;
}
}
ostream & operator << ( ostream &out , P i l a &p i l a ) {
Nodo ∗ n = p i l a . g e t S t a r t ( ) ;
c o u t << ” P i l a : ” << e n d l ;
while ( n ) {
c o u t << n−>g e t V a l u e ( )<< e n d l ;
n = n−>getNext ( ) ;
}
c o u t << e n d l ;
}
int main ( ) {
P i l a p ; p . push ( 1 ) ; p . push ( 2 ) ; p . push ( 4 ) ; p . push ( 9 ) ;
c o u t << p ; p . pop ( ) ; c o u t << p ; p . pop ( ) ; c o u t << p ;
}

2. [002.txt] Conviérte la clase Pila en genérica Haz un programa de prueba que cree dos pilas, una de enteros y
otra de chars y prueba su funcionamiento.

Solución:

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

using namespace s t d ;
template <c l a s s T>
c l a s s Nodo{
T value ;
Nodo∗ next ;
public :
Nodo (T v a l u e ) ;
void s e t N e x t ( Nodo∗ next ) ;
Nodo ∗ getNext ( ) ;
T getValue ( ) ;
void s e t V a l u e (T v a l u e ) ;
};
template <c l a s s T>
Nodo<T> : : Nodo (T v a l u e )
: v a l u e ( v a l u e ) , next ( 0 ) {
}
template <c l a s s T>
Nodo<T> ∗ Nodo<T> : : getNext ( ) {
return next ;
}
template <c l a s s T>
void Nodo<T> : : s e t N e x t ( Nodo<T>∗ next ) {
this−>next = next ;
}
template <c l a s s T>
T Nodo<T> : : g e t V a l u e ( ) {
return v a l u e ;
}
template <c l a s s T>
void Nodo<T> : : s e t V a l u e (T v a l u e ) {

Página 2 de 5
Plantillas

this−>v a l u e=v a l u e ;
}
template <c l a s s T>
class Pila {
Nodo<T>∗ s t a r t ;
public :
Pila () ;
Nodo<T> ∗ g e t S t a r t ( ) ;
void push (T n ) ;
T pop ( ) ;
};
template <c l a s s T>
P i l a <T> : : P i l a ( ) {
start = 0;
}
template <c l a s s T>
Nodo<T> ∗ P i l a <T> : : g e t S t a r t ( ) {
return s t a r t ;
}
template <c l a s s T>
void P i l a <T> : : push (T n ) {
Nodo<T> ∗ newNode = new Nodo<T>(n ) ;
newNode−>s e t N e x t ( s t a r t ) ;
s t a r t = newNode ;
}
template <c l a s s T>
T P i l a <T> : : pop ( ) {
if ( start ){
T r e t = s t a r t −>g e t V a l u e ( ) ;
Nodo<T>∗ tmp = s t a r t ;
s t a r t = s t a r t −>getNext ( ) ;
delete tmp ;
return r e t ;
} else {
c o u t << ” Error , p i l a v a c i a ” << e n d l ;
return 0 ;
}
}
template <c l a s s T>
ostream & operator << ( ostream &out , P i l a <T> &p i l a ) {
Nodo<T> ∗ n = p i l a . g e t S t a r t ( ) ;
out << ” P i l a : ” << e n d l ;
while ( n ) {
out << n−>g e t V a l u e ( )<< e n d l ;
n = n−>getNext ( ) ;
}
out << e n d l ;
}
int main ( ) {
P i l a <int> p ;
p . push ( 1 ) ; p . push ( 2 ) ;
c o u t << p ; p . pop ( ) ; c o u t << p ; p . pop ( ) ; c o u t << p ; p . pop ( ) ;
P i l a <char> p1 ;
p1 . push ( ’ a ’ ) ; p1 . push ( ’ b ’ ) ;
c o u t << p1 ; p1 . pop ( ) ; c o u t << p1 ; p1 . pop ( ) ; c o u t << p1 ; p1 . pop ( ) ;
}

Página 3 de 5
Plantillas

3. [003.txt] Modificar la definición de la clase Tvector para hacerla genérica.

c l a s s Tvector
{
int ∗ Elementos ; // Puntero a l o s e l e m e n t o s d e l v e c t o r
int NumElementos ; // Numero de e l e m e n t o s d e l v e c t o r
public :
Tvector ( int Num) ;
int &operator [ ] ( int Num) ; // s o b r e c a r g a d e l o p e r a d o r [ ]
˜ Tvector ( ) ;
};

Añadir a la definición de la clase Tvector una función para contar cuantas veces aparece un determinado elemento
en el vector entre dos posiciones determinadas. Implementar dicha funció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 ;

template <typename T>

c l a s s TVector {
T∗ e l e m e n t o s ;
int numElementos ;
public :
TVector ( int num) ;
T& operator [ ] ( int n ) ;
int count ( T elem , int desde , int h a s t a ) ;
˜ TVector ( ) ;
};

template <typename T>

TVector<T> : : TVector ( int num) {
e l e m e n t o s = new T[ num ] ;
numElementos = num ;
}

template <typename T>

TVector<T> : : ˜ TVector ( ) {
delete [ ] e l e m e n t o s ;
}

template <typename T>

T& TVector<T> : : operator [ ] ( int n ) {
return e l e m e n t o s [ n ] ;
}

template <typename T>

int TVector<T> : : count (T elem , int desde , int h a s t a ) {
i f ( desde < 0) desde = 0 ;
i f ( h a s t a > numElementos ) h a s t a = numElementos ;
int t i m e s =0;
f or ( int n = d e s d e ; n< h a s t a ; n++){
i f ( e l e m e n t o s [ n ] == elem ) {
t i m e s ++;
}
}

Página 4 de 5
Plantillas

return t i m e s ;
}

4. [004.txt] 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 Matriz {
int n f i l a s ;
int ncolumnas ;
int ∗∗ e l e m e n t o s ;
public :
Matriz ( int , int ) ;
};
Matriz : : Matriz ( int f , int c )
: n f i l a s ( f ) , ncolumnas ( c ) {
e l e m e n t o s = new int ∗ [ n f i l a s ] ;
f or ( int 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 int [ ncolumnas ] ;
}
}
class Tablero {
Matriz m;
public :
T a b l e r o ( ) : m( 8 , 8 ) {

}
};

5. [005.txt] 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 {
int n f i l a s ;
int 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 , int ) ;
};
template <typename T>
M a t r i z G e n e r i c a <T> : : M a t r i z G e n e r i c a ( int f , int 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 ] ;
f or ( int 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