Brenda Karoliny

28 de maio de 2017

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

6 de maio de 2017

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

19 de abril de 2017

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

26 de março de 2017

14 minutos atrás, vangodp disse:

deverias por o código completo.

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;
}

26 de março de 2017

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");
		     }
			
		}
	}

Entrar

Brenda Karoliny

Posts

Cadastrado em

Última visita

Tipo de conteúdo

Artigos

Selos

Fabricantes

Livros

Cursos

Análises

Fórum

posts postados por Brenda Karoliny

Como excluir registro

Como excluir um cadastro em C

Como identificar endereços dentro de um arquivo?

Apresentar a placa do carro

Apresentar a placa do carro

Sobre o Clube do Hardware

Direitos autorais

Mais

Fórum

Atividades

Artigos

Análises

Livros

Cursos