Structs e Arquivos

bellun
(usa Outra)

Enviado em 20/09/2015 - 19:17h

Estou com um problema na minha função que valida matriculas repetidas e com uma dúvida a respeito de como vou gravar os dados que meu programa le para um arquivo txt, separando os dados em:
Alunos com iniciais de A a N em um arquivo e de M a Z em outro arquivo.
Meu programa ainda não faz tudo que me foi proposto mas acredito que solucionando essa dúvidas o resto eu consigo me virar.

Fernando Henrique 



/*

 Sintese

   Objetivo: Auxiliar um professor no controle de dados de uma quantidade de alunos(max 120) numa turma.

 

   Entrada : Quantidade de alunos, matricula, nome e duas notas de cada aluno. Nome de 2 arquivos de saída para o programa



   Saida   :	Arquivo 1(Alunos com Iniciais de A a M):

   		   		Matricula	Nome						Média aritmética	  

			

				9898		Ana Maria					    7.50

				12345		José da Silva Nascimento	    9.75

				455			Maria Antonia				    8.85

				

				Total de 3 alunos.

				

				

				Arquivo 2(Alunos com Iniciais de N a Z):

   		   		Matricula	Nome						Média aritmética	  

				

				567			Raimundo Nonoto					7.50

				7652		Raissa de Azevedo				9.75

				78999		Roberto da Silva				8.85

				3232		Rosivaldo Manoel				8.95

				

                Total de 4 alunos.

			

			    Caso de erro será gerado um arquivo erro.txt com o número da linha com erro, o conteúdo da linha e a descrição do erro ou erros encontrados.

			*/

#include <stdio.h>

#include <conio.h>

#define NOME_MAX 100

#define MAX_ALUNOS 120

#define MIN_ALUNOS 1

#define QTDE_NOTAS 2

#define NOTA_MIN   0

#define NOTA_MAX   10

////////STRUCTS///////////////

struct Dados 

{

char  nome[NOME_MAX];

float notas[QTDE_NOTAS];

int matricula;

float media;

};

/////////////////////////////////////////////



/////////////////PROTÓTIPOS///////////////////

void leValidaTexto (char *texto, char *mensagemTitulo, int tamanho, int aux);

int leValidaInt(char *titulo);

int leValidaQuantidade(char *titulo,int min, int max);

void cadastraAluno(struct Dados *turma,int qtdeAlunos);

leValidaMatricula(char *titulo);

float leValidaNotas(char *titulo, float valorMin, float valorMax);

int verificaRepetido(struct Dados *turma, int ultimoLido);

//////////////////////////////////////////////			

int main(void)

{

// Declaracoes

char nomeArquivo1[NOME_MAX];

char nomeArquivo2[NOME_MAX];

int qtdeAlunos;

FILE *arquivo1;

FILE *arquivo2;

FILE *erro;

int aux;

// Instrucoes

qtdeAlunos=leValidaQuantidade("Informe a quantidade de alunos da turma:",MIN_ALUNOS, MAX_ALUNOS);

struct Dados turma[qtdeAlunos];

erro=fopen("erro.txt","w");

fclose(erro);

for ( aux = 0;aux<1;aux++)

{

	leValidaTexto(nomeArquivo1,"Informe o nome do arquivo n 1 :",NOME_MAX, aux);

	leValidaTexto(nomeArquivo2,"Informe o nome do arquivo n 2:",NOME_MAX, aux);

};

if(strcmp(nomeArquivo1,nomeArquivo2)==0)

{

    printf("Nomes iguais");            

    getch();

    fopen("erro.txt","a");

    fprintf(erro,"Nome dos arquivos iguais, impossibilitando a criacao.");

    fclose(erro);

    exit(0);

};

arquivo1=fopen(nomeArquivo1,"w");

arquivo2=fopen(nomeArquivo2,"w");

cadastraAluno(&turma,qtdeAlunos);

getch();

return 0;

}

//Objetivo:

//Parametros:

//Retorno:

//Objetivo: ler e Validar um Nome

//Parametros: endereço de titulo, endereco de msgErro, tamanho maximo e endereço de nome

//Retorno:

void leValidaTexto (char *texto, char *mensagemTitulo, int tamanho, int aux)

{

	do{

		printf("%s\n",mensagemTitulo);

		fflush(stdin);

		fgets(texto, tamanho, stdin);

		fflush(stdin);

		if(texto[strlen(texto)-1] == '\n'){

			texto[strlen(texto)-1] = '\0';

		}

		if(strlen(texto) == 0){

			system("cls");

			printf("Nada foi informado\n");

			getch();

		}

		}while(strlen(texto) == 0);

		system("cls");

}

//Objetivo:Ler e validar uma quantidade de alunos

//Parametros:endereço do vetor titulo, quantidade minima e maxima de alunos.

//Retorno: Quantidade de alunos válida

int leValidaQuantidade(char *titulo,int min, int max)

{

    int qtde;

    do{

        qtde=leValidaInt(titulo);

        if(qtde<min||qtde>max)

		{

			printf("Quantidade de alunos, invalida, informe uma quantidade na faixa: [1]..[120]");

			getch();

		}

		system("cls");

    }while(qtde<min||qtde>max);

    return qtde;

}

//Objetivo: ler e validar inteiro 

//Parametros: endereco de titulo

//Retorno: inteiro validado

int leValidaInt(char *titulo)

{

	int ret;

	int nro;

	do

	{

		printf("%s\n",titulo);

		fflush(stdin);

		ret = scanf("%d",&nro);

		fflush(stdin);

		if(ret == 0 )

		{

			printf("Campo destinado para numeros inteiros, informe novamente");

			getch();

		}

		system("cls");

	}while(ret==0);

	return nro;

}

//Objetivo:Cadastrar os dados dos alunos da turma

//Parametros:endereço de memória do vetor turma, quantidade de alunos

//Retorno:sem retorno

void cadastraAluno(struct Dados *turma,int qtdeAlunos)

{

    int aux;

    int validacao;

    system("cls");

    for(aux=0;aux<qtdeAlunos;aux++){

       

       do

	   {

	       printf("Informe a matricula do aluno %d\n",aux+1);

		   turma[aux].matricula=leValidaMatricula(turma->matricula);

		   validacao = verificaRepetido(&turma,aux);

		   if(validacao == 1 )

		   {

		      printf("Matricula  repetido informe outra novamente\n");

	          getch();

	          system("cls");

	       }

	   }while(validacao == 1);

        leValidaTexto(turma->nome,"Informe o nome do estudante n :",NOME_MAX,aux);

        turma[aux].notas[0]=leValidaNotas("Informe a nota 1:",NOTA_MIN,NOTA_MAX);

        turma[aux].notas[1]=leValidaNotas("Informe a nota 2:",NOTA_MIN,NOTA_MAX);

        turma[aux].media=(turma[aux].notas[0]+turma[aux].notas[1])/2;

        };

}

//Objetivo:Ler e validar uma matricula

//Parametros: endereço do vetor matricula, endereço do vetor de titulo,contador 

//Retorno:

leValidaMatricula(char *titulo)

{

    int matricula;

    do{

        matricula=leValidaInt("Insira:");

        }while(matricula<0||matricula>99999);

    return matricula;

}   

//Objetivo: Verificar numero repetido em uma matriz

//Parametros: endereço da matriz e o ultimo lido

//Retorno: 1 se repetido 0 se não repetido

int verificaRepetido(struct Dados *turma, int ultimoLido)

{

	int cont;

	int flag = 0;

	for(cont = 0; cont < ultimoLido; cont++)

	{

	  if(turma[ultimoLido].matricula == turma[cont].matricula)

	   {

	   	  flag = 1;

	   	  break;

       }

	}

	return flag;

}

//Objetivo: ler e validar real 

//Parametros: endereco de titulo, endereco de mensagem de erro , valorMin e valor Max

//Retorno: real validado

float leValidaNotas(char *titulo, float valorMin, float valorMax)

{

	int ret = 0;

	int flag;

	float nro;

	do

	{

		flag = 0;

		printf("%s\n",titulo);

		fflush(stdin);

		ret = scanf("%f",&nro);

		fflush(stdin);

		if(ret == 0 || nro < valorMin || nro > valorMax)

		{

			flag = 1;

			printf("ERRO, campo destinado para numeros");

			getch();

		}

		system("cls");

	}while(flag == 1);

	return nro;

}