#include <stdio.

h> // Inclui a biblioteca padrão de entrada e saída

#include <stdlib.h> // Inclui a biblioteca padrão de funções utilitárias

#define TAMANHO_MAXIMO 100 // Define o tamanho máximo da fila

// Estrutura da fila typedef struct { int itens[TAMANHO_MAXIMO]; // Array

para armazenar os elementos da fila int frente; // Índice para o primeiro

elemento da fila int fim; // Índice para o último elemento da fila

} Fila;

// Função para criar uma fila vazia

Fila* criarFila() {

Fila* fila = (Fila*)malloc(sizeof(Fila)); // Aloca memória para a estrutura da fila

fila->frente = -1; // Inicializa a frente como -1 fila->fim = -1; // Inicializa o

fim como -1 return fila; // Retorna o ponteiro para a fila criada

// Função para verificar se a fila está vazia int estaVazia(Fila* fila) { return fila->frente == -1 &&

fila->fim == -1; // Retorna verdadeiro se a frente e o fim forem -1

// Função para verificar se a fila está cheia int

estaCheia(Fila* fila) {

return (fila->fim + 1) % TAMANHO_MAXIMO == fila->frente; // Retorna verdadeiro se o próximo

índice do fim for igual à frente

// Função para adicionar um elemento à fila void enfileirar(Fila* fila, int valor) { if (estaCheia(fila)) {

// Verifica se a fila está cheia printf("A fila está cheia. Não é possível enfileirar %d\n", valor); //

Exibe uma mensagem de erro return; // Retorna sem fazer nada

}
 if (estaVazia(fila)) { // Verifica se a fila está vazia

fila->frente = 0; // Define a frente como 0 fila->fim

= 0; // Define o fim como 0

} else {

fila->fim = (fila->fim + 1) % TAMANHO_MAXIMO; // Atualiza o índice do fim

fila->itens[fila->fim] = valor; // Adiciona o valor na posição do fim da fila

printf("%d enfileirado na fila\n", valor); // Exibe uma mensagem de sucesso

// Função para remover um elemento da fila void desenfileirar(Fila* fila, int quantidade) { if

(estaVazia(fila)) { // Verifica se a fila está vazia printf("A fila está vazia. Não é possível

desenfileirar\n"); // Exibe uma mensagem de erro return; // Retorna sem fazer nada

if (quantidade <= 0) { // Verifica se a quantidade é menor ou igual a zero

printf("A quantidade de elementos a desenfileirar deve ser maior que zero\n"); // Exibe uma
mensagem de erro

return; // Retorna sem fazer nada

if (quantidade > (fila->fim - fila->frente + 1)) { // Verifica se a quantidade é maior que o número de
elementos na fila

printf("Não há elementos suficientes na fila para desenfileirar\n"); // Exibe uma mensagem de

erro return; // Retorna sem fazer nada
}

for (int i = 0; i < quantidade; ++i) { // Loop para desenfileirar a quantidade especificada de
elementos printf("Desenfileirado: %d\n", fila->itens[fila->frente]); // Exibe o elemento
desenfileirado fila->frente = (fila->frente + 1) % TAMANHO_MAXIMO; // Atualiza o índice
da frente

// Função para obter o elemento da frente da fila sem removê-lo

int frente(Fila* fila) { if (estaVazia(fila)) { // Verifica se a fila

está vazia printf("A fila está vazia\n"); // Exibe uma

mensagem de erro return -1; // Retorna um valor inválido

return fila->itens[fila->frente]; // Retorna o elemento da frente da fila

// Função para imprimir os elementos da fila void

imprimirFila(Fila* fila) { if (estaVazia(fila)) { // Verifica se a fila

está vazia printf("A fila está vazia\n"); // Exibe uma

mensagem de erro return; // Retorna sem fazer nada

printf("Fila: "); // Exibe uma mensagem indicando que os elementos da fila serão mostrados

for (int i = fila->frente; i != fila->fim; i = (i + 1) % TAMANHO_MAXIMO) { // Loop para percorrer os

elementos da fila printf("%d ", fila->itens[i]); // Exibe o elemento atual

printf("%d\n", fila->itens[fila->fim]); // Exibe o último elemento da fila

// Função principal para interagir com a fila

int main() {

Fila* fila = criarFila(); // Cria uma nova fila

int opcao, valor, quantidade;

do { printf("\n1. Enfileirar\n"); // Exibe opção para enfileirar um elemento

printf("2. Desenfileirar\n"); // Exibe opção para desenfileirar um ou mais elementos

printf("3. Mostrar elemento da frente\n"); // Exibe opção para mostrar o elemento da frente da
fila

printf("4. Imprimir fila\n"); // Exibe opção para imprimir os elementos da fila

printf("0. Sair\n"); // Exibe opção para sair do programa printf("Escolha uma

opção: "); // Solicita ao usuário que escolha uma opção scanf("%d",

&opcao); // Lê a opção escolhida pelo usuário

switch (opcao) { // Estrutura de controle switch para executar a opção escolhida pelo usuário

case 1: // Opção para enfileirar um elemento printf("Digite o valor a ser enfileirado: ");

// Solicita ao usuário que digite o valor scanf("%d", &valor); // Lê o valor a ser enfileirado

enfileirar(fila, valor); // Chama a função para enfileirar o valor na fila break; // Sai do

switch case 2: // Caso a opção escolhida seja 2

printf("Digite a quantidade de elementos a desenfileirar: "); // Solicita ao usuário a

quantidade de elementos a desenfileirar scanf("%d", &quantidade); // Lê a
quantidade de elementos a desenfileirar

desenfileirar(fila, quantidade); // Chama a função para desenfileirar a quantidade

especificada de elementos

break; // Sai do switch case 3: // Caso a opção escolhida seja 3

printf("Elemento da frente: %d\n", frente(fila)); // Exibe o elemento da frente da fila

break; // Sai do switch case 4: // Caso a opção escolhida seja 4

imprimirFila(fila); // Chama a função para imprimir os elementos da fila

break; // Sai do switch case 0: // Caso a opção escolhida seja 0

printf("Saindo...\n"); // Exibe uma mensagem indicando que o programa está saindo

break; // Sai do switch default: // Caso a opção escolhida seja diferente das anteriores

printf("Opção inválida\n"); // Exibe uma mensagem indicando que a opção é inválida

} while (opcao != 0); // Continua o loop até que o usuário escolha a opção de sair

free(fila); // Libera a memória alocada para a fila

return 0; // Retorna 0 indicando que o programa terminou com sucesso

}
 COMPARAÇÃO

1. Estrutura de dados:

Ambos os códigos implementam uma estrutura de fila, permitindo operações como inserção,
remoção e exibição de elementos.

2. Implementação:

O primeiro código utiliza uma abordagem com estrutura (struct) para representar a fila, enquanto o
segundo código usa uma estrutura de fila definida por typedef.

O primeiro código usa alocação dinâmica de memória para o array de elementos da fila (float
*dados), enquanto o segundo código usa um array estático (int itens[TAMANHO_MAXIMO])

3. Gerenciamento de Memória:

Ambos os códigos gerenciam a memória adequadamente, com o primeiro código utilizando malloc()
para alocar memória dinamicamente e o segundo código não requer alocação dinâmica de memória
para a fila em si.

4. Flexibilidade:

O meu código é um pouco mais flexível em termos de capacidade máxima da fila, pois utiliza uma
definição de macro (TAMANHO_MAXIMO) que pode ser facilmente modificada, enquanto o código
do professor requer uma mudança direta na declaração da fila.

5. Interface do Usuário:

Ambos os códigos fornecem uma interface de linha de comando para interação com a fila,
permitindo ao usuário inserir, remover e visualizar elementos da fila.

6. Saída de Mensagens:

A saída de mensagens é um pouco diferente entre os dois códigos devido à implementação

específica de cada um, mas ambos fornecem feedback adequado ao usuário durante as operações
na fila.

7. Estrutura do Código:

O meu código está organizado em uma única função main() que contém todas as operações da fila,
enquanto o código do professor divide as operações em funções separadas (por exemplo,
enfileirar(), desenfileirar(), etc.