ATPS

ESTRUTURA
DE
DADOS

NOMES: Fernando Csar Scial Arzenares

RAs: 5876159859

dipo Cordeiro Souza

3703611130

Vander Barroso Lopes

1929858184

Caio Csar Costa Bonadies

4236821927

Bagagem.c

#include <sys/time.h>
#include <stdlib.h>
#include<string.h>
#include<stdio.h>
#include "Bagagem.h"
void flush_inB(){
int ch;
while( (ch = fgetc(stdin)) != EOF && ch != '\n' ){}
}
// -------------------------------------------void imprimeData(Date1 d){
printf(" %d/",d.dia);
printf("%d/",d.mes);
printf("%d ",d.ano);
}
Date1 coletaData(){
Date1 temp;
int verifica =0;
while(verifica == 0){
printf("Dia: ");
scanf("%d",&temp.dia);
if(temp.dia >= 0 && temp.dia <= 31){
verifica = 1;
}
}
verifica = 0;
while(verifica == 0){
printf("Mes: ");

scanf("%d",&temp.mes);
if(temp.mes >= 0 && temp.mes <= 12){
verifica = 1;
}
}
verifica = 0;
while(verifica == 0){
printf("Ano: ");
scanf("%d",&temp.ano);
if(temp.ano >= 0){
verifica = 1;
}
}
return temp;
}
/*imprime a hora que foi passada como parametro*/
void imprimeTimeB(Time2 t){
printf(" %d:",t.hora);
printf("%d:",t.minuto);
printf("%d ",t.segundo);
}
/*Coleta a hora digitada pelo user*/
Time2 coletaTime(){
Time2 t;
int verifica = 0;
while(verifica == 0){
printf("\n Hora: ");
scanf("%d", &t.hora);
if(t.hora >= 0 && t.hora <= 23){
verifica = 1;

}
}
verifica = 0;
while(verifica == 0){
printf("Minuto: ");
scanf("%d", &t.minuto);
if(t.minuto >= 0 && t.minuto <= 59){
verifica = 1;
}
}
verifica = 0;
while(verifica == 0){
printf("Segundo: ");
scanf("%d", &t.segundo);
if(t.segundo >= 0 && t.segundo <= 59){
verifica = 1;
}
}
return t;
}
//--------------------------------------// -------------------------------------void imprimeBagagem(Bagagem tx){
printf("\nBagagem: %d\n",tx.codBagagem);
printf("Numero da passagem: %d\n",tx.numPassagem);
printf("Numero do Voo %d\n",tx.numVoo);
printf("Data de Embarque: ");imprimeData(tx.dataEmbarque);
printf("\nHorario de Saida: ");imprimeTimeB(tx.horarioEmbarque);
printf("\nPortao de embarque: %s", tx.portaoEmbarque);
}

void imprimeBagagemCab(Bagagem tx){

printf("Bagagem: %d\n",tx.codBagagem);
}
void coletaDadosBagagem(Bagagem *tx){
printf("Digite o codigo da Bagagem: ");
scanf("%d", &tx->codBagagem);
printf("Digite o numero da passagem: ");
scanf("%d", &tx->numPassagem);
printf("Digite o numero do voo: ");
scanf("%d", &tx->numVoo);
printf("Digite a Data:\n");
tx->dataEmbarque = coletaData();
printf("Digite o horario:\n");
tx->horarioEmbarque = coletaTime();
printf("Digite o portao de embarque: ");
flush_inB();
gets(tx->portaoEmbarque);
}
//----------------------------------------

FilaTaxiamento.c

#include <sys/time.h>
#include <stdlib.h>
#include<string.h>
#include<stdio.h>
#include "FilaTaxiamento.h"
//Imprime a lista de taxiamentos pendentes
void printTaxi(FilaTaxiamento Fila){
TipoApontador Aux;
Aux = Fila.Frente->Prox;
printf("\n");
while (Aux != NULL){
imprimeTaxiamento(Aux->Item);
Aux = Aux->Prox;
}
}
//Imprime a lista dos cabe alhos dos taxiamentos pendentes
void printTaxiOrdem(FilaTaxiamento Fila){
TipoApontador Aux;
Aux = Fila.Frente->Prox;
while (Aux != NULL){
printf("\n");
imprimeTaxiamentoCab(Aux->Item);
printf("\n");
Aux = Aux->Prox;
}
}
//Imprime o primeiro taxiamento da fila
void printTaxiamento1(FilaTaxiamento Fila){

TipoApontador Aux;
Aux = Fila.Frente->Prox;
printf("\n");
imprimeTaxiamento(Aux->Item);
}
void Desenfileira(FilaTaxiamento *Fila, Taxiamento *Item){
TipoApontador q;
if (Vazia(*Fila)) { printf("Erro fila esta vazia\n"); return; }
q = Fila->Frente;
Fila->Frente = Fila->Frente->Prox;
*Item = Fila->Frente->Item;
free(q);
}
void Enfileira(Taxiamento x, FilaTaxiamento *Fila){
Fila->Tras->Prox = (TipoApontador) malloc(sizeof(TipoCelula));
Fila->Tras = Fila->Tras->Prox;
Fila->Tras->Item = x;
Fila->Tras->Prox = NULL;
}
int Vazia(FilaTaxiamento Fila){
return (Fila.Frente == Fila.Tras);
}
void initTaxamento(FilaTaxiamento *Fila){
Fila->Frente = (TipoApontador) malloc(sizeof(TipoCelula));
Fila->Tras = Fila->Frente;
Fila->Frente->Prox = NULL;
}
Taxiamento Localiza(FilaTaxiamento *Fila, int numeroVoo){
Taxiamento a;
return a;

PilhaBagagem.c

#include <sys/time.h>
#include <stdlib.h>
#include<string.h>
#include<stdio.h>
#include "PilhaBagagem.h"
void initPilha(PilhaBagagem *Pilha)
{ Pilha->Topo = (TipoApontadorB) malloc(sizeof(TipoCelulaB));
Pilha->Fundo = Pilha->Topo;
Pilha->Topo->Prox = NULL;
Pilha->Tamanho = 0;
}
int emptyPilha(PilhaBagagem Pilha)
{ return (Pilha.Topo == Pilha.Fundo); }
void Empilha(Bagagem x, PilhaBagagem *Pilha)
{ TipoApontadorB Aux;
Aux = (TipoApontadorB) malloc(sizeof(TipoCelulaB));
Pilha->Topo->Item = x;
Aux->Prox = Pilha->Topo;
Pilha->Topo = Aux;
Pilha->Tamanho++;
}
void Desempilha(PilhaBagagem *Pilha, Bagagem *Item)
{ TipoApontadorB q;
if (emptyPilha(*Pilha)) { printf("Erro: lista emptyPilha\n"); return; }
q = Pilha->Topo;

Pilha->Topo = q->Prox;
*Item = q->Prox->Item;
free(q); Pilha->Tamanho--;
}
int Tamanho(PilhaBagagem Pilha)
{ return (Pilha.Tamanho); }

PilhaBagagem.h

#ifndef PILHABAGAGEM_H
#define PILHABAGAGEM_H
#include "Bagagem.h"
typedef struct TipoCelulaB *TipoApontadorB;
typedef struct TipoCelulaB {
Bagagem Item;
TipoApontadorB Prox;
} TipoCelulaB;
typedef struct {
TipoApontadorB Fundo, Topo;
int Tamanho;
} PilhaBagagem;
//inicializa a pilha
void initPilha(PilhaBagagem *Pilha);
//verifica se a pilha est ou n o vazia
int emptyPilha(PilhaBagagem Pilha);
void Empilha(Bagagem x, PilhaBagagem *Pilha);
void Desempilha(PilhaBagagem *Pilha, Bagagem *Item);
//retorna o tamanho

int Tamanho(PilhaBagagem Pilha);

#endif /* PILHABAGAGEM_H */
#ifndef PILHABAGAGEM_H
#define PILHABAGAGEM_H
#include "Bagagem.h"
typedef struct TipoCelulaB *TipoApontadorB;
typedef struct TipoCelulaB {
Bagagem Item;
TipoApontadorB Prox;
} TipoCelulaB;
typedef struct {
TipoApontadorB Fundo, Topo;
int Tamanho;
} PilhaBagagem;
//inicializa a pilha
void initPilha(PilhaBagagem *Pilha);
//verifica se a pilha est ou no vazia
int emptyPilha(PilhaBagagem Pilha);
void Empilha(Bagagem x, PilhaBagagem *Pilha);
void Desempilha(PilhaBagagem *Pilha, Bagagem *Item);
//retorna o tamanho
int Tamanho(PilhaBagagem Pilha);
#endif /* PILHABAGAGEM_H */

Bagagem.h

#ifndef BAGAGEM_H
#define BAGAGEM_H
#define MAXLIST 5
// Estrutura de tempo, inicialmente o correte era fazer duas bibliotecas
separadas..... uma para tempo e outra para data
typedef struct {
int hora;
int minuto;
int segundo;
}Time2;
typedef struct {
int dia;
int mes;
int ano;
}Date1;
// Estrutura da bagagem
//-----------------------------------typedef struct {
int codBagagem;
int numPassagem;
int numVoo;
Date1 dataEmbarque;
Time2 horarioEmbarque;
char portaoEmbarque[50];
}Bagagem;
// -------------------------------------------void imprimeData(Date1 d);
Date1 coletaData();

void imprimeTimeB(Time2 t);

Time2 coletaTime();
// -------------------------------------void imprimeBagagem(Bagagem tx);
void imprimeBagagemCab(Bagagem tx);
void coletaDadosBagagem(Bagagem *tx);
//---------------------------------------void flush_inB();// funo para limpar o buffer do teclado -- feita para substituir o
fflush();
#endif /* BAGAGEM_H*/

Bagagem.c

#include <sys/time.h>
#include <stdlib.h>
#include<string.h>
#include<stdio.h>
#include "Bagagem.h"
void flush_inB(){
int ch;
while( (ch = fgetc(stdin)) != EOF && ch != '\n' ){}
}
// -------------------------------------------void imprimeData(Date1 d){
printf(" %d/",d.dia);
printf("%d/",d.mes);
printf("%d ",d.ano);
}

Date1 coletaData(){
Date1 temp;
int verifica =0;
while(verifica == 0){
printf("Dia: ");
scanf("%d",&temp.dia);
if(temp.dia >= 0 && temp.dia <= 31){
verifica = 1;
}
}
verifica = 0;
while(verifica == 0){
printf("Mes: ");
scanf("%d",&temp.mes);
if(temp.mes >= 0 && temp.mes <= 12){
verifica = 1;
}
}
verifica = 0;
while(verifica == 0){
printf("Ano: ");
scanf("%d",&temp.ano);
if(temp.ano >= 0){
verifica = 1;
}
}
return temp;
}
/*imprime a hora que foi passada como parametro*/
void imprimeTimeB(Time2 t){

printf(" %d:",t.hora);
printf("%d:",t.minuto);
printf("%d ",t.segundo);
}
/*Coleta a hora digitada pelo user*/
Time2 coletaTime(){
Time2 t;
int verifica = 0;
while(verifica == 0){
printf("\n Hora: ");
scanf("%d", &t.hora);
if(t.hora >= 0 && t.hora <= 23){
verifica = 1;
}
}
verifica = 0;
while(verifica == 0){
printf("Minuto: ");
scanf("%d", &t.minuto);
if(t.minuto >= 0 && t.minuto <= 59){
verifica = 1;
}
}
verifica = 0;
while(verifica == 0){
printf("Segundo: ");
scanf("%d", &t.segundo);
if(t.segundo >= 0 && t.segundo <= 59){
verifica = 1;
}

}
return t;
}
//--------------------------------------// -------------------------------------void imprimeBagagem(Bagagem tx){
printf("\nBagagem: %d\n",tx.codBagagem);
printf("Numero da passagem: %d\n",tx.numPassagem);
printf("Numero do Voo %d\n",tx.numVoo);
printf("Data de Embarque: ");imprimeData(tx.dataEmbarque);
printf("\nHorario de Saida: ");imprimeTimeB(tx.horarioEmbarque);
printf("\nPortao de embarque: %s", tx.portaoEmbarque);
}
void imprimeBagagemCab(Bagagem tx){
printf("Bagagem: %d\n",tx.codBagagem);
}
void coletaDadosBagagem(Bagagem *tx){
printf("Digite o codigo da Bagagem: ");
scanf("%d", &tx->codBagagem);
printf("Digite o numero da passagem: ");
scanf("%d", &tx->numPassagem);
printf("Digite o numero do voo: ");
scanf("%d", &tx->numVoo);
printf("Digite a Data:\n");
tx->dataEmbarque = coletaData();
printf("Digite o horario:\n");
tx->horarioEmbarque = coletaTime();
printf("Digite o portao de embarque: ");
flush_inB();
gets(tx->portaoEmbarque);

}
//----------------------------------------

main.c

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include "Taxiamento.h"
#include "FilaTaxiamento.h"
#include "Bagagem.h"
#include "PilhaBagagem.h"
/*
O projeto foi desenvolvido com a utilizao de bibliotecas.
Para poder utiliza ele no CODE BLOCKS:
* deve-se criar um projeto;
* adicionar o arquivo main;
* adicionar os outros arquivos;
* executar o main;
O arquivo main possui a implementao de duas funes(metodos) gerais:
void mainTaxiamento(Taxiamento *tx, FilaTaxiamento *ftx);
void mainBagagem(Bagagem *bg, PilhaBagagem *pbg);
estes metodos so para gerenciar o taxiamento e a bagagem.
A implementao foi feita em um unico arquivo, mas nada impediria de ser
realizada de forma separada com mais duas bibliotecas.
*/
//---------------void pause() {
system("pause");

}
void clear() {
system("cls");
}
void opIncorreta() {
printf("\nOpcao invalida ou indisponivel\n");
}
void agradecimento() {
printf("\nObrigado pela utilizacao, volte sempre\n");
}
//Funces de menu -----------------void menuTaxiamento();
void menuBagagem();
void menu();
//Funces para auxilio -------------void mainTaxiamento(Taxiamento *tx, FilaTaxiamento *ftx);
void mainBagagem(Bagagem *bg, PilhaBagagem *pbg);
//Funes especificas do taxiamento
void cadastraTaxiamento(Taxiamento *tx, FilaTaxiamento *ftx);
void autorizarTaxiamento(FilaTaxiamento *ftx);
//Funes especificas da bagagem
void cadastraBagagem(Bagagem *bg, PilhaBagagem *pbg);
void recuperarBagagem(PilhaBagagem *pbg, Bagagem *bg);
/* Main principal */
int main() {
clear();
// -------------------Taxiamento tx;
FilaTaxiamento ftx;
initTaxamento(&ftx);

// -------------------Bagagem bg;
PilhaBagagem pbg;
initPilha(&pbg);
int op = 0; // variavel de controle do menu principal
while(op != (-1) ) {
menu();
scanf("%d", &op);
//swich do menu principal
switch(op) {
case 1:
clear();
mainTaxiamento(&tx, &ftx);
break;
case 2:
clear();
mainBagagem(&bg, &pbg);
break;
case 0:
clear();
agradecimento();
op = -1;
break;
case -5:
clear();
break;
default:
clear();
opIncorreta();
op = 0;

break;
}
}
pause();
return 0;
}
//-- menu principal
void menu() {
printf("\t\t 1 - Menu Taxiamento\n");
printf("\t\t 2 - Menu Bagagem\n");
printf("\t\t 0 - Sair\n");
printf("\t\t-5 - Limpar\n");
}
//-- menu Taxiamento
void menuTaxiamento() {
printf("\t\t 1 Cadastrar Taxiamento - \n");
printf("\t\t 2 Autorizar Taxiamento - \n");
printf("\t\t 3 Vizilizar fila de taxiamentos - \n");
printf("\t\t 0 - Voltar ao menu principal\n");
printf("\t\t-5 - Limpar\n");
}
//-- Main Taxiamento
void mainTaxiamento(Taxiamento *tx, FilaTaxiamento *ftx) {
int op1 = 0;// variavel de controle do menu taxiamento
while(op1 != (-1) ) {
menuTaxiamento();
scanf("%d", &op1);
switch(op1) {
case 1:
clear();

cadastraTaxiamento(tx, ftx);
//opIncorreta();
break;
case 2:
clear();
autorizarTaxiamento(ftx);
break;
case 3:
clear();
printTaxiOrdem(*ftx);
break;
case 0:
clear();
//opIncorreta();
op1 = -1;
break;
case -5:
clear();
break;
default:
clear();
opIncorreta();
op1 = 0;
break;
}
}
}
/*
Cadastra o taxiamento recebendo um taxiamento e sua respectivo item
*/

void cadastraTaxiamento(Taxiamento *tx, FilaTaxiamento *ftx) {

coletaDadosTaxiamento(tx);
Enfileira(*tx, ftx);
}
void autorizarTaxiamento(FilaTaxiamento *ftx) {
Taxiamento temp;
int autorizado = 0 ;//variavel de controle - define se o voo esto autorizado
//ou no para prosseguir viagem
clear();
if(!Vazia(*ftx)) {}
printf("Autorizar taxiamento?????\t\n ");
printTaxiamento1(*ftx);
printf("\n1-Sim 2-No: ");
scanf("%d", &autorizado);
if(autorizado == 1) {
Desenfileira(ftx, &temp);
}else{
printf("\t\tNao ha avioes para taxiamento\n");
}
}
//-- menu Bagagem
void menuBagagem() {
printf("\t\t 1 Cadastrar bagagem - \n");
printf("\t\t 2 Recuperar bagagem - \n");
printf("\t\t 0 - Voltar ao menu principal\n");
printf("\t\t-5 - Limpar\n");
}
//-- Main Bagagem
void mainBagagem(Bagagem *bg, PilhaBagagem *pbg) {
int op2 = 0;// variavel de controle do menu bagagem

while(op2 != (-1) ) {
menuBagagem();
scanf("%d", &op2);
switch(op2) {
case 1:
clear();
cadastraBagagem(bg, pbg);
break;
case 2:
clear();
recuperarBagagem(pbg, bg);
break;
case 3:
clear();
opIncorreta();
break;
case 0:
clear();
//opIncorreta();
op2 = -1;
break;
case -5:
clear();
break;
default:
clear();
opIncorreta();
op2 = 0;
break;
}

}
}
void cadastraBagagem(Bagagem *bg, PilhaBagagem *pbg) {
coletaDadosBagagem(bg);
Empilha(*bg,pbg);
}
void recuperarBagagem(PilhaBagagem *pbg, Bagagem *bg){
int ont;//variavel de cotrole da opo
printf("tamanho da pilha %d\n",Tamanho(*pbg));
if(!emptyPilha(*pbg)){
printf("Deseja recuperar a bagagem? \n1-sim 2-nao: ");
scanf("%d", &ont);
if(1 == ont){
Desempilha(pbg, bg);
printf("Bagagem recuperada: \n");
imprimeBagagem(*bg);
printf("\n");
}
}
}

ETAPA 1

TIPOS DE DADOS
Em informtica todas as informaes so armazenadas em Bits que representa a menor
unidade de medida que s aceita 2 valores (0 e 1) que so mutuamente exclusivas, ou seja,
um Bit no pode assumir dois valores ao mesmo tempo, a representao de nmeros decimais
feita atravs de um calculo onde cada Bit representa uma potncia de 2 a contar a partir do
ultimo elemento da direita, ou seja, o numero binrio 00101110 seria em decimal 46. Veja o
porque:
00101110 contando da direita para esquerda todos os elementos que so 1 temos a seguinte
frao:
21+22+23+25=2+4+8+32=46.
se quisermos representar o mesmo numero porem negativo, basta invertemos os nmeros, ou
seja, onde 0 fica 1 e onde 1 fica 0, veja como ficaria nosso numero negativo:
11010001=-46.
Pode-se dizer ento que todo numero binrio que representa um numero decimal se iniciado
com 0 positivo e se iniciado com 1 negativo.
Para representar nmeros reais utiliza-se a notao de ponto flutuante.No qual o numero
real representado pela mantissa multiplica pela base elevada a uma potencia de inteiro
(expoente). Em geral, a base fixa, e a mantissa e o expoente variam de modo a representar
nmeros reais diferentes. Um nmero real representado por uma string de 32 bits
consistindO em uma mantissa de 24 bits seguida por um expoente de 8 bits.
A vantagem da notao de ponto flutuante que ela pode ser usada para representar
nmeros com valores absolutos muito grandes ou muito pequenos. O menor nmero positivo
que pode ser representado 10-128, que muito pequeno. O fator limitante na exatido com a
qual os nmeros podem ser representados em determinada mquina o nmero de dgitos
binrios significativos na mantissa.
Para representar caracteres no numricos utilizamos a string de caracteres, cada caractere
possuem 8 Bits.Exemplo:
A letra A em binrio 01000001, e a letra B 01000010 esses caracteres so
conhecidos como strings de Bits para escrever os caracteres AB juntos ficaria
0100000101000010 (juno do cdigos binrios de cada letra), e isto considerado uma string
de caracteres uma vez que para escrever mais de uma letra utilizado a concatenao de
caracteres. Um mtodo de interpretar um padro de bits frequentemente chamado tipo de
dado.

MEMRIA

A memria um conjunto de Bits (chaves).Os bits na memria de um computador so

agrupados em unidades maiores, como bytes.Em alguns computadores, vrios bytes so
agrupados em unidades chamadas palavras. Cada unidade desse tipo recebe a atribuio de
um endereo, isto , um nome que identifica determinada unidade entre todas as unidades na
memria.Um endereo frequentemente chamado posio, e o contedo de uma posio so
os valores dos Bits que formam a unidade nessa posio.Todo computador tem um conjunto
de tipos de dados "nativos". Isso significa que ele construdo com um mecanismo para
manipular padres de bits coerentes com os objetos que eles representam. Por exemplo, um
computador que contem a instruo para somar dois inteiros binrios e introduzir sua soma em
determinada posio na memria para uso posterior. Sendo assim, deve existir um mecanismo
incorporado no computador para:
1. extrair os padres de bits dos operandos de duas posies determinadas;
2. produzir um terceiro padro de bits representando o inteiro binrio que seja a soma dos dois
inteiros binrios representados pelos dois operandos; e
3. armazenar o padro de bits resultante em determinada posio.
O computador "sabe" interpretar os padres de bits nas posies especficas como inteiros
binrios porque o hardware que executa a instruo foi projetado para fazer isso.
Se a mesma mquina tiver tambm uma instruo para somar dois nmeros reais, dever
existir um mecanismo embutido separado para interpretar operandos como nmeros reais. So
necessrias duas instrues distintas para as duas operaes, e cada instruo carrega em si
mesma uma identificao implcita dos tipos de seus operandos, alm de suas posies
explcitas.
importante reconhecer o papel-chave desempenhado pelas declaraes numa linguagem
de alto nvel. por meio das declaraes que o programador especifica como o contedo da
memria do computador deve ser interpretado pelo programa.

IMPLEMENTAO

Existem dois tipos de implementao, implementao de hardware e implementao de

software.
Na implementao de hardware construdo um circuito para efetuar as operaes
necessrias.
Na implementao de software um programa consistindo em instrues de hardware j
existentes criado para interpretar strings de bits na forma desejada e efetuar as operaes
necessrias, sendo assim, nesta implementao possvel criar um novo tipo de dado que
interaja com um tipo de dado j existente, assim como manipula e o mesmo.
Para implementar um novo tipo de dados necessrio descrever como ele ser
representado na memria e em seguida como ela ser manipulada. ( necessrio conhecer a
quantidade de bytes que deve ser deslocada para executar essa instruo).

A linguagem C usa uma implementao que evita limitaes sobre o tamanho da string,
todas as strings terminam com um caractere especial, '\0'. Este caractere nunca aparece dentro
de uma string, ele introduzido automaticamente no final de cada string.Todas as operaes
de strings devem proceder de um caractere por vez at que '\0' seja encontrado.
Uma desvantagem da implementao de strings de caracteres de C que o tamanho de
uma string de caracteres no est disponvel sem avanar na string um caractere de cada vez
at encontrar um '\0'. Por outro lado no h um limite arbitrrio imposto sobre o tamanho da
string.
Assim que for definida uma representao para objetos de determinado tipo de dado e forem
escritas as rotinas para operar sobre esta representao, o programador poder usar este tipo
de dado para solucionar problemas. O programador da mquina original no precisa se
preocupar com o modo como o computador projetado e com o circuito usado para executar
cada instruo. O programador s precisa conhecer as instrues disponveis e como essas
instrues podem ser usadas. De modo semelhante, o programador que usar a mquina
"estendida" (consistindo em hardware e software), ou o "computador virtual", no precisar se
preocupar com os detalhes da implementao dos diversos tipos de dados. Tudo o que o
programador precisa saber como eles podem ser manipulados.
importante reconhecer as limitaes de determinada implementao. Frequentemente,
ser possvel apresentar vrias implementaes do mesmo tipo de dado, cada uma com
vantagens e desvantagens prprias.Talvez determinada implementao seja melhor que outra
para uma aplicao especfica.
Em toda implementao o importante levar em conta a sua eficincia. A razo pela qual as
estruturas de dados de alto nvel no serem construdas em C a sobrecarga que
acarretariam. Existem linguagens de nvel mais alto que C, que possuem vrios desses tipos
de dados j incorporados, mas muitas delas so ineficientes e, portanto, no amplamente
usadas.
Em geral, a eficincia determinada por dois fatores: tempo e espao.Se determinada
aplicao depender intensivamente da manipulao de estruturas de dados de alto nvel, a
velocidade na qual essas manipulaes podem ser executadas ser o principal determinante
da velocidade da aplicao inteira. De modo semelhante, se um programa usar uma grande
quantidades destas estruturas, uma implementao que utiliza uma quantidade excessiva de
espao para representar a estrutura de dados no ser prtica. Em geral existe um
compromisso entre esses dois prismas de eficincia, de modo que uma implementao veloz
usa mais armazenamento do que uma implementao lenta. A escolha da implementao
nesse caso requer uma avaliao cuidadosa dos compromissos entre as vrias possibilidades.

ESTRUTURA DE DADOS

O estudo da estrutura de dados abrange duas metas complementares, a primeira meta

identificar e desenvolver entidades e operaes matemticas teis e determinar que classes de
problemas podem ser solucionadas, usando essas entidades e operaes, neste meta utilizase um tipo de dado alto nvel como ferramenta para resolver outros problemas (se necessrio).
A segunda meta determinar representaes para essas entidades abstratas e implementar
as operaes abstratas sobre essas representaes concretas, esta meta percebe a
implementao de tal tipo de dado como um problema a ser resolvido usando os tipos de
dados j existentes. Ao determinar representaes para as entidades abstratas preciso ter o
cuidado de especificar os recursos disponveis para construir tais representaes.

PONTEIRO

Ponteiro um tipo de varivel em C que guarda o endereo de outra varivel.

A declarao do ponteiro feita da seguinte forma int *p, onde int o tipo da varivel, o *
indica que ela do tipo ponteiro e p o nome do modelo, o valor do ponteiro o valor do
endereo de memria assim como o valor de um inteiro um numero.
Ponteiro tem dois operadores unitrio o * e &.
O operador * retorna o valor da varivel que esta apontada pelo ponteiro.
O operador & retorna o endereo de memria da varivel apontada pelo ponteiro.
A atribuio de valores para variveis do tipo ponteiro igual atribuio de valores do tipo
objetos. Exemplo: *p=x;
Ponteiro quando declarado e iniciado com endereo no valido, portanto necessrio
atribuir um valor ao mesmo antes da utilizao.
Para utilizar comandos de comparao/ deciso (if) por exemplo utilizamos a seguinte
sintaxe:
if(px1>px2);
Para realizar a converso do tipo de dado entre ponteiro feita da seguinte forma:
pi = (int *) pf;
Onde pi um ponteiro do tipo inteiro, pf um ponteiro do tipo ponto flutuante e (int *)
converte o valor de pf para o tipo ponteiro para um int
Os ponteiros devem ser interligados para formar uma estrutura
Para realizar somas e subtraes dos ponteiros utilizamos a seguinte sintaxe:
px1=px1+2;
px2=px2-2;
px1=2+px2;
Caso o ponteiro seja utilizado para auxiliar na criao de registros ser necessrio criar
ponteiros auxiliares para que todas os registros criados sejam interligados, sem alterar o ultimo
registro criado.

VETORES UNIDIMENCIONAIS

Vetor uma estrutura de dados em C no qual o programador defini um numero finito de

variveis do mesmo tipo em uma nica varivel, o termo finito utilizado pois o numero de
posies (elementos) a serem armazenadas definida pelo programador durante a declarao
deste vetor, para navegarmos por suas posies deve- se ter uma estrutura de repetio junto
com um contador que incremente ou decremente o valor do ndice para que o mesmo navegue
por todas posies do vetor.
O primeiro ndice do vetor 0 e o ultimo ndice ser o valor estipulado pelo programado
que sempre reservado para o prprio vetor. Veja o exemplo:
Declarao do vetor.
int vet[20];
Onde int o tipo de vetor, vet o nome do vetor e [20] a quantidade de elementos que
este vetor pode armazenar. Este vetor tem 20 posies porem s poder ser alterados o
intervalo entre as posies 0 e 19 que no total somam 20 elementos. O elemento na posio
20 reservado indicando para a memria que este vetor acabou.
Inserindo informaes no vetor.
for(i=0);

ALOCAO ESTTICA DE MEMORIA

Alocao esttica de memria quando o compilador reserva em tempo de compilao um

espao determinada da memria do computador para armazenar uma determinada informao
cujo o tamanho do espao no pode ser alterado durante a execuo, este tipo de
armazenamento geralmente usado quando se sabe qual o tamanho da informao a ser
salva.
A alocao esttica de memria mantm as informaes organizadas na memria de forma
linear e sequencial. Isto facilita a sua localizao e manipulao. Em contra partida, precisamos
estabelecer previamente a quantidade mxima necessria de memria para armazenar uma
determinada estrutura de dados, ou seja, se durante a execuo for constatado que
necessrio mais espao de memria ser necessrio alterar o espao reservado no cdigo
fonte da aplicao, ou at mesmo, se precauo for reservado um espao maior que o utilizado
este espao continuar reservado e sem utilizao, ou seja, ser um espao que esta
reservado sem utilizao (lixo de memria).

#include <stdio.h>
typedef struct aviao
{
char modelo[50];
char fabricante[20];
int passageiros;
float comprimento;
float altura;
float velocidade;
float altitude;
char motor[30];
}AVIAO;
void mostrar(struct aviao x)
{
printf("Modelo: %s\n", x.modelo);
printf("Fabricante: %s\n", x.fabricante);
printf("Passageiros: %d\n", x.passageiros);
printf("Comprimento: %.2f m\n", x.comprimento);
printf("Altura: %.2f m\n", x.altura);
printf("Velocidade: %.2f Km/h\n", x.velocidade);
printf("Altitude: %.2f m\n", x.altitude);
printf("Motor: %s\n", x.motor);
}
main()
{
char modelo[50];
char fabricante[20];
int passageiros;
float comprimento;

float altura;
float velocidade;
float altitude;
char motor[30];
printf("**********VOEBEM***********\n\n");
printf("Entre com o modelo do aviao: ");
scanf("%s",modelo);
printf("\nEntre com o fabricante do aviao: ");
scanf("%s",fabricante);
printf("\nEntre com a quantidade de passageiros do aviao: ");
scanf("%d",&passageiros);
printf("\nEntre com o comprimento do aviao: ");
scanf("%f",&comprimento);
printf("\nEntre com a altura do aviao: ");
scanf("%f",&altura);
printf("\nEntre com a velocidade do aviao: ");
scanf("%f",&velocidade);
printf("\nEntre com a altitude do aviao: ");
scanf("%f",&altitude);
printf("\nEntre com o motor do aviao: ");
scanf("%s",motor);
printf("\n\n");
AVIAO aviao;
strcpy(aviao.modelo, modelo);
strcpy(aviao.fabricante, fabricante);
aviao.passageiros = passageiros;
aviao.comprimento = comprimento;
aviao.altura = altura;
aviao.velocidade = velocidade;

aviao.altitude = altitude;
strcpy(aviao.motor, motor);
printf("Aviao cadastrado com sucesso!!!!\n\n");
mostrar(aviao);
printf("\n\n");
system("PAUSE");
}

ETAPA 2

#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
struct voo
{
int numvoo;
int datavoo;
int horario;
char saida[40];
char chegada[40];
char rota[60];
int passabordo;
};
void menu();
void consultar();
void cadastro();
void selecao();
void remover();
struct voo *inf;
main()
{
menu();
return 0;
system("pause");
}

void menu()
{
printf("\n Empresa VOEBEM \n");
printf(" ============================ \n\n");
printf(" ____________________________\n");
printf("| Escolha uma opo abaixo |\n");
printf("|----------------------------|\n");
printf("| 1 - Cadastrar Passagem |\n");
printf("| 2 - Consultar Passagem |\n");
printf("| 3 - Remover |\n");
printf("| 0 - Sair |\n");
printf("|____________________________|\n");
selecao();
}
void selecao(){
int opo;
printf("\nDigite uma das opes: ");
scanf("%i", &opo);
switch (opo){
case 1:
cadastro();
menu();
break;
case 2:
consultar();
menu();
break;
case 3:
remover();

menu();
break;
case 0:
system("pause");
exit(0);
break;
default:
printf("\n\nOpcao nao encontrada.\nTente Novamente\n\n");
system("pause");
system("cls");
menu();
break;
}
}

//FUNO CADASTRAR

void cadastro(){
int num;
do{
inf = (struct voo *) malloc(sizeof(struct voo));
printf("\n\n*****CADASTRO DE VOO*****\n");
printf("\nNumero do voo: ");
scanf("%d", &inf->numvoo);
fflush(stdin);
printf("\nData do voo: ");
scanf("%d", &inf->datavoo);
printf("\nHorario do voo: ");

scanf("%d", &inf->horario);
printf("\nAeroporto de saida: ");
fflush(stdin);
gets(inf->saida);
printf("\nAeroporto de chegada: ");
fflush(stdin);
gets(inf->chegada);
printf("\nRota do voo: ");
fflush(stdin);
gets(inf->rota);
printf("\nPassageiros a bordo: ");
fflush(stdin);
scanf("%d", &inf->passabordo);
printf(" ___________________________________\n");
printf("| Escolha uma opo abaixo |\n");
printf("|-----------------------------------|\n");
printf("| 1 - Cadastrar outra Passagem |\n");
printf("| 0 - Voltar ao menu |\n");
printf("|___________________________________|\n");
printf("opo: ");
scanf("%d",&num);
}while(num!=0);
system("cls");
}
void remover(){
free(*inf);
break;
menu();
}

//FUNO CONSULTAR

void consultar(){
system("cls");
int consult;
printf("Digite o numero do voo: ");
scanf("%d", &consult);
if(inf->numvoo!=consult){
printf("Numero nao encontrado\n");
printf("Tente Novamente");
getch();
system("cls");
consultar();
}else{
printf("\n-----------------------------");
printf("\nNumero do voo encontrado");
printf("\nNumero do Voo: %d ", inf->numvoo);
printf("\n\nData do voo: %d ", inf->datavoo);
printf("\nHorario do voo: %d", inf->horario);
printf("\nAeroporto de saida: %s ", &inf->saida);
printf("\nAeroporto de chegada: %s", &inf->chegada);
printf("\nRota: %s", &inf->rota);
printf("\nPassageiros a bordo: %d", inf->passabordo);
getch();
system("cls");
menu();
}
}