C Programa de cadastro de uma oficina em C

joaovictormc · 4 de abril de 2020

Estou aprimorando um código antigo meu e to tentando adicionar novas funções nele, exibir todos os cadastros, alterar e excluir. Só que no meio disso esbarrei em alguns problemas:

1- na hora que vou realizar cadastros e depois faço a busca específica do cadastro ele está sobrescrevendo um cadastro anterior e misturando os dados

2- minha função emitir tudo só mostra um cadastro

3- não estou entendendo como posso fazer as funções alterar e excluir

O que está comentado são as coisa que não fiz ainda. Na função de emitir todas os fread comentado foram tentativas de fazer a emissão sem usar o while.

Vou deixar o que já fiz aqui em baixo

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


struct carro{

	char placa[10], marca[50], modelo[50], ano[10];
};

struct cliente{
	struct carro y;
	char nome[100], CPF[20], RG[20], endereco[200];
};

struct manutencao{

	char data[15], mecanico[50], itens[200], valor[50], placa[15];
};


void cabecalho();

void cadastrarCliente(struct cliente x, struct carro y);
void cadastarServ(struct manutencao z, struct carro y);
void buscarOrdem(struct carro y, struct cliente x, struct manutencao z);
void emitirTudo(struct carro y, struct cliente x, struct manutencao z);
//void alterarCad(struct carro y, struct cliente x, struct manutencao z);
//void excluirOrdem(struct carro y, struct cliente x, struct manutencao z);

int main()
{
    setlocale(LC_ALL, "portuguese");

	struct cliente x;
	struct carro y;
	struct manutencao z;
	int op, wo;

	do{
		cabecalho();
        printf("\t\t\t\t###########################################\n");
		printf("\t\t\t\t##\t1 - CADASTRAR CLIENTE            ##\n");
		printf("\t\t\t\t##\t2 - CRIAR ORDEM DE SERVIÇO       ##\n");
		printf("\t\t\t\t##\t3 - BUSCAR ORDEM DE SERVIÇO      ##\n");
        printf("\t\t\t\t##\t4 - MAIS OPÇÕES                  ##\n");
		printf("\t\t\t\t##\t5 - SAIR                         ##\n");
        printf("\t\t\t\t###########################################\n");
		printf("\t\t\t\t\tDIGITE UMA OPÇÂO --> ");
        scanf("%d", &op);


		switch(op)
		{
			case 1:
				cadastrarCliente(x, y);
				break;

			case 2:
				cadastrarServ(z, y);
				break;

			case 3:
			    buscarOrdem(y, x, z);
				break;

            case 4:
                    do
                    {
                        cabecalho();
                        printf("\t\t\t\t###########################################\n");
                        printf("\t\t\t\t##\t1 - EXIBIR TODAS AS ORDENS       ##\n");
                        printf("\t\t\t\t##\t2 - ALTERAR CADASTRO             ##\n");
                        printf("\t\t\t\t##\t3 - EXCLUIR ORDEM                ##\n");
                        printf("\t\t\t\t##\t4 - VOLTAR                       ##\n");
                        printf("\t\t\t\t###########################################\n");
                        printf("\t\t\t\t\tDIGITE UMA OPÇÃO -> ");
                        scanf("%d", &wo);

                        switch (wo)
                        {
                            case 1:
                                emitirTudo(y, x, z);
                                break;

                            case 2:
                                //alterarCad(y, x, z);
                                break;

                            case 3:
                                //excluirOrdem(y, x, z);
                                break;

                            case 4:
                                printf("\t\t\t\t\tVOLTANDO...");
                                Sleep(300);
                                break;

                            default:
                                printf("\t\t\t\t\tOPÇÃO INVÁLIDA!!!");
				                getch();
                                break;
                        }
                    } while (wo != 4);

                break;

			case 5:
				printf("\t\t\t\t\tSAINDO...\n");
				Sleep(400);
				break;

			default:
				printf("\t\t\t\t\tOPÇÃO INVÁLIDA!!!");
				getch();
				break;
		}
	}while(op != 5);
};



void cadastrarCliente(struct cliente  x,struct carro y){
	FILE *fp;
	FILE *f;


	fp = fopen("cliente.txt", "ab");
	f = fopen("carro.txt", "ab");
	if(fp == NULL){
		printf("\t\t\t\t\tNÃO FOI POSSÍVEL CRIAR O ARQUIVO!!\n");
	}
	else{
		do{
			cabecalho();
			fflush(stdin);
			printf("NOME DO CLIENTE: ");
			gets(x.nome);

			printf("CPF: ");
			gets(x.CPF);

			printf("RG: ");
			gets(x.RG);

			printf("ENDEREÇO: ");
			gets(x.endereco);

			fwrite(&x, sizeof(struct cliente),1,fp);


			printf("INFORME A PLACA DO CARRO: ");
			gets(y.placa);

			printf("MARCA DO CARRO: ");
			gets(y.marca);

			printf("MODELO: ");
			gets(y.modelo);

			printf("ANO DE FABRICAÇÃO: ");
			gets(y.ano);


			fwrite(&y, sizeof(struct carro), 1, f);
			fclose(f);
            fclose(fp);
			printf("DESEJA CONTINUAR REALIZANDO CADASTROS? [ S / N ]");

		}while(getch() == 's');
	}
}

void cadastrarServ(){
	FILE *fs;
	FILE *fp;
	struct manutencao z;
	struct carro y;
    char placa[15];
    int tam, i, w = 0;

	fs = fopen("manutenção.txt", "ab");
    fp = fopen("carro.txt", "r+b");

	if(fs == NULL){
		printf("\t\t\t\t\tNÃO FOI POSSÍVEL CRIAR O ARQUIVO!!\n");
	}
	else{
		do{
			cabecalho();
			fflush(stdin);
			printf("DIGITE A DATA DA MANUTENÇÃO: ");
			gets(z.data);

			printf("INFORME O MECÂNICO QUE FARA A MANUTENÇÃO: ");
			gets(z.mecanico);

			printf("ITENS QUE SERÃO UTILIZADOS NA MANUTEÇÃO: ");
			gets(z.itens);

			printf("VALOR TOTAL DO SERVIÇO: ");
			gets(z.valor);

            do
            {
                printf("DIGITE A PLACA: ");
                gets(placa);

                //PESQUISA DENTRO DO ARQUIVO SE A PLACA INFORMADA ESTÁ CADASTRADA
                fseek(fp, 0, SEEK_END);
                tam = ftell(fp)/sizeof(struct carro);
                rewind(fp);
                for(i = 0; i < tam; i++)
                {
                    fseek(fp, i* sizeof (struct carro), SEEK_SET);
                    fread(&y, sizeof(struct carro), 1, fp);

                    if (strcmp(placa, y.placa)== 0)
                    {
                        w = 1;
                        strcpy(z.placa, placa);
                    }
                }
                if(w == 0)
                {
                    printf("\nPLACA NÃO CADASTRADA!!\n");
                }
                fwrite(&z, sizeof(struct manutencao), 1, fs);
            }
            while(w != 1);

            fclose(fp);
            fclose(fs);

            printf("DESEJA CONTINUAR REALIZANDO CADASTROS? [ S / N ]");
        } while(getch() == 's');

    }

}

void buscarOrdem(struct carro y, struct cliente x, struct manutencao z)
{
    FILE *fp;
    FILE *fs;
    FILE *f;
    char placa[10];


    int j, t, v = 0;

    fp = fopen("cliente.txt", "r+b");
    fs = fopen("manutenção.txt", "r+b");
    f = fopen("carro.txt", "r+b");

    if(fp, fs, f == NULL)
    {
        printf("\t\t\t\t\tNÃO FOI POSSÍVEL ABRIR O ARQUIVO!!\n");
        getch();
    }
    else
    {
        cabecalho();
        fflush(stdin);
        do
        {
            printf("DIGITE A PLACA DO CARRO: ");
            gets(placa);

            //BUSCA A ORDEM DE SERVIÇO BASEADO NA PLACA INFORMADA
            fseek(f, 0, SEEK_END);
            t = ftell(f)/sizeof(struct carro);
            rewind(f);
            for(j = 0; j < t; j++){
                fseek(f, j* sizeof(struct carro), SEEK_SET);
                fread(&y, sizeof(struct carro), 1, f);
                
                if(strcmp(placa, y.placa)== 0){
                    v = 1;
                    strcpy(y.placa, placa);
                    //CASO A PLACA ESTIVER CADASTRADA, O PROGRAMA IRÁ IMPRIMIR
                    printf("MODELO: %s\n", y.modelo);
                    printf("MARCA: %s\n", y.marca);
                    printf("ANO DE FABRICAÇÃO: %s\n", y.ano);


                    fread(&x, sizeof(struct cliente), 1, fp);
                    printf("NOME DO CLIENTE: %s\n", x.nome);
                    printf("CPF: %s\n", x.CPF);
                    printf("RG: %s\n", x.RG);
                    printf("ENDEREÇO: %s\n", x.endereco);

                    fread(&z, sizeof(struct manutencao), 1, fs);
                    printf("DATA DE INÍCIO DA MANUTENÇÃO: %s\n", z.data);
                    printf("MECÂNICO: %s\n", z.mecanico);
                    printf("ITENS UTILIZADOS: %s\n", z.itens);
                    printf("VALOR FINAL: %s\n",z.valor);
                }
            }
            if(v == 0){
                printf("CARRO NÃO CADASTRADO!!\n\n");
            }
        }while(v != 1);
        fclose(f);
        fclose(fp);
        fclose(fs);
        getch();
    }

}

void emitirTudo(struct carro y, struct cliente x, struct manutencao z)
{
    FILE *fp;
    FILE *fs;
    FILE *f;
    int retorno, cont = 0;

    fp = fopen("cliente.txt", "r+b");
    fs = fopen("manutenção.txt", "r+b");
    f = fopen("carro.txt", "r+b");

    if (fp, fs, f == NULL) {
        printf("\t\t\t\t\tNÃO FOI POSSÍVEL ABRIR OS ARQUIVOS!!\n");
        getch();
    }
    else
    {
        retorno = fread(&x, sizeof(struct cliente), 1, fp);
        retorno = fread(&y, sizeof(struct carro), 1, f);
        retorno = fread(&z, sizeof(struct manutencao), 1, fs);
        while( retorno == 0 )
        {
            system("cls");
            cabecalho();
            cont++;
            //fread(&x, sizeof(struct cliente), 1, fp);
            printf("NOME DO CLIENTE: %s\n", x.nome);
            printf("CPF: %s\n", x.CPF);
            printf("RG: %s\n", x.RG);
            printf("ENDEREÇO: %s\n", x.endereco);
            //fread(&y, sizeof(struct carro), 1, f);
            printf("PLACA DO CARRO: %s\n", y.placa);
            printf("MODELO: %s\n", y.modelo);
            printf("MARCA: %s\n", y.marca);
            printf("ANO DE FABRICAÇÃO: %s\n", y.ano);
            //fread(&z, sizeof(struct manutencao), 1, fs);
            printf("DATA DO INÍCIO DA MANUTENÇÃO: %s\n", z.data);
            printf("MECÂNICO: %s\n", z.mecanico);
            printf("ITENS UTILIZADOS: %s\n", z.itens);
            printf("VALOR FINAL: %s\n",z.valor);
            retorno = fread(&x, sizeof(struct cliente), 1, fp);
            retorno = fread(&y, sizeof(struct carro), 1, f);
            retorno = fread(&z, sizeof(struct manutencao), 1, fs);
            printf("--------------------------------------------------------------------------\n\n\n");
        }
        fclose(fp);
        fclose(fs);
        fclose(f);
        getch();
    }
}

/*
void alterarCad(struct carro y, struct cliente x, struct manutencao z)
{
    FILE *fp;
    FILE *fs;
    FILE *f;
    char placa[10];
    int j, t, v = 0;

    fp = fopen("cliente.txt", "rb");
    f = fopen("carro.txt", "rb");
    fs = fopen("manutenção.txt", "rb");

    if (fp, fs, f == NULL) {
        printf("\t\t\t\t\tNÃO FOI POSSÍVEL ABRIR OS ARQUIVOS!!\n");
        getch();
    }
    else {
        cabecalho();
        fflush(stdin);

        do {
            printf("DIGITE A PLACA DO CARRO PARA ALTERAR O CADASTRO: ");
            gets(placa);

            fseek(f, 0, SEEK_END);
            t = ftell(f)/sizeof(struct carro);
            rewind(f);
            for(j = 0; j < t; j++){
                fseek(f, j* sizeof(struct carro), SEEK_SET);
                fread(&y, sizeof(struct carro), 1, f);
                if(strcmp(placa, y.placa)== 0){
                    v = 1;
                    strcpy(y.placa, placa);
                }
            }

            printf("DESEJA REALIZAR OUTRAS ALTERAÇÕES? [ S / N ]");
        }while(getch() == 's');
    }
}
*/

void cabecalho()
{
    system("cls");
    printf("\t\t\t########################################################\n");
    printf("\t\t\t##                                                    ##\n");
    printf("\t\t\t##     SISTEMA DE CADASTRO DE MANUTENÇÃO E VENDAS     ##\n");
    printf("\t\t\t##                                                    ##\n");
    printf("\t\t\t########################################################\n\n");
}

arfneto · 5 de abril de 2020

O problema inicial com seu programa é que não está considerando onde vai guardar essas coisas.

Deveria ter um cadastro de carros, um cadastro de clientes e um cadastro de servicos.

No entanto declarou somente um de cada e em main() e espera fazer todo o sincronismo usando os arquivos e read/write/seek/tell/rewind e tal. Isso pode funcionar mas vem com tantos problemas...

O problema clássico com isso é que tem que controlar duplicidade nos arquivos, pode ter que manter na ordem os registros, apagar fica difícil, coisas assim. E fica tudo lento. Claro que para os computadores e discos dos últimos 30 anos e para o volume de dados de uma oficina isso não é um problema.

A aproximação mais produtiva é usar uma estrutura de dados para gravar os cadastros direto na memória. Ao iniciar o programa você carrega os cadastros do disco para a memória. Ao terminar você grava de volta no disco.

Durante o uso você grava um registro do que acontece. Se costuma chamar de log ou journal ou pode chamar de registro de transações. A ideia é que se cair a força ou o programa tiver uma pane você possa abrir esse arquivo e ver o que foi feito mas não tinha sido gravado, e aí gravar no disco os dados e apagar esses registros. Quando inicia o programa você sabe que se esse arquivo existe e tem algo é porque o programa não terminou direito e você processa essas coisas pra ficar tudo certinho. É o se fazia nos velhos tempos.

Num primeiro momento esqueça isso e apenas crie um vetor para cada cadastro e copie do disco no início e grave no fim. E durante o programa use esses dados e não os do disco. Meu palpite.

Não misture menus e leitura com sua lógica. Isso transforma sua vida num inferno na hora de testar. Não dá pra imaginar ficar sentado digitando dados de cadastro a toa pa testar um programa.

Seu programa parece bem estruturado, mas é frágil e difícil de testar.

Compare com esse pequeno programa e veja se não acha mais legível do modo como vou tem mostrar


struct carro
{
	char placa[10];
	char marca[50];
	char modelo[50];
	char ano[10];
};
typedef struct carro Carro;

struct pessoa
{
	char nome[100];
	char CPF[20];
	char RG[20];
	char endereco[200];
	char tipo;
};
typedef struct pessoa Pessoa;

struct manutencao
{
	Pessoa* mecanico;
	Pessoa* cliente;
	Carro*  carro;

	char itens[200];
	char valor[50];
	char descricao[200];
};
typedef struct manutencao Servico;

// os cadastros sao colecoes dessas estruturas

struct c_carro
{
	int total;
	Carros carro[200];
};
typedef struct c_carro C_carros;

struct c_pessoas
{
	int total;
	Pessoas pessoa[200];
};
typedef struct c_carro C_pessoas;

struct c_servicos
{
	int total;
	Servico servico[200];
};
typedef struct c_servicos C_servicos;

int    cadastrarCliente(Pessoa* p, C_servicos* cadastro);
int    cadastarServ(Servico* servico, C_servicos* cadastro);
int    buscarOrdem(Carro* carro, Pessoa* cliente, C_Servicos cadastro);
int    emitirTudo(Carro* carro, Pessoa* cliente, C_Servicos cadastro);

int main(in argc, char** argv)
{
	C_carros   cad_c;
	C_pessoas  cad_p;
	C_servicos cad_s;

	const char* arq_carros = "carros.txt";
	const char* arq_pessoas = "pessoas.txt";
	const char* arq_servicos = "servicos.txt";

	FILE* f_carros;
	FILE* f_pessoas;
	FILE* f_servicos;

	return 0;

};	// main()

As rotinas recebem ponteiros com o endereco dos dados assim em main() eles estão atualizados.

Retornam um valor int que você pode usar pra testar se deu certo/

As estruturas tem nomes e descrições mais claras, eu acho. E os cadastros tem 200 de cada pra você testar antes de se preocupar com capacidades e tal.

Pense nisso.