C problema exercicio em C

juan vieira prado · 19 de maio de 2019

olá estou tentando fazer um exercício na linguagem c, não consigo adaptar o código para o que o exercício pede, poderiam me ajudar?

• typedef struct fila Fila;

• Fila* cria (void); /* cria uma fila vazia */

• void insere (Fila* f, float v); /* insere um elemento */

• float retira (Fila * f); /* retira um elemento */

• int vazia (Fila * f); /* retorna se está vazia */

• void libera (Fila * f); /* libera a estrutura */

Suponha que uma empresa de ônibus mantém um cadastro de aeroportos como uma fila implementada com uma lista encadeada as seguintes informações:
1. Sigla: cadeia com até 3 caracteres; 2. Cidade: cadeia com até 50 caracteres; 3. Pais: cadeia com até 30 caracteres; 4. Taxa: um valor real; 5. Capacidade: um valor inteiro;
Pede-se:
A) Defina uma estrutura em C com o nome de aeroporto, que tenha os campos apropriados para guardar todas as informações descritas anteriormente. Defina também um novo tipo de dados com o nome de Busão, correspondendo a essa estrutura.
b) Escreva uma função que cria dinamicamente e preenche uma variável do tipo Aeroporto. Esta função deve receber como parâmetros as cadeias de caracteres s, contendo a sigla do aeroporto, c e p, contendo, respectivamente, a cidade e o país onde esse se localiza, o valor real tx, contendo a taxa cobrada por ele, e o inteiro cap, indicando sua capacidade; e retornar um ponteiro para a variável alocada dinamicamente. Se não for possível alocar uma variável, a função deve retornar NULL. A função deve ter o seguinte protótipo:
Busão* Cadastra(char* s, char* c, char* p, float tx, int cap);

e meu código está assim:

#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>

struct Node{
 char s[3]; /*sigla*/
 char c[50]; /*cidade */
 char p[30]; /*pais*/
 float tx; /*taxa*/
 int cap; /*capacidade*/
 struct Node *prox;
};
typedef struct Node node;

int tam;

int menu(void);
void opcao(node *FILA, int op);
void inicia(node *FILA);
int vazia(node *FILA);
node *Cadastra();
void insere(node *FILA);
node *retira(node *FILA);
void exibe(node *FILA);
void libera(node *FILA);


int main(void)
{
 node *FILA = (node *) malloc(sizeof(node));
 if(!FILA){
  printf("Sem memoria disponivel!\n");
  exit(1);
 }else{
 inicia(FILA);
 int opt;

 do{
  opt=menu();
  opcao(FILA,opt);
 }while(opt);

 free(FILA);
 return 0;
 }
}


int menu(void)
{
 int opt;

 printf("Escolha a opcao\n");
 printf("0. Sair\n");
 printf("1. Zerar fila\n");
 printf("2. Exibir fila\n");
 printf("3. Adicionar Elemento na Fila\n");
 printf("4. Retirar Elemento da Fila\n");
 printf("Opcao: "); scanf("%d", &opt);

 return opt;
}

void opcao(node *FILA, int op)
{
 node *tmp;
 switch(op){
  case 0:
   libera(FILA);
   break;

  case 1:
   libera(FILA);
   inicia(FILA);
   break;

  case 2:
   exibe(FILA);
   break;

  case 3:
   insere(FILA);
   break;

  case 4:
   tmp= retira(FILA);
   if(tmp != NULL){
    printf("Retirado.");
    libera(tmp);
   }
   break;

  default:
   printf("Comando invalido\n\n");
 }
}

void inicia(node *FILA)
{
 FILA->prox = NULL;
 tam=0;
}

int vazia(node *FILA)
{
 if(FILA->prox == NULL)
  return 1;
 else
  return 0;
}

node *Cadastra()
{
 node *novo=(node *) malloc(sizeof(node));
 if(!novo){
  printf("Sem memoria disponivel!\n");
  return NULL;
 }else{
  printf("Nova sigla: "); 
  scanf("%s", &novo->s);
  
  printf("Nova cidade: "); 
  scanf("%s", &novo->c);
  
  printf("Novo Pais: "); 
  scanf("%s", &novo->p);
  
  printf("Nova taxa: "); 
  scanf("%f", &novo->tx);
  
  printf("Nova capacidade: "); 
  scanf("%d", &novo->cap);
  return novo;
 }
}

void insere(node *FILA)
{
 node *novo=Cadastra();
 novo->prox = NULL;

 if(vazia(FILA))
  FILA->prox=novo;
 else{
  node *tmp = FILA->prox;

  while(tmp->prox != NULL)
   tmp = tmp->prox;

  tmp->prox = novo;
 }
 tam++;
}


node *retira(node *FILA)
{
 if(FILA->prox == NULL){
  printf("Fila ja esta vazia\n");
  return NULL;
 }else{
  node *tmp = FILA->prox;
  FILA->prox = tmp->prox;
  tam--;
  return tmp;
 }

}


void exibe(node *FILA)
{
 if(vazia(FILA)){
  printf("Fila vazia!\n\n");
  return ;
 }

 node *tmp;
 tmp = FILA->prox;
 printf("Fila :");
 while( tmp != NULL){
  printf("%s\n", tmp->s);
  printf("%s\n", tmp->c);
  printf("%s\n", tmp->p);
  printf("%f\n", tmp->tx);
  printf("%d\n", tmp->cap);
  tmp = tmp->prox;
 }
 /*printf("\n        ");
 int count;
 for(count=0 ; count < tam ; count++)
  printf("  ^  ");
 printf("\nOrdem:");
 for(count=0 ; count < tam ; count++)
  printf("%5d", count+1);

*/
 printf("\n\n");
}

void libera(node *FILA)
{
 if(!vazia(FILA)){
  node *proxNode,
     *atual;

  atual = FILA->prox;
  while(atual != NULL){
   proxNode = atual->prox;
   free(atual);
   atual = proxNode;
  }
 }
}

Ansi C · 19 de maio de 2019

Anotei os pedidos do enunciado ...

1) Definir uma estrutura chamada Aeroporto com seguintes campos:

char s[],

char c[],

char p[],

float tx,

int cap

2) Definir um tipo de dados com nome Busao a partir da estrutura Aeroporto

3) Definir a função Cadastro com seguinte protótipo: Busao* Cadastra(char* s, char* c, char* p, float tx, int cap);

/* Meu Programa C */

#include <stdlib.h>
#include <stdio.h>

/* Minhas Estrutura de Dados */
struct ?
{	char s[?];
	char c[?];
	char p[?];
	float tx; 
	int cap;
};

/* Meus Nomes */
typedef struct Aeroporto ?;

/* Meus protótipos de Função */
Busao* Cadastra(char* s, char* c, char* p, float tx, int cap);

/* Minha Função Principal */
int main(void)
{	Busao* bc= Cadastra("PMJ", "Jurema", "Brazil", 1.5, 60);

	printf("Busao Cadastrado tem capacidade %d pessoa(s).\n", ?);
	printf("Busao Cadastrado tem taxa %.2f por pessoa.\n",    ?);

	return EXIT_SUCCESS;
}

/* Meus protótipos de Função Definidos */
Busao* Cadastra(char* s, char* c, char* p, float tx, int cap)
{	Busao* bc= calloc(1, sizeof (*bc));
	if (NULL == bc) return ?;
    
	int index;
	index= -1; if (NULL != s) while('\0' != (s)[++index]) (bc->s[index])= ((s)[index]);
   	index= -1; if (NULL != c) while('\0' != (c)[++index]) (bc->c[index])= ((c)[index]);
   	index= -1; if (NULL != p) while('\0' != (p)[++index]) (bc->p[index])= ((p)[index]);

   	bc->tx= tx;
   	bc->cap= cap;
    
   	return ?;
}

@juan vieira prado Sua obrigação agora e substituir as interrogações por aquilo que acha certo.

juan vieira prado · 19 de maio de 2019

@AnsiC me parece mais fácil de entender agora, vou tentar fazer, não tive muitas aulas de estrutura de dados, então está um pouco complicado pra mim :v

valeu

juan vieira prado · 19 de maio de 2019

@AnsiC não estou conseguindo fazer, e percebi que faltou eu falar alguns detalhes também.

• typedef struct fila Fila;

• Fila* cria (void); /* cria uma fila vazia */

• void insere (Fila* f, float v); /* insere um elemento */

• float retira (Fila * f); /* retira um elemento */

• int vazia (Fila * f); /* retorna se está vazia */

• void libera (Fila * f); /* libera a estrutura */

2 horas atrás, AnsiC disse:

Ansi C · 19 de maio de 2019

10 horas atrás, juan vieira prado disse:

Suponha que uma empresa de ônibus mantém um cadastro de aeroportos como uma fila implementada com uma lista encadeada as seguintes informações:
1. Sigla: cadeia com até 3 caracteres; 2. Cidade: cadeia com até 50 caracteres; 3. Pais: cadeia com até 30 caracteres; 4. Taxa: um valor real; 5. Capacidade: um valor inteiro;
Pede-se:
A) Defina uma estrutura em C com o nome de aeroporto, que tenha os campos apropriados para guardar todas as informações descritas anteriormente. Defina também um novo tipo de dados com o nome de Busão, correspondendo a essa estrutura.
b) Escreva uma função que cria dinamicamente e preenche uma variável do tipo Aeroporto. Esta função deve receber como parâmetros as cadeias de caracteres s, contendo a sigla do aeroporto, c e p, contendo, respectivamente, a cidade e o país onde esse se localiza, o valor real tx, contendo a taxa cobrada por ele, e o inteiro cap, indicando sua capacidade; e retornar um ponteiro para a variável alocada dinamicamente. Se não for possível alocar uma variável, a função deve retornar NULL. A função deve ter o seguinte protótipo:
Busão* Cadastra(char* s, char* c, char* p, float tx, int cap);

Esse é o enunciado

6 minutos atrás, juan vieira prado disse:

typedef struct fila Fila;

• Fila* cria (void); /* cria uma fila vazia */

• void insere (Fila* f, float v); /* insere um elemento */

• float retira (Fila * f); /* retira um elemento */

• int vazia (Fila * f); /* retorna se está vazia */

• void libera (Fila * f); /* libera a estrutura */

Em parte alguma dele é exigido essas funções, portanto poste o enunciado completo como ele foi dado.

adicionado 1 minuto depois

9 minutos atrás, juan vieira prado disse:

não estou conseguindo fazer

Onde mais sentiu dificuldade?

adicionado 3 minutos depois

3 minutos atrás, AnsiC disse:

Suponha que uma empresa de ônibus mantém um cadastro de aeroportos como uma fila implementada com uma lista encadeada as seguintes informações:

Talvez essa parte aqui tem lhe dado a impressão de que é necessário ter a implementação completa, mas não precisa é a penas uma suposição.

juan vieira prado · 19 de maio de 2019

@AnsiC arrumei o post, foi mal.

agora que o enunciado está completo, estou tendo dificuldade de fazer o exercício "completo" que seria colocar mais essa parte que eu não tinha colocado no enunciado.

adicionado 2 minutos depois

@AnsiC eu aprendi um pouco de pilha na faculdade, o professor atrasou a matéria, então ta bem difícil entender

Ansi C · 19 de maio de 2019

38 minutos atrás, juan vieira prado disse:

eu aprendi um pouco de pilha na faculdade, o professor atrasou a matéria, então ta bem difícil entender

Sendo assim aconselho uma leitura para reforço; caso não tenha anotações busque assistir algumas vídeo-aulas no youtube. Eu faria um resumo rápido aqui agora mesmo, porém sabemos que isso ajuda menos que uma vídeo aula da internet.

juan vieira prado · 19 de maio de 2019

@AnsiC eu fiz esse código:

#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>



// estrutura que guarda as informações de cada nó 
struct aeroporto{
	
	char s[3];//sigla
	char c[50];//cidade
	char p[30];//pais
	float tx;//taxa
	int cap;//capacidade
	struct BUSAO* prox;
};
typedef struct aeroporto BUSAO;

//estrutura que organisa conforme os padrões da fila(obs: essa estrutura pode se dizer que ela é a propria fila)
struct fila{
	
	BUSAO* ini;
	BUSAO* fim;
};

typedef struct fila FILA;

// função para criar a fila
FILA* cria(void)
{
	FILA* f = (FILA*)malloc(sizeof(FILA));
	f->ini = f->fim = NULL;
	return f;
}

// função para inserir elementos na fila
void fila_inseri(FILA* f, char* s, char* c, char* p, float tx, int cap)
{
	
	BUSAO* n = (BUSAO*)malloc(sizeof(BUSAO));
		
	strcpy(n->s, s);
	strcpy(n->c, c);
	strcpy(n->p, p);
	n->tx = tx;
	n->cap = cap;
	n->prox = NULL;
	
	if(f->fim != NULL)
	{
		f->fim->prox = n;
	}
	else
	{
		f->ini = n;
		f->fim = n;
	}
	
	
}

// função para verificar se a fila está vazia
int fila_vazia(FILA* f)
{
	if(f->fim == NULL || f->ini == NULL);
	{
		return 1;
	}
	
	return 0;
	
}


// função para retirar elementos da fila
float fila_retira(FILA* f)
{
	BUSAO* t;
	int v;
	
	if(fila_vazia(f))
	{
		printf("Fila vazia.\n");
		return;
	}
	
	t = f->ini;
	
	v = t->tx;
	
	f->ini = t->prox;
	
	if(f->ini == NULL)
	{
		f->fim = NULL;
	}
	
	free(t);
	
	return(v);
}

// função para liberar a memoria alocada para a fila
float fila_libera(FILA* f)
{
	
	BUSAO* q = f->ini;
	
	while(q != NULL)
	{
		BUSAO* t = q->prox;
		free(q);
		q = t ;
	}
	
	free(f);
	
	return 0;
}

//função que tem que ser usada na solução(ainda em construção) 
BUSAO* Cadastra(char* s, char* c, char* p, float tx, int cap)
{
	FILA* f= (FILA*)malloc(sizeof(FILA));
	if(f == NULL)
	{
		return NULL;
	}
	
	BUSAO* n = (BUSAO*)malloc(sizeof(BUSAO));
		
	strcpy(n->s, s);
	strcpy(n->c, c);
	strcpy(n->p, p);
	n->tx = tx;
	n->cap = cap;
	n->prox = NULL;
	
	if(f->fim != NULL)
	{
		f->fim->prox = n;
	}
	else
	{
		f->ini = n;
		f->fim = n;
	}
	
	
	printf("%s, %s, %s, %f, %d",n->s, n->c, n->p, tx, cap);
	
	return;
}


main()
{
	FILA* f = cria();

	char *sigla, *cidade, *pais;
	float taxa;
	int capacidade, op, x;

	
	sigla = (char *)malloc(3*sizeof(char));
	cidade = (char *)malloc(50*sizeof(char));
	pais = (char *)malloc(30*sizeof(char));
	
	while(true)
	{
	
		printf("\n\n");
		printf("------------------------------");
		printf("\n\tInsira numero       |");
		printf("\n1-Insirir elementos na fila |");
		printf("\n2-Retirar elementos da fila |");
		printf("\n3-Excluir fila atual        |");
		printf("\n4-Excluir e sair            |");
		printf("\n5-Sair                      |");
		printf("\n------------------------------");
		
		printf("\n\nop: ");
		
		scanf("%d", &op);fflush(stdin);
		
		switch(op)
		{
			case 1:
				
				printf("\ninsira a sigla: ");
				gets(sigla);fflush(stdin);
			
				printf("\ninsira a cidade: ");
				gets(cidade);fflush(stdin);
			
				printf("\ninsira o pais: ");
				gets(pais);fflush(stdin);
				printf("\n");
			
				printf("insira a taxa: ");
				scanf("%f", &taxa);
				printf("\n");
				
				printf("insira a capacidade: ");				
				scanf("%d", &capacidade);
				printf("\n");
				
				//fila_inseri(f, sigla, cidade, pais, taxa, capacidade);
				Cadastra(sigla, cidade, pais, taxa, capacidade);
				
			break;
				
			case 2:
				x =	fila_retira(f);
			break;
			
			case 3:
				x = fila_libera(f);
				FILA* f = cria();
			break;
			
			case 4:
			 	x = fila_libera(f);
				exit(0);
			break;
			
			case 5:
				exit(0);
			break;
		}
	}
}