Arquivos da Aula 6

Arquivo pilhaBasica.cpp
#include <iostream>
#define TAM 5
using namespace std;
void empilha(int p[], int &t, int v);
int desempilha(int p[], int &t, int &v);
void acessoTopo(int p[], int &t);
void situacaoPilha(int p[], int &t);
int main()
{
int op, val, topo= -1, pilha[TAM],resp;
do
{ system("cls");
system("color f0");
cout<<"\nPILHA( LIFO - Last In - First Out )\n\n";
cout<<"\n1- Inserir um valor na pilha";
cout<<"\n2- Remover um valor da pilha";
cout<<"\n3- Mostrar o elemento do topo da pilha";
cout<<"\n4- Mostrar situacao da pilha";
cout<<"\n5- Sai";
cout<<"\nOpcao: ";
cin>>op;
system("cls");
switch(op)
{ case 1: cout<<"Digite o valor a ser empilhado: ";
cin>>val;
empilha(pilha, topo, val);
break;
case 2: resp=desempilha(pilha,topo,val);
if(resp==0)
cout<<"\nATENCAO. Pilha Vazia\n";
else
cout<<"\nValor removido: "<<val;
break;
case 3: acessoTopo(pilha,topo);
break;
case 4: situacaoPilha(pilha,topo);
break;
case 5: cout<<"\nPrograma basico da PILHA\n";
break;
default: cout<<"\nOPCAO INVALIDA\n";
}
cout<<"\n\n";system("pause");
}while(op!=5);
}
/* Insere */
void empilha(int p[], int &t, int v)
1

{
if(t == TAM-1)
cout<<"\nATENCAO. Pilha Cheia\n";
else
{
t++; //atualiza o topo
p[t]=v; // pilha recebe valor
}
}
/* Remove */
int desempilha(int p[], int &t, int &v)
{
if(t == -1)
return 0;
else
{
v=p[t];//guarda o valor do topo
t--; //atualiza o topo
return 1;
}
}
/* Mostra o topo */
void acessoTopo(int p[], int &t)
{
if(t == -1)
cout<<"\nATENCAO. Pilha Vazia\n";
else
cout<<"\nElemento do Topo da PILHA: "<<p[t];
}
/* Mostra situacao da Pilha */
void situacaoPilha(int p[], int &t)
{
if(t == -1)
cout<<"\nATENCAO. Pilha Vazia\n";
else if (t == TAM - 1 )
cout<<"\nATENCAO. Pilha Cheia\n";
else
{ cout<<"\nTotal de elementos na pilha: "<<t+1<<"\n";
cout<<"\n\nEspaco disponivel na pilha: "<<TAM-(t+1)<<"\n"; }
}

Arquivo calculadoraReal.cpp
#include <iostream>
#include <cstdlib>
#define TAM 100
using namespace std;
void push(float p[], int &t, float v);
float pop(float p[], int &t);
int main()
{
int t = -1; //Inicializao
float a, b,p[TAM] ;
char s[10];
system("color f1");
cout<<"\n****************************************************";
cout<<"\n* Calculadora para quatro operacoes pos-fixa *";
cout<<"\n*
Digite numeros e operadores
*";
cout<<"\n*
Digite s para sair
*";
cout<<"\n****************************************************\n";
do
{
cout<<": ";
cin>>s;
switch(s[0])
{
case '+':
a = pop(p, t);
b = pop(p, t);
cout<<"\n"<< a+b<<"\n";
push(p, t,a+b);
break;
case '-':
a = pop(p, t);
b = pop(p, t);
cout<<"\n"<< b-a<<"\n";
push(p, t,b-a);
break;
case '*':
a = pop(p, t);
b = pop(p, t);
cout<<"\n"<< a*b<<"\n";
push(p, t,b*a);
break;
case '/':
a = pop(p, t);
b = pop(p, t);
if(a==0)
cout<<"\ndivisao por 0\n";
else
{
cout<<"\n"<< b/a<<"\n";
push(p, t,b/a);
}
3

break;
default: push(p,t, atof(s));
}
} while(s[0]!='s');
system("pause");
}
/* Insere o elemento na pilha */
void push(float p[], int &t, float v)
{
if(t==TAM-1)
cout<<"\nATENCAO. Pilha Cheia\n";
else
{
t++; //atualiza o topo
p[t]=v; // pilha recebe valor
}
}
/* Remove o elemento da pilha */
float pop(float p[], int &t)
{ float v;
if(t == -1)
{
cout<<"\nATENCAO. Pilha Vazia\n";
return 0;
}
else
{
v=p[t];//guarda o valor do topo
t--; //atualiza o topo
return v;
}
}
/*Este programa uma adaptao do cdigo do livro C Completo e Total
de Herbert Schildt pagina 538.Como as funes eram com ponteiros, fiz
as alteraes necessrias, mantendo as funes dos outros exemplos*/

Arquivo ConversorDecimalBinarioRepete.cpp
#include <iostream>
#define TAM 40
using namespace std;
void empilha(int p[], int &t, int v);
int desempilha(int p[], int &t, int &v);
int main()
{ float n;// para possibilitar a entrada de nmero maior do que o inteiro permite
int num, resto, pilha[TAM],sinal,topo=-1; //Inicializao da pilha atravs de topo=-1
system("color 2f");
cout<<"\n####################################################
######";
cout<<"\n###
###";
cout<<"\n### Converte Numero da base decimal para base binaria ###";
cout<<"\n###
###";
cout<<"\n####################################################
######\n";
cout<<"\nDigite numero positivo ate 2147483520. Qualquer outro, sai: ";
cin>>n;
if(n > 2147483520 || n <-2147483520)
exit(0);//Limita intervalo de inteiro no Dev-Cpp, embora seja maior, mas
else
num=(int)n;//converte real para inteiro
while(num>=0 )
{
do //inicio do trecho que empiha os restos que iro gerar o nmero binrio
{
resto= num%2;
empilha(pilha,topo, resto);
num/=2;
}while(num > 0);//fim do trecho de empilhamneto
cout<<"\nConvertido para binario: ";
sinal=desempilha(pilha, topo,resto);//inicio do trecho que desempilha todos
while(sinal == 1)//os restos que iro exibir o nmero binrio
{
cout<<resto;
sinal=desempilha(pilha, topo,resto);
}//Fim do trecho de desempilhamento
topo=-1;
cout<<"\n\nDigite numero positivo ate 2147483520. Qualquer outro, sai: ";
cin>>n; if(n > 2147483520 || n <-2147483520) exit(0);//Mximio permitido no Dev-Cpp
else num=(int)n;
}
cout<<"\n\n";
system("pause");
}
void empilha(int p[], int &t, int v)
{
if(t==TAM-1)//Este teste no necessrio porque j limitei a entrada
cout<<"\nATENCAO. Pilha Cheia\n";// Mantive para usar o mesmo trecho
else
{
t++; //atualiza o topo
p[t]=v; // pilha recebe valor
5

}
}
int desempilha(int p[], int &t, int &v)
{
if(t == -1)
return 0;
else
{
v=p[t];//guarda o valor do topo
t--; //atualiza o topo
return 1;
}
}