C ler os dados tabulados de um arquivo txt e guardá-los na fila

mellosilvajp · 14 de fevereiro de 2022

Boa noite a todos.

Fazendo um trabalho pra faculdade, que consiste em criar um sistema de filas para uma banco, me deparei com uma dificuldade enorme em ler os dados tabulados de um arquivo txt e guardá-los na fila.

Alguém consegue me dar uma luz? Estou nisso há uma semana.

Acredito muito que o erro esteja na função lerArquivo. Agradeço desde já. Anexarei os arquivos txt que quero ler.

Código:

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

typedef struct cliente{

    char codigo[5];
    char nome[40];
    struct cliente *prox;
}Cliente;


void menu(){

    printf("=======================");
    printf("OLA, O QUE voce DESEJA?");
    printf("=======================");
    printf("\n");
    printf("ENFILEIRAR [1]");
    printf("\n");
    printf("DESENFILEIRAR [2]");
    printf("\n");
    printf("EXIBIR [3]");
    printf("\n");
    printf("BUSCAR [4]");
    printf("\n");
    printf("ENCERRAR PROGRAMA [5]");
    printf("\n");

}

Cliente* iniciaFila(){
    return NULL;
}

Cliente* enfileirar(Cliente* fila, char codigo[5], char nome[40]){
    Cliente* novo = malloc(sizeof(Cliente));
    strcpy(novo->codigo, codigo);
    strcpy(novo->nome, nome);
    novo->prox = NULL;
    Cliente* aux = fila;
    if(fila == NULL){
        return novo;
    }else{
        while (aux->prox != NULL){
            aux = aux->prox;
        }
        aux->prox = novo;
        return fila;
    }
}

Cliente* desenfileirar(Cliente *fila){
    Cliente *aux = fila;
    Cliente *prox = NULL;
    prox = aux->prox;
    fila = prox;
    free(aux);
    return fila;
}

void imprimeFila(Cliente *fila){
    Cliente *aux = fila;
    while (aux != NULL){
        printf("%s, %s\n", aux->codigo, aux->nome);
        aux = aux->prox;
    }
}

void chama_cliente(Cliente* filaPreferencial, Cliente* filaNormal){
    Cliente* aux = filaPreferencial;
    if(aux == NULL){
        filaNormal = desenfileirar(filaNormal);
    }
    else{
        filaPreferencial = desenfileirar(filaPreferencial);
    }

}

void lerArquivo(char nomeArquivo[20], Cliente* fila){
    
    FILE *arquivo; 
    arquivo = fopen(nomeArquivo,"r");
    while (0){
        char codigo[5];
        char nome[40];
        fscanf(arquivo, "%[^,],%[^,]\n", codigo, nome);
        if(feof(arquivo)){
            break;
        }
        fila = enfileirar(fila, codigo, nome );
    }

    fclose(arquivo);
}

void gravarArquivo(char nomeArquivo[20], Cliente* fila){
    FILE *arquivo;
    Cliente* aux = fila;
    arquivo = fopen(nomeArquivo,"w");
    while(aux!=NULL){
        fprintf(arquivo, "%s,%s\n", aux->codigo, aux->nome);
        aux = aux->prox;
    }
    fclose(arquivo);}


int main(){

    menu();
    Cliente *filaNormal = iniciaFila();
    Cliente *filaPreferencial = iniciaFila();
    int escolha;
    scanf("%d", &escolha);

    lerArquivo("clientes.txt", filaNormal);
    lerArquivo("clientesPreferencial.txt", filaPreferencial);

    if (escolha == 1){
        char nome[40];
        char codigo[5];
        char preferencial;
        
        printf("Digite o nome do cliente: ");
        scanf(" %[^\n]", nome);
        printf("Digite o codigo do cliente: ");
        scanf(" %[^\n]", codigo);
        printf("É um cliente preferencial? [S/N]");
        scanf(" %c", &preferencial);

        if(preferencial == 83|| preferencial == 115){
            filaPreferencial = enfileirar(filaPreferencial, codigo, nome);
                
        }
        else{
            filaNormal = enfileirar(filaNormal, codigo, nome);
        }
    }

    else if (escolha == 2){
        chama_cliente(filaPreferencial, filaNormal);
    }

    else if (escolha == 3){
        imprimeFila(filaPreferencial);
        imprimeFila(filaNormal);
    }

    gravarArquivo("clientesPreferencial.txt", filaPreferencial);
    gravarArquivo("clientes.txt", filaNormal);

    system("pause");
    return 0;
}

clientes.txt
clientesPreferencial.txt

IzeraXD · 14 de fevereiro de 2022

@mellosilvajp

Ainda estou Estudando Aquivos Txt
Eu fiz um código que acredito que vá te ajudar são varias formas de ler linha e guarda-la em uma variável

acredito que se você estudar o código vai te ajudar

# include <stdio.h>
# include <stdlib.h>
# include <math.h>
// Requerimento Especial
# include <string.h>  
/* */
// prototipagens

int main (void) {
	
	printf(" O Proposito desse programa é Ler  As Linha do Arquivo TxT e Gravalas em Variaveis  \n ");
	printf(" Assim que você rodou Crio o Arquivo Texto no Diretorio Pode Conferir La    \n  ");
	printf(" . §referencia Temos  \n ");
	printf(" 0 Linha = Pokemon | 1 Linha = Megaman | 2 Linha = Megamente| 3 Linha = Kirby |  \n ");
	void zr4_Criararquivotxt();	
	zr4_Criararquivotxt();
	void zr4_F_Read_Line();	
	zr4_F_Read_Line();
	void zr4_F_Read_ALL_Lines();	
	zr4_F_Read_ALL_Lines();
	void zr4_F_Read_Det_Line();	
	zr4_F_Read_Det_Line();
	void zr4_F_Read_Line_A_M_Array();	
	zr4_F_Read_Line_A_M_Array();
	void zr4_F_Read_Det_Line_A_M_Array();	
	zr4_F_Read_Det_Line_A_M_Array();
	
	printf(" \n \n ---------------- Mano VI ---------------- \n");
	// Mano 6 Passando Parametros
	void zr4_F_Read_Det_Line_A_M_Array_Para();
	int zr4_pjj=1;
	printf("\n Mano VI: voce quer ler qual linha? \n");
	scanf("%d",&zr4_pjj);
	zr4_F_Read_Det_Line_A_M_Array_Para(zr4_pjj);

	return(0);
};

//  ------------------------------------- zr4_F_Read_Line: Mano 0  -----------------------------------------------------------
void zr4_A(void){
// ALLLLLLLLLLLLLLLLLL  
};

//  ------------------------------------- zr4_Criararquivotxt -----------------------------------------------------------
void zr4_Criararquivotxt(void){
	//
	// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
	FILE *zr4_ponteiro;
	char hh[] ="pokemon"; 
	char hj[] ="Megaman";
	char hjf[] ="Megamente";
	char hjfg[] ="Kyrbi";
	// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX Abrindo e lendo com o r o texto
	// Caso não tenha não e! o foco
	// 
	//Criar O osso arquivo TXT e Gravar As Linhas Nele  
	zr4_ponteiro = fopen("02,1 Lendo Aquivos Textos A.txt","w");
	fprintf(zr4_ponteiro, "%s \n" ,hh);
	fprintf(zr4_ponteiro, "%s \n" ,hj);
	fprintf(zr4_ponteiro, "%s \n" ,hjf);
	fprintf(zr4_ponteiro, "%s \n" ,hjfg);
	fclose(zr4_ponteiro); // fechando
};

/* */

//  ------------------------------------- zr4_F_Read_Line: Mano I  -----------------------------------------------------------
void zr4_F_Read_Line(void){
	// Mano III ( Copia\Ler UMA LINHA !!! )  e ( Gravar NUm Array  !!! ) 
	FILE *zr4_ponteiro;
	char zr4_Rline[120];
	int p=0;
	printf(" ---------------- Mano I ---------------- \n");
	zr4_ponteiro = fopen("02,1 Lendo Aquivos Textos A.txt","r");
	
	fgets(zr4_Rline,120, zr4_ponteiro);
	printf("A primeira Linha e! = %s \n ",zr4_Rline);
	printf("A primeira Linha e! nide =  \n ");
	fclose(zr4_ponteiro); 
	fflush(zr4_ponteiro);
	printf("Limpando  Tudo \n ");
	for( p=0; p<6  ; p++){
		zr4_Rline[p] = 0;
		printf(" %s .",&zr4_Rline[p]); 
    };
};

//  ------------------------------------- zr4_F_Read_ALL_Lines: Mano II -----------------------------------------------------------

void zr4_F_Read_ALL_Lines(void){
//  -------------------------------------Mano II -----------------------------------------------------------
	// Leia Varias Linhas Tudo  Uma Linha de cd ves
	// Abrindo e lendo com o r o texto
	FILE *zr4_ponteiro;
	char zr4_Rline[120];
	int p=0;
	printf(" \n ---------------- Mano II ---------------- \n");
	zr4_ponteiro= fopen("02,1 Lendo Aquivos Textos A.txt","r");
    printf("--- Todas As Linhas --- \n");

	while(fgets(zr4_Rline,120, zr4_ponteiro) != NULL) {
		printf("%s",zr4_Rline);
		
	}
	fclose(zr4_ponteiro); // fechando
	fflush(zr4_ponteiro);  
};

//  ------------------------------------- zr4_F_Read_Det_Line: Mano III  -----------------------------------------------------------



void zr4_F_Read_Det_Line(void){
	//  -------------------------------------Mano III -----------------------------------------------------------
	// Mano III ( Ler Determinada LINHA !!! )  e ( Gravar NUm Array !!! )
	// Leia Varias Linhas Tudo  Uma Linha de cd ves
	// Abrindo e lendo com o r o texto
	FILE *zr4_ponteiro;
	char zr4_Rline[120]; // Varivael Goblal
	int p=0;
	int zr4_pzz=0; // zr4_pjj contador do mano III p contador do mano IV 
	int zr4_pjj=0;

	printf(" \n ---------------- Mano III ---------------- \n");
	zr4_ponteiro = fopen("02,1 Lendo Aquivos Textos A.txt","r");
    printf("voce quer ler qual linha? \n");
	scanf("%d",&zr4_pjj);
	for( p=0 ; p<=zr4_pjj ; p++ ){
        printf("%d.",p);
		if ( p==zr4_pjj ){
			fgets(zr4_Rline,120, zr4_ponteiro);
			printf(" voce encontrou = %s",zr4_Rline);
			break;
		}else{ 
			 	fgets(zr4_Rline,120, zr4_ponteiro);
				printf(".");
			};
		 
	};
	fclose(zr4_ponteiro); // fechando
	fflush(zr4_ponteiro);  
};

//  ------------------------------------- zr4_F_Read_Line_A_M_Array: Mano IV  -----------------------------------------------------------
void zr4_F_Read_Line_A_M_Array(void){
	// Mano III ( Ler UMA LINHA !!! )  e ( Gravar NUm Array Organizado !!! )   txt 4 organizado indice a indice
	// Variaveis 
	FILE *zr4_ponteiro;
	char *zr4_Rline =(char*) calloc(120,sizeof(char)); // Varivael Goblal
	char *zr4_CpyRline =(char*) calloc(120,sizeof(char)); 
	char *zr4_ArrayA =(char*) calloc(120,sizeof(char)); // mano IV organizado
	int p=0;
	//Tipo da variavel *p = (Tipo da variavel*)  malloc ( quantidade*sizeof(Tipo da variavel));
	printf(" \n ---------------- Mano IV ---------------- \n");
	zr4_ponteiro = fopen("02,1 Lendo Aquivos Textos A.txt","r");
	scanf("%*c");
	fgets(zr4_Rline,120,zr4_ponteiro);
	printf("%s",zr4_Rline);
    strcpy(zr4_CpyRline, zr4_Rline);
    printf("zr4_CpyRline[0] = %s ",&zr4_CpyRline[0]);
    printf("zr4_CpyRline[1] = %s ",&zr4_CpyRline[1]);
    printf("zr4_CpyRline[2] = %s ",&zr4_CpyRline[2]);
    printf("zr4_CpyRline[3] = %s ",&zr4_CpyRline[3]);
    
    for( p=0; *(&zr4_CpyRline[p]) != '\n' ; p++ ){
        strncpy(&zr4_ArrayA[p],&zr4_CpyRline[p],1);
        printf("una letra = %s \n",&zr4_ArrayA[p]);
    };
	fclose(zr4_ponteiro); 
	fflush(zr4_ponteiro);
	
	// free();
	free(zr4_Rline);
	free(zr4_CpyRline);
	free(zr4_ArrayA);
	
	printf("Limpando  Tudo \n ");
	
	
};

//  ------------------------------------- zr4_F_Read_Det_Line_A_M_Array: Mano V  -----------------------------------------------------------

void zr4_F_Read_Det_Line_A_M_Array(void){
	
	FILE *zr4_ponteiro;
	char *zr4_Rline =(char*) calloc(120,sizeof(char)); // Varivael Goblal
	char *zr4_CpyRline =(char*) calloc(120,sizeof(char)); 
	char *zr4_ArrayA =(char*) calloc(120,sizeof(char)); // mano IV organizado
	
	int p=0;  
	int zr4_pjj=0;
	int zr4_pzz=0;

	printf(" \n ---------------- Mano V ---------------- \n");
	
	zr4_ponteiro = fopen("02,1 Lendo Aquivos Textos A.txt","r");
    printf("voce quer ler qual linha? \n");
	scanf("%d",&zr4_pjj);
	for( p=0 ; p<=zr4_pjj ; p++ ){
        printf("%d.",p);
		if ( p==zr4_pjj ){
			fgets(zr4_Rline,120, zr4_ponteiro);
			printf(" voce encontrou = %s",zr4_Rline);
			strcpy(zr4_CpyRline, zr4_Rline);
    		for( zr4_pzz=0; *(&zr4_CpyRline[zr4_pzz]) != '\n' ; zr4_pzz++){
        		strncpy(&zr4_ArrayA[zr4_pzz],&zr4_CpyRline[zr4_pzz],1);
        		printf(" %s. ",&zr4_ArrayA[zr4_pzz]);
    		};
			// Vizualição
			break;
		}else{ 
			 	fgets(zr4_Rline,120, zr4_ponteiro);
				printf(".");
			};
	}
	fclose(zr4_ponteiro); // fechando
	free(zr4_Rline);
	free(zr4_CpyRline);
	free(zr4_ArrayA);  
};

//  ------------------------------------- zr4_F_Read_Det_Line_A_M_Array: Mano VI  -----------------------------------------------------------
	// Mano 6 Passando Parametros
	/* - - - - Requerimentos : Como  Usar ?- - - - - - - - 
	1--> Prototipagem :  void zr4_F_Read_Det_Line_A_M_Array_Para();         // Coloque Perto/Depos das Bibliotecas
	2--> Copie Fun�ao Abaixo e Coloque e seu algoritmo 
	3--> Declare a variavel : int zr4_pjj=1;                               // onde for coviniente na main
	4--> Chame a Fun�ao : zr4_F_Read_Det_Line_A_M_Array_Para(zr4_pjj);    // onde for coviniente na main
     */
void zr4_F_Read_Det_Line_A_M_Array_Para(int zr4_pjj){
	
	FILE *zr4_ponteiro;
	char *zr4_Rline =(char*) calloc(120,sizeof(char)); // Varivael Goblal
	char *zr4_CpyRline =(char*) calloc(120,sizeof(char)); 
	char *zr4_ArrayA =(char*) calloc(120,sizeof(char)); // Mano IV organizado
	
	int p=0,zr4_pzz=0;  
	// int zr4_pjj;
	// printf(" \n ---------------- Mano VI ---------------- \n");
	
	zr4_ponteiro = fopen("02,1 Lendo Aquivos Textos A.txt","r");
	for( p=0 ; p<=zr4_pjj ; p++ ){
        printf("%d.",p);
		if ( p==zr4_pjj ){
			fgets(zr4_Rline,120, zr4_ponteiro);
			printf(" voce encontrou = %s",zr4_Rline);
			strcpy(zr4_CpyRline, zr4_Rline);
    		for( zr4_pzz=0; *(&zr4_CpyRline[zr4_pzz]) != '\n' ; zr4_pzz++){
        		strncpy(&zr4_ArrayA[zr4_pzz],&zr4_CpyRline[zr4_pzz],1);
        		printf(" %s. ",&zr4_ArrayA[zr4_pzz]);
    		};
			// Vizualição
			break;
		}else{ 
			 	fgets(zr4_Rline,120, zr4_ponteiro);
				printf(".");
			};
	};
	fclose(zr4_ponteiro); // fechando
	free(zr4_Rline);
	free(zr4_CpyRline);
	free(zr4_ArrayA);  
};

arfneto · 14 de fevereiro de 2022

15 horas atrás, mellosilvajp disse:

em ler os dados tabulados de um arquivo txt e guardá-los na fila

Note que são duas coisas distintas então poderia (deveria) escrever e testar em separado

15 horas atrás, mellosilvajp disse:

erro esteja na função lerArquivo. Agradeço desde já. Anexarei os arquivos txt que quero ler

Seus arquivos tem 3 linhas cada um. Não seria mais simples postar aqui mesmo ao invés de esperar que alguém faça um download de arquivos desconhecidos?

Compare:

clientes.txt

abcd,joao,
lkjh,jose,

clientesPreferencial (1).txt

afcd,ana,
uytq,leticia,

Seu programa destrói os arquivos originais ao regravar sempre na saída. Acho que sabe que não é uma boa ideia. Mude isso. Ao menos nos seus testes. Ao menos no forum para não enfurecer quem rodar seu programa e descobrir que o arquivo se foi ao testar.

De volta ao código

Seu programa tem muitos (muitos mesmo) dos "erros" ou práticas menos boas que parecem ser norma de todos os programas que vejo aqui. Isso deve ser pela maneira que ensinam isso hoje.

Não é uma maneira produtiva de escrever. Muito disso sequer seria permitido em escolas ou empresas. E só vai fazer você perder tempo testando.

Sugiro muito mudar isso tudo.

Eis algumas das coisas que acontecem em seu código

Nunca escreva um programa interativo. Não vai aprender nada. Não vai ganhar nada. Escreva e teste todas as funções. DEPOIS de tudo testado coloque a parte interativa. isso inclui claro o eventual menu.
Ao usar scanf() ou alguma função da família, como fscanf() entenda que ela retorna um valor. E teste. É ingênuo deixar o programa seguir sem testar. TESTE sempre. Para 5 especificadores --- aquelas coisas com % na frente e que não tem um asterisco nem outro %, como "%d %d %f %f %d" scanf() pode ler de 0 a 5 itens ou dar erro e retornar -1. Então teste o retorno que vai estar entre -1 e 5...
Não misture entrada de dados ou formatação com a apresentação dos dados ou a lógica do programa, Isso é um desastre para manutenção e desenvolvimento
Um printf() de 6 linhas é muito, mas muito melhor que 6 printf() de 1 linha. E se só vai mostrar o texto puts() é ainda melhor e dezenas de vezes mais rápido que uma série de printf().
Não use system() para nada. Não estará fazendo nada. Não há praticamente nada que possa fazer com system() que não possa fazer em C ou C++. system() foi escrita em C e o sistema quase todo também. E em geral é proibido em empresas e escolas afinal: é um risco grande de segurança. E se tem algo que você não possa inicialmente fazer em C ou C++ talvez não deva mesmo fazer.
main() deve ser a primeira função de seu programa. Se possível em um arquivo separado. Há muitas razões para isso, mas em especial vai gostar de começar a ler seus programas e os de outros a partir de main() E a partir do início do texto. Ao mesmo tempo.
evite retornar void de funções: em geral é um desperdício. Muitas vezes um erro. Use argumentos nas funções, e retorne algo delas.
Ao usar uma estrutura de dados como uma lista, uma pilha ou fila entenda que ela é um container e nada tem a ver com os dados. Não misture NUNCA os dados com a estrutura porque só via complicar tudo. Em especial vai ficar muito mais difícil aproveitar a estrutura em outros programas, e essa é toda a razão de escrever isso.

Mais sobre o código

typedef struct cliente
{
    char            codigo[5];
    char            nome[40];
    struct cliente* prox;
} Cliente;

Não escreva assim. Como eu disse acima não deve misturar os dados com a fila. Escreva e teste em separado. Usou uma lista ligada para representar a fila. Só que está tudo junto. No seu próximo programa de lista vai ser uma lista de que? Aquela de livros? A playlist clássica? A fila do consultório? Aquele exercício inevitável da agenda? Se escrever assim não vai ser fácil reaproveitar.

Se esse não é seu primeiro programa com listas já sabe que eu estou certo...

Sobre Cliente

typedef struct
{
    char codigo[5];
    char nome[40];

} Cliente;

Esse é o dado: Cliente.

Nada tem a ver com a fila

Sobre o menu

void menu()
{
    printf("=======================");
    printf("OLA, O QUE voce DESEJA?");
    printf("=======================");
    printf("\n");
    printf("ENFILEIRAR [1]");
    printf("\n");
    printf("DESENFILEIRAR [2]");
    printf("\n");
    printf("EXIBIR [3]");
    printf("\n");
    printf("BUSCAR [4]");
    printf("\n");
    printf("ENCERRAR PROGRAMA [5]");
    printf("\n");
}

Não escreva assim. É óbvio que o menu vai ser seguido por uma leitura e uma decisão para tratar a opção. Então faça o óbvio e retorne a opção.

int menu();

Sobre o printf():

Não escreva desse jeito. Essa opção


    printf("\
=======================\
OLA, O QUE voce DESEJA?\n\
=======================\n\
ENFILEIRAR [1]\n\
DESENFILEIRAR [2]\n\
EXIBIR [3]\n\
BUSCAR [4]\n\
\n\
ENCERRAR PROGRAMA [5]\n");
}

é dezenas de vezes mais rápida.

E é muito mais fácil de ler e alinhar.

Prefira

    puts("\
=======================\
OLA, O QUE voce DESEJA?\n\
=======================\n\
ENFILEIRAR [1]\n\
DESENFILEIRAR [2]\n\
EXIBIR [3]\n\
BUSCAR [4]\n\
\n\
ENCERRAR PROGRAMA [5]\n");

Que é ainda mais rápido.

Use um header - cabeçalho

main() deve ser a primeira função de seu programa. Se possível em um arquivo separado.

Escreva em torno dos dados.

Isso leva a programas que muitas vezes rodam certo já na primeira vez.

Seu dado é uma fila. E não o cliente. A fila é de clientes.

Mas não tem fila no programa. Onde está esse dado? Está espalhado pelo código. Não escreva assim. Só vai trabalhar MUITO mais.

EXEMPLOS

Cliente* iniciaFila() { return NULL; }

Não. iniciaFila() deve retornar o endereço de uma fila nova, vazia. Nunca um ponteiro para Cliente. Seria algo como:

    Fila* iniciaFila();

E

Cliente* enfileirar(
    Cliente* fila, char codigo[5], char nome[40]);

Esse é mais interessante: você não pode passar os campos 1 a 1. Não faz sentido nenhum. E se fossem 30? E cada vez que mudar um vai mudar a função em todo lugar? Para que a struct então?

No mínimo escreva

Cliente* enfileirar( Cliente* novo, Cliente* fila);

Porque o que você quer é inserir um novo cliente na fila.

Mas não deve passar os dados assim. Não vai enfileirar um Cliente. Nada tem a ver com a fila. Vai enfileirar um nó na fila e o nó tem um endereço do dado, que pode ser qualquer coisa, por exemplo um Cliente*. Assim poderá usar essas funções a vida toda.

O que seria uma fila?

A fila tem um começo, um fim, um tamanho. E tem os nós, os registros, os caras que estão na fila. Não seria

typedef struct
{
    Node*  ini;
    Node*  fim;
    size_t tamanho;

} Fila;

Seria.

E um tal Node seria o que? Poderia ser

typedef struct st_node
{
    Dado*           info;
    struct st_node* prox;

} Node;

Sim. Poderia.

E o que é info? É um ponteiro para o dado. Em geral se usa void* mesmo, para ficar mais flexível: um ponteiro para qualquer coisa.

E assim a fila podia ser

typedef struct st_node
{
    Dado*           info;
    struct st_node* prox;

} Node;

typedef struct
{
    Node*  ini;
    Node*  fim;
    size_t tamanho;

} Fila;

E assim não tem nenhuma referência a cliente.

Mas se acrescentar uma linha lá na definição do tal Cliente....

typedef struct st_cl
{
    char codigo[5];
    char nome[40];
    struct st_cl* prox;

} Cliente;

typedef Cliente Dado;

Agora a conta fecha e já pode compilar o código da fila. Para o próximo uso apenas mude essa linha: o typedef que diz qual é o dado.

Espero que tenha entendido.

Exemplo: reordenando seu código

Esse seria um ponto de partida usando seu código e o que eu mostrei aqui. A fila é uma fila. Tem seu código em fila.c e as funções em fila.h

fila.h

#include "v0.h"

typedef struct st_node
{
    Dado*           info;
    struct st_node* prox;

} Node;

typedef struct
{
    Node*  ini;
    Node*  fim;
    size_t tamanho;

} Fila;

Fila* apagaF(Fila*);
Fila* iniciaF();
int   insereF(Dado*, Fila*);
Dado* retiraF(Fila*);
int   imprimeF(Fila*);

Um esqueleto de fila.c para poder compilar:

#include "fila.h"

Fila* apagaF(Fila* fila) { return NULL; }
Fila* iniciaF() { return NULL; }
int insereF(Dado* dado, Fila* fila) { return 0; }
Dado* retiraF(Fila* fila) { return NULL; }
int imprimeF(Fila* f) { return 0; }

E o Cliente?

As definições em Cliente.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct st_cl
{
    char          codigo[5];
    char          nome[40];
    struct st_cl* prox;

} Cliente;

typedef Cliente Dado;

Cliente* iniciaFila();
Cliente* enfileirar(
    Cliente* fila, char codigo[5], char nome[40]);
Cliente* desenfileirar(Cliente* fila);
void     imprimeFila(Cliente* fila);
void     chama_cliente(
        Cliente* filaPreferencial, Cliente* filaNormal);

void lerArquivo(char nomeArquivo[20], Cliente* fila);
void gravarArquivo(char nomeArquivo[20], Cliente* fila);

int menu();

As funções como você escreveu, em Cliente.c

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

#include "v0.h"

int menu()
{
    puts("\
=======================\
OLA, O QUE voce DESEJA?\n\
=======================\n\
ENFILEIRAR [1]\n\
DESENFILEIRAR [2]\n\
EXIBIR [3]\n\
BUSCAR [4]\n\
\n\
ENCERRAR PROGRAMA [5]\n");

    return 0;
}

Cliente* iniciaFila() { return NULL; }

Cliente* enfileirar(
    Cliente* fila, char codigo[5], char nome[40])
{
    Cliente* novo = malloc(sizeof(Cliente));
    strcpy(novo->codigo, codigo);
    strcpy(novo->nome, nome);
    novo->prox   = NULL;
    Cliente* aux = fila;
    if (fila == NULL) { return novo; }
    else
    {
        while (aux->prox != NULL) { aux = aux->prox; }
        aux->prox = novo;
        return fila;
    }
}

Cliente* desenfileirar(Cliente* fila)
{
    Cliente* aux  = fila;
    Cliente* prox = NULL;
    prox          = aux->prox;
    fila          = prox;
    free(aux);
    return fila;
}

void imprimeFila(Cliente* fila)
{
    Cliente* aux = fila;
    while (aux != NULL)
    {
        printf("%s, %s\n", aux->codigo, aux->nome);
        aux = aux->prox;
    }
}

void chama_cliente(
    Cliente* filaPreferencial, Cliente* filaNormal)
{
    Cliente* aux = filaPreferencial;
    if (aux == NULL)
    {
        filaNormal = desenfileirar(filaNormal);
    }
    else
    {
        filaPreferencial = desenfileirar(filaPreferencial);
    }
}

void lerArquivo(char nomeArquivo[20], Cliente* fila)
{
    FILE* arquivo;
    arquivo = fopen(nomeArquivo, "r");
    while (0)
    {
        char codigo[5];
        char nome[40];
        fscanf(arquivo, "%[^,],%[^,]\n", codigo, nome);
        if (feof(arquivo)) { break; }
        fila = enfileirar(fila, codigo, nome);
    }

    fclose(arquivo);
}

void gravarArquivo(char nomeArquivo[20], Cliente* fila)
{
    FILE*    arquivo;
    Cliente* aux = fila;
    arquivo      = fopen(nomeArquivo, "w");
    while (aux != NULL)
    {
        fprintf(arquivo, "%s,%s\n", aux->codigo, aux->nome);
        aux = aux->prox;
    }
    fclose(arquivo);
}

E sua versão de main em main.c por exemplo

#include "v0.h"
#include "fila.h"

int main()
{
    menu();
    Cliente* filaNormal       = iniciaFila();
    Cliente* filaPreferencial = iniciaFila();
    int      escolha;
    scanf("%d", &escolha);

    lerArquivo("clientes.txt", filaNormal);
    lerArquivo(
        "clientesPreferencial.txt", filaPreferencial);

    if (escolha == 1)
    {
        char nome[40];
        char codigo[5];
        char preferencial;

        printf("Digite o nome do cliente: ");
        scanf(" %[^\n]", nome);
        printf("Digite o codigo do cliente: ");
        scanf(" %[^\n]", codigo);
        printf("É um cliente preferencial? [S/N]");
        scanf(" %c", &preferencial);

        if (preferencial == 83 || preferencial == 115)
        {
            filaPreferencial =
                enfileirar(filaPreferencial, codigo, nome);
        }
        else
        {
            filaNormal =
                enfileirar(filaNormal, codigo, nome);
        }
    }

    else if (escolha == 2)
    {
        chama_cliente(filaPreferencial, filaNormal);
    }

    else if (escolha == 3)
    {
        imprimeFila(filaPreferencial);
        imprimeFila(filaNormal);
    }

    gravarArquivo(
        "clientesPreferencial.txt", filaPreferencial);
    gravarArquivo("clientes.txt", filaNormal);

    system("pause");
    return 0;
}

Conclusão

Se leu até aqui já deve ter percebido que em fila.c tem uma lista genérica que pode usar em todos os seus programas. Apenas mude o typedef para indicar o que é o dado.

Suas funções de cliente devem ser reescritas para usar a fila. É muito mais fácil. E tem a vantagem de estar escrevendo como o mundo inteiro faz mas aparentemente a escola não ensina.

Entenda que se resolver usar outra coisa para tratar os clientes, como um vetor, não vai mexer na fila. Apenas deixa de incluir os arquivos

E se for usar a fila para outra coisa apenas inclui no outro exercício o tal fila.h/fila.c. Não precisa mudar uma única linha.

mellosilvajp · 14 de fevereiro de 2022

@arfneto caraca cara, agradeço demais por abdicar tanto tempo pra me ajudar aqui. Muito obrigado mesmo cara.
Estou aprendendo C há pouco tempo, então estou tendo muita dificuldade em coisas básicas ainda, mas sem dúvidas seu comentário serviu muito mais do que muitas aulas minhas na faculdade. Vou dar uma analisada passo a passo sobre o que você me falou, mas novamente, agradeço demais

@IzeraXD valeu irmão. Agradeço muito