Exemple #1
0
bool llaves(const char cadena[], int n, const char caracterAbertura, const char caracterCierre) {
    
    Pila<int> colaAbiertos;
    
    bool completos = true;
    
    int i = 0;
    int j = n-1;
    
    while(i < n) {
        
        if(cadena[i] == caracterAbertura) {
            
            colaAbiertos.apila(cadena[i]);
            
        } else if (cadena[i] == caracterCierre) {
            
            try {
                colaAbiertos.desapila();
            } catch(EPilaVacia e) {
                cout << e.msg() << endl;
            }
        }
        i++;
    }

    if ( ! colaAbiertos.esVacia()) {
        completos = false;
    }
    
    return completos;
}
int main(int argc, char **argv) {
    const int TAM_BUFFER = 100;
    char buffer[TAM_BUFFER];
    Pila pila;
    bool primero = false;
    char valor;
    int i = 0;

    while (!cin.eof()) {
        cin >> valor;
        pila.push(valor);

        i = 0;
        primero = false;

        while (buffer[i] != '\0') {
            if ((buffer[i] >= '0') && (buffer[i] <= '9')) {
                cout << buffer[i];
                primero = true;
            } else if (primero == true) {
                cout << '\n';
                primero = false;
            }

            i++;
        }
    }

    return (0);
}
TEST( PilaCharTest, apilarUnUnicoElemento ) {

    Pila<char> pila;

    pila.apilar('D');

    ASSERT_FALSE( pila.estaVacia() );
}
Pila * invertirPila(Pila *ori)
{
	Pila *out = new Pila();
	while (!ori->isEmpty())
	{
		out->push(ori->pop());
	}
	return out;
}
Exemple #5
0
int main(int argc, char** argv) {
	Giornale G1(12.50, "Titolo1", false);
	Giornale G2(1.50, "Titolo2", true);
	Giornale G3(2.00, "Titolo3", false);
	Rivista R4(22.70, "Titolo4", false, "Editore4", "Periodo4");
	Rivista R5(11.50, "Titolo5", true, "Editore5", "Periodo5");
	Rivista R6(6.00, "Titolo6", false,  "Editore6", "Periodo6");
	Quotidiano Q7(6.35, "Titolo7", false, "Direttore7", true);
	Quotidiano Q8(9.99, "Titolo8", true, "Direttore8", false);
	Quotidiano Q9(5, "Titolo9", false, "Direttore9", true);
	
	cout<<"Polimorfismo:\n";
	Giornale * vett[9];
	vett[0] = &G1;
	vett[1] = &G2;
	vett[2] = &G3;
	vett[3] = &R4;
	vett[4] = &R5;
	vett[5] = &R6;
	vett[6] = &Q7;
	vett[7] = &Q8;
	vett[8] = &Q9;
	
	for(int i=0; i<9; i++) {
		cout << *vett[i] << "\n\n";
	}
	
	cout<<"\n\nPila:\n";
	Pila P;
	for(int i=0; i<9; i++) {
		P.push(vett[i]);
	}
	cout<<P;
	
	ofstream file;
	file.open("./test.txt", ios::out);
	if(!file) {
		cout<<"Errore apertura file.";
	} else {
		file << P;
	}
	file.close();
	
	Rivista R10(1.00, "Titolo10", false,  "Editore10", "Periodo10");
	Quotidiano Q11(1.35, "Titolo11", false, "Direttore11", true);
	
	P.push(&R10);
	
	cout<<"\n\nEccezione:\n";
	try {
		P.push(&Q11);
	} catch(SpaceOverflow e) {
		cout<<e.errorLog();
	}
	return 0;
}
TEST( PilaCharTest, apilarMultiplesElementos ) {

    Pila<char> pila;

    pila.apilar('O');
    pila.apilar('P');
    pila.apilar('Q');

    ASSERT_FALSE( pila.estaVacia() );
}
TEST( PilaCharTest, desapilarElUnicoElementoApilado ) {

    Pila<char> pila;

    pila.apilar('S');
    const char elemento = pila.desapilar();

    ASSERT_TRUE( pila.estaVacia());
    ASSERT_EQ( 'S', elemento);
}
TEST( PilaCharTest, obtenerTope ) {

    Pila<char> pila;

    pila.apilar('X');
    pila.apilar('Y');
    pila.apilar('Z');

    ASSERT_FALSE( pila.estaVacia() );
    ASSERT_EQ( 'Z', pila.obtenerTope() );
}
Cola * invertirCola(Cola *ori)
{
	Pila *inc = new Pila();
	while (!ori->isEmpty())
	{
		inc->push(ori->dequeue());
	}
	Cola *out = new Cola();
	while (!inc->isEmpty())
	{
		out->enqueue(inc->pop());
	}
	return out;
}
int main() {

    Pila<int> pila;

    pila.apilar(3);
    pila.apilar(5);
    pila.apilar(1);
    pila.apilar(6);

    while (! pila.estaVacia()) {

        cout << pila.desapilar() << endl;
    }

    return 0;
}
Exemple #11
0
int main(){

  Pila<int> p;
  cout << "Entra pila naturals (acabada per -1): " << endl;
  llegir_pila_int(p,-1);
  cout << "Entra número a buscar: " << endl;
  int x = readint();
  bool b;
    b = p.cerca_pila(x);

  if (b) cout << "esta" << endl;
  else cout << "no esta" << endl;
  cout << "pila p, despues de buscar (notad que no se destruye en ningun caso, aunque no se ha usado copia)" << endl;
  escriure_pila_int(p);

}
Exemple #12
0
int viaDeEntrada(Pila<int> &entrada, Lista<int> &secuenciaSalida) {
    
    int numeroVagones = 0;
    
    //cout << "Introduzce el número de bagones: ";
    
    cin >> numeroVagones;
    
    if ( numeroVagones != 0) {
        //cout << endl << "Escriba la secuencia resultante de los bagones: " << endl;
        
        for (int n = 0; n < numeroVagones; n++) {
            
            //if( n > 0 ) cout << "Queda/n " << numeroVagones-n << " bagón/es." << endl;
            
            int a;
            
            cin >> a;
            
            secuenciaSalida.ponDr(a);
        }
        
        for (int j = numeroVagones; j > 0 ; j--) {
            entrada.apila(j);
        }
    }
    
    return numeroVagones;
}
TEST( PilaCharTest, desapilaTresElementosCumplindoFIFO ) {

    Pila<char> pila;

    pila.apilar('A');
    pila.apilar('B');
    pila.apilar('C');

    ASSERT_FALSE( pila.estaVacia() );
    ASSERT_EQ( 'C', pila.desapilar() );
    ASSERT_FALSE( pila.estaVacia() );
    ASSERT_EQ( 'B', pila.desapilar() );
    ASSERT_FALSE( pila.estaVacia() );
    ASSERT_EQ( 'A', pila.desapilar() );
    ASSERT_TRUE( pila.estaVacia() );
}
Exemple #14
0
int main() {
	Pila<float> pila;
	Cola<float> cola;

	cout << " -> Pila" << endl;
	for (int i = 0; i < 10; i++)
		pila.insertar(i + 0.01);

	while (!pila.estaVacia())
		cout << "\t" << pila.sacar() << endl;

	cout << endl << " -> Cola " << endl;
	for (int i = 0; i < 10; i++)
		cola.insertar(i + 0.03);

	while (!cola.estaVacia())
		cout << "\t" << cola.sacar() << endl;

	return 0;
}
int main() {
	Pila<char> p;
	char c = 'a';
	while (c != '*'){ // Mientras no introduzca asterisco para terminar
		cout << "> "; // Mostramos prompt
		cin.get(c); // Leemos el primer caracter
		if (c != '*'){ // Si no es el asterisco
			while (c != '\n'){ // Mientras no haya fin de linea
				p.apila (c); // Apilamos el caracter
				cin.get(c); // Leemos el siguiente
			}
			while (!p.esVacia()){ // Mientras no se quede vacía la pila
				cout << p.cima(); // Escribimos la cima de la pila
				p.desapila(); // Desapilamos
			}
		}
		cout << endl; // Añadimos un salto de linea final
	}
	
	return 0;
}
Exemple #16
0
int main() {
	int wagons = -1, expected[10000];
	int i;

	while (wagons != 0) {
		cin >> wagons;

		for (i = 0; i < wagons; i++) {
				cin >> expected[i];
			}

			int currentWagon = 1;
			int expectedIndex = 0;
			Pila<int> station;
			while (currentWagon <= wagons) {
				station.apila(currentWagon);
				while (!station.esVacia()
						&& station.cima() == expected[expectedIndex] &&
						expectedIndex < wagons) {
					station.desapila();
					expectedIndex++;
				}
				currentWagon++;
			}

			if (station.esVacia())
				cout << "POSIBLE" << endl;
			else
				cout << "IMPOSIBLE" << endl;
		}

	return 0;
}
TEST( PilaCharTest, obtenerTopeNoModificaLaPila ) {

    Pila<char> pila;

    pila.apilar('X');

    ASSERT_FALSE( pila.estaVacia() );
    ASSERT_EQ( 'X', pila.obtenerTope() );
    ASSERT_EQ( 'X', pila.obtenerTope() );
    ASSERT_EQ( 'X', pila.obtenerTope() );

    ASSERT_EQ( 'X', pila.desapilar() );
    ASSERT_TRUE( pila.estaVacia() );
}
Exemple #18
0
int main(){

Pila pila;
pila.apilar( 5 );
pila.apilar( 6 );
pila.apilar( 7 );
pila.apilar( 8 );
pila.apilar( 9 );
pila.apilar( 10 );

while(  pila.esVacia() == 0 ){
   printf(" %d\n", pila.desapilar() );
}



   return 0;
}
int main()
{
  Pila *x = new Pila();
  x->push(12);
  x->push(13);
  x->push(14);
  
  cout<<"Pila original "<<endl;
  x->print();
  cout<<endl;
  
  Pila *y = new Pila();
  y = invertirPila(x);
  cout<<"Pila invertida "<<endl;
  y->print();

  cout<<"\n-------------------------"<<endl<<endl;

  Cola *q = new Cola();
  q->enqueue(9);
  q->enqueue(8);
  q->enqueue(7);
  q->enqueue(6);
  q->enqueue(5);
  q->enqueue(4);

  cout<<"Cola original "<<endl;
  q->print();
  cout<<endl;

  Cola *q2 = new Cola();
  q2 = invertirCola(q); 

  cout<<"Cola invertida "<<endl;
  q2->print();
  cout<<endl;
 
  int loop;
  cin >> loop;
  return 0;
}
Exemple #20
0
int main()
{
	Pila<int> pila;
	Pila<int> pila2;

	pila.Apilar(1);
	pila.Apilar(2);
	pila.Apilar(3);
	pila.Apilar(4);
	pila.Apilar(5);
	pila.Apilar(6);

	pila2.Apilar(7);
	pila2.Apilar(8);

	//Invertirmos la pila
	//pila.ConcatenarPila(pila2);

	//pila.ImprimirPila();
	//pila.ImprimirPila();

	pila.InvertirPila();
	pila.ImprimirPila();
}
Exemple #21
0
void hangarDeVagones(const int &numeroVagones, Pila<int> &entrada, Lista<int> &secuenciaSalida) {
    
    Pila<int> hangar;
    
    bool resultado = true;
    
    while( resultado && (! secuenciaSalida.esVacia() || ! hangar.esVacia()) ) {
        
        // Si el elemento de la cima es igual que el primer elemento
        // de la secuencia resultante lo sacamos de la pila.
        if (hangar.esVacia() || (! entrada.esVacia() && hangar.cima() < secuenciaSalida.primero()) ) {
            hangar.apila( entrada.cima() );
            entrada.desapila();
        }
        else if  (hangar.cima() == secuenciaSalida.primero() ) {
            
            hangar.desapila();
            secuenciaSalida.resto();
        }
        else if (hangar.cima() > secuenciaSalida.primero()) {
            resultado = false;
        }
    }
    
    if( resultado ) cout << "POSIBLE" << endl;
    else cout << "IMPOSIBLE" << endl;
}
int main() {

// este codigo es como usted comento que iba a revisar nuestro proyecto


	//inicio proceso cola
	cout<<"\n\n\n<<<Proceso de Cola>>>"<<endl;
	Cola cl;

	cl.Listavaciacola(); // indica si la lista esta vacia o contiene datos
	cl.tamaniocola();  //indica el tamanio de la lista

	cl.Pushcola("jo"); 	//prueba que no permite mas o menos de 1 caracter en la cola
	cl.Pushcola("j");
	cl.Pushcola("o");
	cl.Pushcola("s");
	cl.Pushcola("e");	 //ingreso de caracteres al programa con la funcion push

	cl.tamaniocola();  //indica el tamanio de la lista
	cl.Listavaciacola();  // indica si la lista esta vacia o contiene datos

	cl.Imprimircola();	 //imprimir todos los nodos existentes hasta el momento
	cl.Topcola(); 		//imprimir el caracter que se encuentra en top en este momento
	cl.Popcola(); 		//eliminar el caracter que se encuentra en top en este momento
	cl.Imprimircola();
	cl.tamaniocola();  //indica el tamanio de la lista
	cl.Topcola();
	cl.Popcola();
	system("PAUSE");
	//fin proceso cola

	//inicio proceso pila
	cout<<"\n\n\n<<<Proceso de Pila>>>"<<endl;
	Pila pl;
	pl.Listavaciapila(); // indica si la lista esta vacia o contiene datos
	pl.tamaniopila();  //indica el tamanio de la lista

	pl.Pushpila("j");
	pl.Pushpila("o");
	pl.Pushpila("s");
	pl.Pushpila("e"); 	//ingreso de caracteres al programa con la funcion push
	pl.Pushpila("jo"); 	//prueba que no permite mas o menos de 1 caracter en la pila

	pl.Listavaciapila(); // indica si la lista esta vacia o contiene datos
	pl.tamaniopila();  //indica el tamanio de la lista

	pl.Imprimirpila();	//imprimir todos los nodos existentes hasta el momento
	pl.tamaniopila();  //indica el tamanio de la lista
	pl.Toppila();		//imprimir el caracter que se encuentra en top en este momento
	pl.Poppila();		//eliminar el caracter que se encuentra en top en este momento
	pl.Imprimirpila();
	pl.tamaniopila();  //indica el tamanio de la lista
	pl.Toppila();
	pl.Poppila();
	system("PAUSE");
	//fin proceso pila

	/*menu para ejecutar funciones

	string caracter;
	Cola cl;
	Pila pl;
	int opcion;
	while(opcion!=13)
	{
		cout<<"\n\n\n<<<Proceso de pilas y colas>>>"<<endl;
		cout<<"opciones para cola: "<<endl;
		cout<<"1. push. "<<endl;
		cout<<"2. pop. "<<endl;
		cout<<"3. top. "<<endl;
		cout<<"4. imprimir. "<<endl;
		cout<<"5. tamaño de lista. "<<endl;
		cout<<"6. verificar si hay datos en lista.\n"<<endl;
		cout<<"opciones para pila: "<<endl;
		cout<<"7. push. "<<endl;
		cout<<"8. pop. "<<endl;
		cout<<"9. top. "<<endl;
		cout<<"10. imprimir. "<<endl;
		cout<<"11. tamaño de lista. "<<endl;
		cout<<"12. verificar si hay datos en lista.\n\n"<<endl;
		cout<<"13. salir.\n\n"<<endl;
		cout<<"ingrese opcion que desea realizar: "<<endl;
		cin>>opcion;

		switch(opcion)
		{
		case 1:
			cout<<"ingrese caracter que desea ingresar: "<<endl;
			cin>>caracter;
			cl.Pushcola(caracter);
			break;
		case 2:
			cl.Popcola();
			break;
		case 3:
			cl.Topcola();
			break;
		case 4:
			cl.Imprimircola();
			break;
		case 5:
			cl.tamaniocola();
			break;
		case 6:
			cl.Listavaciacola();
			break;
		case 7:
			cout<<"ingrese caracter que desea ingresar: "<<endl;
			cin>>caracter;
			pl.Pushpila(caracter);
			break;
		case 8:
			pl.Poppila();
			break;
		case 9:
			pl.Toppila();
			break;
		case 10:
			pl.Imprimirpila();
			break;
		case 11:
			pl.tamaniopila();
			break;
		case 12:
			pl.Listavaciapila();
			break;
		case 13:
			cout<<"\n HASTA LA PROXIMA"<<endl;
			break;
		default:
			cout<<"esta opcion no esta disponible"<<endl;
			cout<<"por favor, ingrese una opcion entre 1 y 12"<<endl;

	}
	system("PAUSE");
	}
	*
	 */

}
Exemple #23
0
string& Evaluador::aPosfija(const string& expInfija) {

    int posP;
    Pila operadores;
    string caracTemp;
    string h = expInfija;
    int pos = 0;
    string res = "";
    string temp = "";
    posP = h.find_first_of("p");

    //recorrer la string 
    h = h + ")";
    operadores.push("(");
    while (!operadores.empty()) {
        caracTemp = h[pos];

        //caso que sea un parentesis izquierdo
        if (caracTemp == "(") {
            operadores.push(caracTemp);
            pos++;
        }
            //caso que sea un operador como *,+,-
        else if (caracTemp == "*" || caracTemp == "+" || caracTemp == "-") {
            while (prioridades(operadores.top()) >= prioridades(caracTemp)) { // puede existir un error
                res = res + operadores.top();
                operadores.pop();
            }
            operadores.push(caracTemp);
            pos++;
        }
            //caso de parentesis derecho
        else if (caracTemp == ")") {
            temp = operadores.top();
            while (temp != "(") {
                res = res + temp;
                operadores.pop();
                temp = operadores.top();
            }
            operadores.pop();
            pos++;
        }
            //caso que sea un p#
        else {


            if (caracTemp == "p" && pos != posP) {
                res = res + ",";
            }
            res = res + caracTemp;
            pos++;
        }
    }
    *posfija = res;
    return *posfija;
}
TEST( PilaCharTest, obtenerTopeConLaPilaVaciaLanzaExcepcion ) {

    Pila<char> pila;

    ASSERT_THROW(pila.obtenerTope(), std::string) << "Pila vacía";
}
void doubleThresholding_c (
	unsigned char *src,
	int cantFilas,
	int cantColumnas,
	int src_row_size
) {
	int i;
	int j;
	Pila laPila;
	int abc;
	int ord;
	unsigned char *pos;
	

	vector<bool> aux(cantColumnas, true);
	vector< vector<bool> > porRevisar(cantFilas, aux);
	
	for(j = 0; j < cantColumnas; ++j){
		porRevisar[0][j] = false; // Primer fila
		porRevisar[cantFilas-1][j] = false; // Última fila
	}
	for(i = 1; i < cantFilas-1; ++i){
		porRevisar[i][0] = false; // Primer columna
		porRevisar[i][cantColumnas-1] = false; // Última columna
	}

	/// Operación con los píxeles
	for(i = 1 ; i < cantFilas-1 ; i++){
		for(j = 1 ; j < cantColumnas-1 ; j++){
			pos = src + i*src_row_size + j;									/// pos guarda la posición en la que uno está iterando
			if ( porRevisar[i][j] && *pos == 0 ) porRevisar[i][j] = false; /// Si no fue revisado y es nulo lo marca como revisado
			else if( porRevisar[i][j] && *pos == 200 ){ 	/// Si aún no fue revisado y es píxel fuerte
				/// Chequea todos los píxeles vecinos, si son débiles los pone en la pila para procesarlos luego
				/*	1 2 3 */
				/*	4 X 6 */
				/*	7 8 9 */
				
				if( *(pos - src_row_size - 1) 	== 100 ) laPila.Apilar(i-1, j-1);	/// Apila el pixel de la pos 1
				if( *(pos - src_row_size) 		== 100 ) laPila.Apilar(i-1, j);		/// Apila el pixel de la pos 2
				if( *(pos - src_row_size + 1) 	== 100 ) laPila.Apilar(i-1, j+1);	/// Apila el pixel de la pos 3
				if( *(pos - 1)					== 100 ) laPila.Apilar(i, j-1);		/// Apila el pixel de la pos 4
				if( *(pos + 1)					== 100 ) laPila.Apilar(i, j+1);		/// Apila el pixel de la pos 6
				if( *(pos + src_row_size - 1)	== 100 ) laPila.Apilar(i+1, j-1);	/// Apila el pixel de la pos 7
				if( *(pos + src_row_size)		== 100 ) laPila.Apilar(i+1, j);		/// Apila el pixel de la pos 8
				if( *(pos + src_row_size + 1)	== 100 ) laPila.Apilar(i+1, j+1);	/// Apila el pixel de la pos 9
				
				porRevisar[i][j] = false;										/// Al fuerte lo marca como revisado
				
				while( !laPila.EsVacia() ){		/// Mientras la pila no sea vacía opera todos los puntos
					abc = laPila.AbcisaTope();
					ord = laPila.OrdenadaTope();
					pos = src + abc*src_row_size + ord;
					laPila.SacarTope();											/// Saca al par ordenado ya operado

					if(porRevisar[abc][ord]){
						
						*pos = 200;					/// Pinta fuerte al píxel	
			
						/// Revisa los vecinos y todos los débiles los agrega a la pila
						if( *(pos - src_row_size - 1) 	== 100 ) laPila.Apilar(abc-1, ord-1);
						if( *(pos - src_row_size) 		== 100 ) laPila.Apilar(abc-1, ord);
						if( *(pos - src_row_size + 1) 	== 100 ) laPila.Apilar(abc-1, ord+1);
						if( *(pos - 1)					== 100 ) laPila.Apilar(abc, ord-1);
						if( *(pos + 1)					== 100 ) laPila.Apilar(abc, ord+1);
						if( *(pos + src_row_size - 1)	== 100 ) laPila.Apilar(abc+1, ord-1);
						if( *(pos + src_row_size)		== 100 ) laPila.Apilar(abc+1, ord);
						if( *(pos + src_row_size + 1)	== 100 ) laPila.Apilar(abc+1, ord+1);
						
						porRevisar[abc][ord] = false;							/// Lo marca como revisado
					}
				}
			}
		}
	}
	
	
	/// Por último, anula todos los débiles que sobrevivieron
	for(i = 1 ; i < cantFilas-1 ; i++){
		for(j = 1 ; j < cantColumnas-1 ; j++){
			if( *(src + i*src_row_size + j) == 100 ) *(src + i*src_row_size + j) = 0;
		}
	}
}
Exemple #26
0
int main(int argc, char **argv) {

	srand(time(NULL));
	string s[30] = { "Diego", "Maria", "Juan", "Andres", "Pedro", "Luis",
		"Juana", "Siria", "Roberto", "Siria", "Sebastian", "Ricardo",
		"Aria", "Andrey", "Chris", "Jose", "Ana", "Tyler", "Alberto",
		"Carolina", "Catalina", "Leonardo", "Walter", "Helen", "Silvia",
		"Monse", "Camila", "Carlos", "Aracely", "Mario" };

	Pila p;
	
	for (int w = 0; w < 10; ++w) {

		Persona* p1 = new Persona(rand() % 1000, s[rand() % 30], rand() % 100);
		ElementoPersona *p11 = new ElementoPersona(p1);
		p.push(p11);

	}

	cout << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<" << endl;
	cout << endl;
	cout << "Pila de personas" << endl;
	cout << endl;
	cout << p << endl;
	cout << "--------------------------------------------------------" << endl;
	cout << endl;
	cout << "Haciendo PEEK" << endl;
	cout << endl;
	p.peek();
	cout << "--------------------------------------------------------" << endl;
	cout << endl;
	cout << "Haciedno POP" << endl;
	cout << endl;
	p.pop();
	cout << "--------------------------------------------------------" << endl;
	cout << endl;
	cout << "Imprimiendo Pila despues del POP" << endl;
	cout << endl;
	cout << p << endl;

	Pila p2;

	for (int h = 0; h < 10; ++h) {

		ElementoInt *p22 = new ElementoInt(rand() % 1000);
		p2.push(p22);

	}

	cout << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<" << endl;
	cout << endl;
	cout << "Pila de Enteros" << endl;
	cout << endl;
	cout << p2 << endl;
	cout << "--------------------------------------------------------" << endl;
	cout << endl;
	cout << "Haciendo PEEK" << endl;
	cout << endl;
	p2.peek();
	cout << "--------------------------------------------------------" << endl;
	cout << endl;
	cout << "Haciedno POP" << endl;
	cout << endl;
	p2.pop();
	cout << "--------------------------------------------------------" << endl;
	cout << endl;
	cout << "Imprimiendo Pila despues del POP" << endl;
	cout << endl;
	cout << p2 << endl;

	Pila p3;

	for (int g = 0; g < 10; ++g) {

		ElementoDouble *p33 = new ElementoDouble(rand() % 1000);
		p3.push(p33);

	}

	cout << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<" << endl;
	cout << endl;
	cout << "Pila de Doubles" << endl;
	cout << endl;
	cout << p3 << endl;
	cout << "--------------------------------------------------------" << endl;
	cout << endl;
	cout << "Haciendo PEEK" << endl;
	cout << endl;
	p3.peek();
	cout << "--------------------------------------------------------" << endl;
	cout << endl;
	cout << "Haciedno POP" << endl;
	cout << endl;
	p3.pop();
	cout << "--------------------------------------------------------" << endl;
	cout << endl;
	cout << "Imprimiendo Pila despues del POP" << endl;
	cout << endl;
	cout << p3 << endl;


	system("pause");
	return 0;

}
TEST( PilaCharTest, desapilarConLaPilaVaciaLanzaExcepcion ) {

    Pila<char> pila;

    ASSERT_THROW(pila.desapilar(), std::string) << "Pila vacía";
}
int main(int argc, char *argv[])
{
  Immagine I1("ME", "800x120"); 
  Immagine I2("ME", "600x120");	
  Fotografia F1("ME", "200x120", 1,"Monti",false);
  Fotografia F2("ME", "600x120", 2,"Mare",false);
  Fotografia F3("ME", "200x1800", 3,"Laura",false);
  Fotografia F4("ME", "100x1800", 4,"Cielo stellato",false);
  Fotografia F;
 // esempio di polimorfismo
 //*************************************************
  Immagine * vet[5];
  vet[0]=&I1;
  vet[1]=&F1;
  vet[2]=&F2;
  vet[3]=&I2;
  vet[4]=&F3;
  cout << "chiamata alla funzione virtuale (print):" << endl; 
  for(int i=0; i<5; i++){
	vet[i]->print();       //binding dinamico
    cout << "\n ";
  }
  cout << "\n ";
  system("PAUSE");  
//*************************************************
 
// test della pila
//**************************************************  
  Pila P;
  
// test funzione push
  cout << "inserimento:" << endl; 
  if(P.push(F1)) cout << "inserimento riuscito"<< endl;
  else cout << "Pila piena"<< endl;
  if(P.push(F2)) cout << "inserimento riuscito"<< endl;
  else cout << "Pila piena"<< endl;
  if(P.push(F3)) cout << "inserimento riuscito"<< endl;
  else cout << "Pila piena"<< endl;
  if(P.push(F4)) cout << "inserimento riuscito"<< endl;
  else cout << "Pila piena"<< endl;
  
 // test funzioni visualizza, top e empty
  cout << "contenuto della pila:" << endl;
  if(!P.empty()) P.visualizza();
  else cout << "Pila vuota!"<< endl;
  
  if(!P.empty())  { 
    P.top(F);
    cout << "elemento di testa:" << F.getID() << ": " << F.getS() << endl;
    }    
   else cout << "Pila vuota!"<< endl;
   
 system("PAUSE");   
 
 // test funzioni sposta, ricerca, swap. Gestione dell'eccezione.   
  
  cout << "sposto in testa l'elemento di chiave 1:" << endl; 
  try{
  P.sposta(1);
  } 
  catch (const bad_event & e) {
   cout << e.what() << endl;
  } 
  cout <<"provoco il lancio dell'eccezione:" << endl;
  try{
  P.sposta(999);
  } 
  catch (const bad_event & e) {
   cout << e.what() << endl;
  } 
  
  cout << "contenuto della pila:" << endl;
  if(!P.empty()) P.visualizza();
  else cout << "Pila vuota!"<< endl;
  
 system("PAUSE");  
 
   // test funzione pop
  cout << "eliminazione:" << endl; 
  if(P.pop(F)) cout << "eliminazione riuscita"<< endl;
  else cout << "Pila vuota"<< endl;
  cout << "contenuto della pila:" << endl;
  if(!P.empty()) P.visualizza();
  else cout << "Pila vuota!"<< endl;
  
 system("PAUSE");  
 
  // test STAMPA su file
  cout << "stampo il contenuto della pila su file di testo." << endl;
  ofstream myfile;
  char nomefile[30];
  
  cout << "inserire il nome del file: ";
  cin.getline(nomefile,30);
  myfile.open(nomefile, ios::out);
  if(!myfile) cout << "operazione non riuscita!!!!" << endl;
  else {
//	P.stampa(myfile);
    myfile << P;
	myfile.close();	
  }
  
 system("PAUSE"); 
  
 // test LETTURA da  file
  Pila mypila2;
  ifstream myfile2;
  char nomefile2[30];
  
  cout << "inserire il nome del file: ";
  cin.getline(nomefile2,30);
  myfile2.open(nomefile2, ios::in);
  if(!myfile2) cout << "operazione non riuscita!!!!" << endl;
  else {
    myfile2>>mypila2;
	myfile2.close();	
  }
  cout << "stampo il contenuto della pila letta da file di testo." << endl;
  cout << mypila2 << endl;
  
   system("PAUSE"); 
  
  cout << "svuoto la pila." << endl;
  
  if(P.pop(F)) cout << "eliminazione riuscita"<< endl;
  else cout << "Pila vuota"<< endl;
  
  if(P.pop(F)) cout << "eliminazione riuscita"<< endl;
  else cout << "Pila vuota"<< endl;
  
  if(P.pop(F)) cout << "eliminazione riuscita"<< endl;
  else cout << "Pila vuota"<< endl;
  
   if(P.pop(F)) cout << "eliminazione riuscita"<< endl;
  else cout << "Pila vuota"<< endl;
  
  system("PAUSE");	
  return 0;
}
TEST( PilaCharTest, crear ) {

    Pila<char> pila;

    ASSERT_TRUE( pila.estaVacia() );
}