ED06_DOC

Prévia do material em texto

1 
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) 
 
2 
{ 
 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"; } 
} 
 
3 
 
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; //Inicialização 
 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); 
 } 
 
4 
 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 adaptação do código do livro C Completo e Total 
de Herbert Schildt pagina 538.Como as funções eram com ponteiros, fiz 
as alterações necessárias, mantendo as funções dos outros exemplos*/ 
 
5 
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 número maior do que o inteiro permite 
 int num, resto, pilha[TAM],sinal,topo=-1; //Inicialização da pilha através 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 irão gerar o número binário 
 { 
 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 irão exibir o número binário 
 { 
 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);//Máximio 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 não é necessário 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 
 
6 
 } 
} 
 
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; 
 } 
}