Apresentar a placa do carro

[Brenda Karoliny]

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

 

[Brenda Karoliny]

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

 

[MassakiMsk]

Um dos principais erros, se não o principal, está no tamanho dos char[]. Você tem que lembrar de deixar sempre uma posição a mais para guardar o '\0'