Brenda Karoliny

Como posso excluir o registro que o usuário digita? exemplo: matricula identificação 1 15 2 15 1 30 3 50 Esses registros estão em um arquivo binario Estou pedindo para o usuário digitar o que ele deseja excluir, supondo que ele digitou a matricula 1 e a identificação 15. Dai quando vai excluir, exclui todos os registros que tem a matricula 1 ou a identificação 15 Esta ficando assim: matricula identificação 3 50 e deveria excluir apenas um matricula identificação 2 15 1 30 3 50

Estou fazendo um trabalho da faculdade onde faço cadastro de modelos, porém se a modelo estiver pesando meno que 40 kg e mais que 90 kg, o usuário poderá digitar novamente ou excluir cadastro. estou com dúvida nessa parte onde estar na LEDADOS coloquei o programa para se baixado depois deste código /* Objetivo: Controlar o cadastro de modelos Entrada: Número do registro, nome completo e peso da candidata, se dejeta continuar cadastrando modelos sim ou não, gravar dados(arquivo tipo texto ou binário), consultar, e encerrar Saída: Gravar todas as informações das canditadas em arquivo texto ou binário, mostrar todas as informações de todas as cantidatas com os pesos fornecidos pelo usuario */ #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_MODELOS 200 #define MIN_NUMCANDIDATA 400 #define MAX_NUMCANDIDATA 100000 #define TAM_CANDIDATA 120 #define MAX_PESO 90 #define MIN_PESO 40 typedef struct ConcursoModelo{ int registro; char nomeCandidata[TAM_CANDIDATA]; float pesoCandidata; }ConcursoModelo; //Prototipos int leInt(char *msn) ; int leValidaInt(char *msn, char *msnErro, int valorMin, int valorMax); float leFloat(char *msn); float leValidaFloat(char *msn, char *msnErro, float valorMin, float valorMax); void leValidaTexto(char *msn, char *msnErro, char *texto, int tam); void tiraTerminador(char *texto); char leValidaOpcao(char *msn, char *msnErro, char *opcoesValidas); int leDados(ConcursoModelo *concursoModelo,int qtdModelos); int verificaRepetido(ConcursoModelo *concursoModelo,int qtdModelos); void transformaMinusculo(char *nome); void gravaDados(ConcursoModelo *concursoModelo,int qtdModelos); void consultaDados(ConcursoModelo *concursoModelo,int qtdModelos); int main() { ConcursoModelo concursoModelo[MAX_MODELOS]; char simNao; int qtdModelos=0, opcao,aux=0; do{ system("cls"); simNao = leValidaOpcao(" Informe a opcao desejada para cadastrar modelos:\n S-> Sim \n N-> NAO\n","Opção inválido! Digite novamente:\n", "SN"); switch(simNao){ case 'S':{ if(qtdModelos < MAX_MODELOS){ if(aux!=1){ aux=leDados(concursoModelo,qtdModelos); qtdModelos++; }else{ printf("Cadastro cancelado"); aux=0; } }else{ printf("Limite de cadastro de modelos alcancados!"); } break; } case 'N': if(qtdModelos == 0){ printf("Nenhuma modelo foi cadastrada"); getch(); }else{ printf("Cadastro de modelos encerrado!"); getch(); } break; } if(qtdModelos >= MAX_MODELOS){ printf("Foi cadastrado: %d modelos",qtdModelos); getch(); } }while(simNao != 'N' && qtdModelos < MAX_MODELOS); if(qtdModelos != 0){ do{ system("cls"); opcao = leValidaInt("1 >> Gravar todas as informações\n 2 >> Consultar peso \n 3 >> Encerrar\n Digite a opcao desejada: ", "Valor invalido! Digite novamente: \n", 1, 3); switch(opcao){ case 1: gravaDados(concursoModelo,qtdModelos); break; case 2: consultaDados(concursoModelo,qtdModelos); break; case 3: system("cls"); printf("Programa encerrado!"); getch(); break; } }while(opcao!=3); } return ; } //Objetivo: Ler dados de um concurso de modelos //Parâmetro: Endereço de memória de um vetor concursoModelos e a quantidade de modelos //Retorno:Nenhum int leDados(ConcursoModelo *concursoModelo,int qtdModelos){ int flag=0,flag2=0; char opcao; ConcursoModelo auxModelos; do{ concursoModelo[qtdModelos].registro = leValidaInt("Informe o numero de registro da candidata: \n", "Valor invalido! Digite novamente: \n",MIN_NUMCANDIDATA,MAX_NUMCANDIDATA); flag2 = verificaRepetido(concursoModelo,qtdModelos); }while(flag2==1); leValidaTexto("Nome Completo\n", "Nome invalido! Digite novamente: \n", concursoModelo[qtdModelos].nomeCandidata, TAM_CANDIDATA); transformaMinusculo(concursoModelo[qtdModelos].nomeCandidata); printf("\n"); concursoModelo[qtdModelos].pesoCandidata = leFloat("Peso: \n"); if(concursoModelo[qtdModelos].pesoCandidata < MIN_PESO || concursoModelo[qtdModelos].pesoCandidata > MAX_PESO){ do{ system("cls"); opcao = leValidaOpcao(" O peso esta invalido! Digite a opcao desejada\n\n C-> Continuar e informar o peso novamente \n S-> Cancelar o cadastro\n","Opção inválido! Digite novamente:\n", "CS"); switch(opcao){ case 'C': concursoModelo[qtdModelos].pesoCandidata = leValidaFloat("Peso: \n","Valor invalido! Digite novamente: \n", MIN_PESO, MAX_PESO); break; case 'S': flag=1; break; } }while(opcao!='S'); } //concursoModelo[qtdModelos]=auxModelos; system("cls"); return flag; } //Objetivo: Verificar se contém número de registro repetido //Parâmetro: Endereço de memória de um vetor concursoModelos e a quantidade de modelos //Retorno: Flag (1 contém repetido) int verificaRepetido(ConcursoModelo *concursoModelo,int qtdModelos){ int cont,flag=0; for(cont = 0; cont < qtdModelos-1; cont++){ if(concursoModelo[cont].registro == concursoModelo[qtdModelos].registro){ flag=1; break; } } if(flag==1){ printf("Numero de registro ja cadastrado! Digite novamente:\n"); getch(); system("cls"); } return flag; } //Objetivo: Transforma uma string para minusculo //Parâmetro: Endereço de memoria da string nome //Retorno:Nenhum void transformaMinusculo(char *nome){ int cont; for(cont = 0; cont < strlen (nome); cont ++){ nome[cont] = tolower(nome[cont]); } } //Objetivo: Gravar os dados em arquivo texto ou binério //Parâmetro: Endereço de memória de um vetor concursoModelos e a quantidade de modelos //Retorno: Nenhum void gravaDados(ConcursoModelo *concursoModelo,int qtdModelos){ FILE *arqtexto,*arqbinario; char opcao; int cont; do{ system("cls"); opcao = leValidaOpcao(" Digite a opcao em que deseja gravar as informações\n T >> Arquivo do tipo texto \n B >> Arquivo do tipo binario\n","Opcao invalido! Digite novamente:\n", "TB"); switch(opcao){ case 'T': arqtexto=fopen("backup.txt","wt"); if(arqtexto == NULL){ printf("Nao foi possivel abrir o arquivo"); }else{ for(cont=0; cont < qtdModelos; cont++){ fprintf(arqtexto,"%d %s %.2f\n",concursoModelo[cont].registro,concursoModelo[cont].nomeCandidata,concursoModelo[cont].pesoCandidata); } fclose(arqtexto); printf("informações gravadas com sucesso"); getch(); } break; case 'B': arqbinario=fopen("backup.txt","wb"); if(arqbinario == NULL){ printf("Nao foi possivel abrir o arquivo"); }else{ for(cont = 0; cont < qtdModelos; cont++){ if(!feof(arqbinario)){ fwrite(&concursoModelo[cont],sizeof(ConcursoModelo),1,arqbinario); } } fclose(arqbinario); printf("informações gravadas com sucesso"); getch(); } break; } }while(opcao =='T' && opcao == 'B' ); } //Objetivo: Consultar se existe o peso que o usúario deseja //Parâmetro: Endereço de memória de um vetor concursoModelos e a quantidade de modelos //Retorno: Nenhum void consultaDados(ConcursoModelo *concursoModelo,int qtdModelos){ int cont,flag=0; float pesoPesq; system("cls"); pesoPesq = leValidaFloat("Digite o peso que deseja pesquisar: \n","Valor invalido! Digite novamente: \n", MIN_PESO, MAX_PESO); system("cls"); for(cont=0; cont < qtdModelos; cont ++){ if(pesoPesq == concursoModelo[cont].pesoCandidata){ if(flag==0){ printf("%15s %25s %7s\n","Numero Registro","Nome","Peso"); flag=1; } printf("%15d %25s %7.2f\n",concursoModelo[cont].registro,concursoModelo[cont].nomeCandidata,concursoModelo[cont].pesoCandidata); } } if(flag==0){ system("cls"); printf("Nenhum com esse peso foi encontrado"); } getch(); system("cls"); } // Funcoes Basicas // Objetivo: Le numero inteiro // Parâmetros: endereco de memoria da string mensagem // Retorna: numero inteiro int leInt(char *msn) { int ret = 0,valor; do { printf(msn); fflush(stdin); ret = scanf("%d", &valor); fflush(stdin); if(ret == 0) { printf("Erro ao ler o numero.\n"); getch(); system("cls"); } }while(ret == 0); return valor; } // Objetivo: Le e validar numero inteiro // Parâmetros: endereco de memoria da string mensagem e mensagem de erro // valor minimo e valor maximo. // Retorna: numero inteiro int leValidaInt(char *msn, char *msnErro, int valorMin, int valorMax) { int valor; do { valor =leInt(msn); if(valor < valorMin || valor > valorMax) { printf(msnErro); getch(); system("cls"); } }while(valor < valorMin || valor > valorMax); return valor; } // Objetivo: Le e numero float // Parâmetros: endereco de memoria da string mensagem // Retorna: numero real float leFloat(char *msn) { float valor; int ret = 0; do { printf(msn); fflush(stdin); ret = scanf("%f", &valor); fflush(stdin); if(ret == 0) { printf("Erro ao ler o numero.\n"); getch(); system("cls"); } }while(ret == 0); return valor; } // Objetivo: Le e validar numero float // Parâmetros: endereco de memoria da string mensagem e mensagem de erro // valor minimo e valor maximo. // Retorna: numero real float leValidaFloat(char *msn, char *msnErro, float valorMin, float valorMax) { float valor; do { valor = leFloat(msn); if(valor < valorMin || valor > valorMax) { printf(msnErro); getch(); system("cls"); } }while(valor < valorMin || valor > valorMax); return valor; } // Objetivo: Le e validar um texto // Parâmetros: endereco de memoria da string mensagem, mensagem de erro e do texto // quantidade de caracteres a serem lidos // Retorna: nenhum void leValidaTexto(char *msn, char *msnErro, char *texto, int tam) { do { printf(msn); fflush(stdin); fgets(texto, tam, stdin); fflush(stdin); tiraTerminador(texto); if(strlen(texto) ==0) { printf(msnErro); getch(); system("cls"); } }while(strlen(texto) ==0); } // Objetivo: Tirar o \n de uma string // Parâmetros: endereco de memoria da string texto // Retorna: Nada void tiraTerminador(char *texto) { if(texto[strlen(texto)-1] == '\n') { texto[strlen(texto)-1] = '\0'; } } // Objetivo: Ler uma opcao // Parâmetros: endereco de memoria da string mensagem, mensagem de erro e das opções validas // Retorna: opcao valida char leValidaOpcao(char *msn, char *msnErro, char *opcoesValidas) { char opcao; do { printf(msn); fflush(stdin); opcao = toupper(getch()); fflush(stdin); system("cls"); if(strchr(opcoesValidas,opcao)==NULL) { printf(msnErro); getch(); system("cls"); } }while(strchr(opcoesValidas,opcao)==NULL); return opcao; } concursomodelo.rar

Como identificar no arquivo o endereço que o usuário digita, e apresentar apenas os endereços que tem esse endereço EX: No arquivo vai estar assim: PP – SQS 312 Bloco E – Apto 601 PP – SQS 313 Bloco A – Apto 101 TAG – AV das Acacias Q- 107 – Casa 1 Supondo que o usuário digitou SQS PP – SQS 312 Bloco E – Apto 601 PP – SQS 313 Bloco A – Apto 101

Ele esta enorme rs, o meu problema so estar na listagem // Aluno : Brenda Karoliny de A. Sousa //Matricula: UC16200175 /* Sintese Objetivo: Auxiliar no cadastro de carros de um colecionador Entrada : A identificação e o valor de cada carro, e se o usuário deseja continuar cadastrando carrros, ou deseja ver a lista dos carro, ou se quer encerrar o programa.. Saida : Apresentar todos os carros, com as 3 primeiras letras da identificações e seus valores */ #include <stdio.h> #include <string.h> #define MAX_CARROS 200 #define MAX_PLACA 7 #define MIN_PLACA 7 #define MAX_VALOR 99999999 char verificaOpcao(char msgErro[]); void leValidaTexto(char msg[], char msgErro[], int tamMax,int tamMin, char texto[]); float leFloat(char msn[]); float leValidaFloat(char msn[], char msnErro[], float valorMin, float valorMax); void apresentaListagem (int contCarros, char placas[][MAX_PLACA], float valorCarros[]); char validaPlacaRepetido(int contCarros,char placas[][MAX_PLACA],char placa[]); int verificaPlaca(char placa[]); int main(void) { // Declaracoes char opcao, placas[MAX_CARROS][MAX_PLACA], placa[MAX_PLACA]; int contCarros=0, cont,cont2,cont3,repetido=0,placa3; float valorCarros[MAX_CARROS]; // Instrucoes do{ opcao = verificaOpcao("Opcao Invalida!!\n"); system("cls"); switch (opcao){ case 'C': if(contCarros >= MAX_CARROS){ printf("A quantidade de carros esgotou."); getch(); }else{ printf("%d%c Veículo \n",contCarros+1,167); leValidaTexto("Informe a placa do carro: ", "Placa invalida!!\n\n", MAX_PLACA,MIN_PLACA,placa); placa3=verificaPlaca(placa); do{ repetido=validaPlacaRepetido(contCarros,placas,placa); if((repetido)== 1 || (placa3==0)){ printf(" Placa ja existe \n"); }else{ strcpy(placas[contCarros],placa); } }while((repetido)== 1 || (placa3==0)); valorCarros[contCarros] = leValidaFloat("Informe o valor do carro: ","Valor inválido",3000,MAX_VALOR); contCarros++; } break; case 'L': if(contCarros==0){ printf("nenhum registro de carros"); }else apresentaListagem(contCarros, placas,valorCarros); getch(); break; case 'E': printf("Programa Encerrado!"); getch(); break; } system("cls"); }while(opcao != 'E'); getch(); return 0; } //Objetivo: Ler e validar opção //Parâmetros:Referencia a um vetor de msg de erro //Saida:saida char verificaOpcao(char msgErro[]){ char saida; do{ printf("Informe a opção desejada: \n\n"); printf("C- Cadastrar novo carro \n"); printf("L- Lista de dados cadastrados até o momento \n"); printf("E- Encerra o programa \n"); saida = getche(); saida = toupper(saida); system("cls"); // a funcao toupper não‰ para transformar o caracter em maiuscula. if(saida != 'C' && saida != 'L' && saida != 'E'){ printf("\nOpição inválida! Digite novamente"); } } while(saida != 'C' && saida != 'L' && saida != 'E'); return saida; } //Objetivo: Ler e validar um texto digitado. //Parâmetros: Mensagem, mensagem de erro, tamanho do texto e a referencia do vetor/matriz que contem o texto. //Retorno: Nenhum void leValidaTexto(char msg[], char msgErro[], int tamMax,int tamMin, char texto[]){ do{ printf("%s",msg); fflush(stdin); fgets(texto, tamMax+1, stdin); if(texto[strlen(texto)-1] == '\n'){ texto[strlen(texto)-1] = '\0'; } if(strlen(texto)<tamMin || strlen(texto)<tamMax){ printf("%s", msgErro); } }while(strlen(texto)<tamMin || strlen(texto)<tamMax); } //Objetivo: Validar um numero Float. //Parâmetros: Mensagem. //Retorno: Numero Validado. // Objetivo: Le e numero float // Parâmetros: endereco de memoria da string mensagem // Retorna: numero real float leFloat(char msn[]) { float valor; int ret = 0; do { printf(msn); fflush(stdin); ret = scanf("%f", &valor); fflush(stdin); if(ret == 0) { printf("Erro ao ler o numero.\n"); getch(); system("cls"); } }while(ret == 0); return valor; } // Objetivo: Le e validar numero float // Parâmetros: endereco de memoria da string mensagem e mensagem de erro // valor minimo e valor maximo. // Retorna: numero real float leValidaFloat(char msn[], char msnErro[], float valorMin, float valorMax) { float valor; do { valor = leFloat(msn); if(valor < valorMin || valor > valorMax) { printf(msnErro); getch(); system("cls"); } }while(valor < valorMin || valor > valorMax); return valor; } //Objetivo: Apresentar a lista de carros cadastrados //Parâmetro:Quantidade de carros, referência a uma string e referencia a um vetor //Retorno: Nenhum void apresentaListagem (int contCarros, char placas[][MAX_PLACA], float valorCarros[]){ int cont, cont2, cont3,flag=0; char letras[4],aux[MAX_PLACA]; printf("Didite apenas as letras da placa \n"); leValidaTexto("Didite apenas as letras da placa \n","Digite somente as letras \n",3,3,letras); for(cont = 0; cont < contCarros; cont++){ strcpy(aux,placas[cont]); for(cont2 = 0; cont2 < contCarros; cont2++){ aux[cont2]=toupper(aux[cont2]); if(cont2 < strlen(letras)){ letras[cont2]=toupper(letras[cont2]); } } printf("%s %s",aux,letras); if(strstr(aux,letras)!=NULL){ flag=1; printf("Placa: %s\n ",placas[cont]); printf("Preço: R$ %f\n ",valorCarros[cont]); } if(flag ==0){ printf("Nã existe essa placa"); } } } //Objetivo: Verificar se tem placa repetida //Parâmetro: Quantidade de carros, referencia a uma matriz placa e uma referência a um vetor placa //Retorna: Repetido char validaPlacaRepetido(int contCarros,char placas[][MAX_PLACA],char placa[]){ int repetido=0,cont; for(cont=0;cont<contCarros;cont++){ if(stricmp(placas[cont],placa)==0){ repetido = 1; return repetido; } } return repetido; } //Objetivo: Verificar o formato da placa //Parâmetro: plca //Retorno: flag int verificaPlaca(char placa[]){ int cont,flag=1; for(cont=0;cont<7;cont++){ if(cont<3){ if(!isalpha(placa[cont])){ flag=0; break; } }else if(!isdigit(placa[cont])){ flag=0; break; } } return flag; }

Estou com um problema nessa função e não consigo identificar. O usuario tem que digitar apenas as letras da placa se existir essa placa apresentar a placa completa com o valor dela. void apresentaListagem (int contCarros, char placas[][MAX_PLACA], float valorCarros[]){ int cont, cont2, cont3,flag=0; char letras[4],aux[MAX_PLACA]; printf("Didite apenas as letras da placa \n"); leValidaTexto("Didite apenas as letras da placa \n","Digite somente as letras \n",3,3,letras); for(cont = 0; cont < contCarros; cont++){ strcpy(aux,placas[cont]); for(cont2 = 0; cont2 < contCarros; cont2++){ aux[cont2]=toupper(aux[cont2]); if(cont2 < strlen(letras)){ letras[cont2]=toupper(letras[cont2]); } } printf("%s %s",aux,letras); if(strstr(aux,letras)!=NULL){ flag=1; printf("Placa: %s\n ",placas[cont]); printf("Preço: R$ %f\n ",valorCarros[cont]); } if(flag ==0){ printf("Nã existe essa placa"); } } }