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;
}
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;
}
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);
}
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() );
}
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;
}
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() );
}
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;
}
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();
}
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");
}
*
*/
}
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;
}
}
}
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() );
}
