Prova P2 Bortot

Escola.cpp

// Programa Escola de Natação - Prova N2 - 01/06/2016 - Turma da Tarde
//
#include "Escola.h"
//	Entry point do programa
//
void main(void)
{
	int nPeriodo,								// periodo da aula de natação
		nRaia,									// raia da piscina
		nPosicionalRaia,						// posicional da raia dentro do arquivo de raias
		nQtdeParentes,							// quantidade de parentes para desconto
		nQtdeTotalDeRaias,						// qtde total de raias nos três períodos
		i, j;									// índices genéricos
	FILE *fdQuantidade,							// file descriptor para o arquivo de quantidade de raias da piscina
		*fdRaia;								// file descriptor da raia da piscina
	RAIA stRaia;								// struct para conter os dados de uma raia
	QTDE_RAIAS stQtRaias;						// struct para conter os dados da qtde raias da piscina
	double dValorMensalidade;					// para calcular a mensalidade
	char cOpcao,								// opcao do operador
		cNomeAluno[] = "Preencher com seu nome", // para conter o nome do aluno que está fazendo a prova
		cWork[200];								// para sprintf_s
	SYSTEMTIME stTime;							// para data e hora do sistema
	char vetNomesPeriodos[QTDE_PERIODOS][7] =
	{"Manhã", "Tarde", "Noite"};
	// para duas casas decimais nos valores
	cout.setf(ios::fixed);
	cout.setf(ios::showpoint);
	cout.precision(2);
	setlocale(LC_ALL, "portuguese_brazil");		// para acentuação brasileira
	// <<<1>>> - Digitar o seu nome na variável cNomeAluno.
	// <<<2>>> - Tratamento inicial dos arquivos de quantidade e raias.
	//	2.1 - Abrir o arquivo de quantidades em modo r+b e testar se ele existe.
	//	2.2 - Se ele não existir o arquivo de quantidades:
	//		2.2.1 - Abrir o arquivo de quantidades em modo w+b e testar se foi aberto com sucesso.
	//		2.2.2 - Se o arquivo não foi aberto com sucesso:
	//			2.2.2.1 - Avisar o operador e abortar o programa.
	//		2.2.3 - Se o arquivo foi aberto com sucesso
	//			2.2.3.1 - Fazer um loop para obter uma quantidade de raias da piscina válida
	//						porque tem um mínimo e máximo no .h. Essa quantidade tem que ser
	//						armazenada na stQtRaias
	//			2.2.3.2 - Gravar stQtRaias no arquivo de quantidades e fechar o arquivo.
	//		2.2.4 - Abrir o arquivo de raias em modo w+b e testar se foi aberto com sucesso
	//			2.2.4.1 - Se houve erro de abertura avisar o operador e abortar o programa
	//			2.2.4.2 - Se o arquivo foi aberto com sucesso fazer um loop para gravar o
	//					  registro de cada raia (stRaia) indicando o período e a raia 
	//						1 e 1 - Manhã raia 1
	//						1 e 2 - Manhã raia 2 .....
	//						1 e qtde raias da piscina - Manhã e raia stQtRaias.nQtdeRaias
	//						2 e 1 - Tarde raia 1
	//						2 e 2 - Tarde raia 2
	//						2 e qtde raias da piscina - Tarde e raia stQtRaias.nQtdeRaias
	//						Idem para o período da noite....
	//					  Para cada raia a ser gravada indicar que a raia não está ocupada.
	//			2.2.4.3 - Se houver erro de gravação fechar o arquivo de raias, avisar o
	//					  operador e abortar a execução do programa
	//	
	//	2.3 - Se o arquivo de quantidades existir:
	//		2.3.1 - Ler a quantidade para stQtRaias e fechar o arquivo.
	//		2.3.2 - Abrir o arquivo de raias em modo r+b e testar se foi aberto com sucesso
	//			2.3.2.1 - Se houve erro de abertura avisar ao operador e abortar a execução do programa
	//			2.3.2.2 - Se o arquivo foi aberto com sucesso ir para o menu do operador


	//	Loop Infinito
	while(true)
	{
		LIMPAR_TELA;
		GetLocalTime(&stTime);						// data e hora do sistema
		sprintf_s(cWork, sizeof(cWork), 
			"\n\tFATEC-Escola de Natação %02d/%02d/%04d às %02d:%02d:%02d\n\tOperador: %s",
			stTime.wDay, stTime.wMonth, stTime.wYear, 
			stTime.wHour, stTime.wMinute, stTime.wSecond,
			cNomeAluno);
		cout << cWork << endl;
		// exibir o menu
		cout << MATRICULAR_ALUNO << " - Matricular aluno em um período desejado" << endl
			<< CANCELAR_MATRICULA << " - Cancelar a matrícula de um aluno" << endl
			<< EXIBIR_DADOS_ALUNO << " - Exibir os dados de um aluno" << endl
			<< LISTAR_PERIODO << " - Listar os alunos de um dado período" << endl
			<< SAIR_DO_PROGRAMA << " - Sair do programa" << endl
			<< "\tSelecione: ";
		cin  >> cOpcao;
		cOpcao = toupper(cOpcao);					// converte para maiúscula
		switch(cOpcao)								// avalia a opção escolhida
		{
			case MATRICULAR_ALUNO:
				// grande parte já codificado 

				nPeriodo = PedirPeriodo(QTDE_PERIODOS, "Matricular Aluno");
				if(nPeriodo == 0)					// cancelou a ação?
					break;							// cai fora do switch
				// chamar a função que vê se tem raia livre neste periodo
				nRaia = BuscarRaiaLivreNoPeriodo(nPeriodo, stQtRaias.nQtdeRaias, &stRaia, &fdRaia);
				// verificar se não tem raia livre neste periodo
				if(nRaia == 0)						// não tem raia livre?
				{	// não tem raia livre neste período
					cout << "Não tem vaga no periodo da " << vetNomesPeriodos[nPeriodo - 1] << endl;
					PAUSA;
					break;
				}
				cin.ignore(1, EOF);
				cout << "Informe o nome do aluno: ";
				cin.getline(stRaia.cNome, EXTENSAO_NOME, '\n');
				cout << "Informe o sobrenome do aluno: ";
				cin.getline(stRaia.cSobreNome, EXTENSAO_SOBRENOME, '\n');
				// vai calcular o valor da mensalidade em função da quantidade de parentes da
				//	mesma família
				nQtdeParentes = VerificaParentes(stRaia.cSobreNome, &fdRaia);

				// calcular o valor da mensalidade sabendo que o valor básico está em 
				//		VALOR_MENSALIDADE e a cada parente (nQtdeParentes) é dado um
				// desconto de 10% até no máximo de 40% se tiver 4 parentes com o mesmo
				//	sobrenome). Copiar o valor calculado em stRaia.dVlrMensalidade
				
				//
				// calcular o indice desta raia para saber o posicional da raia dentro do arquivo de
				//	raias - é função do periodo, quantidade de raias da piscina e a raia da piscina
				// armazenar este cálculo em nPosicionalRaia
				stRaia.flgRaiaOcupada = true;				// indica que a raia está ocupada
				if(!GravaPosicional(nPosicionalRaia, &stRaia, &fdRaia)) // erro de gravação?
				{
					cout << "Erro de gravação!" << endl;
					PAUSA;
				}
				break;								// cai fora do switch e volta ao menu
			case CANCELAR_MATRICULA:				
				// <<<9>>>  Chamar a função que pede o periodo e a raia indicando que a ação é
				//			Cancelamento de Matrícula
				//		
				//			Calcular o posicional para está raia.
				//			Chamar a função que lê posicional
				//			Verificar se a raia está ocupada
				//			Se não estiver ocupada avisar ao operador e voltar ao menu
				//			Se estiver ocupada, exibir todos os dados da raia e
				//				pedir a confirmação com S ou N.
				//			Se o operador confirmar com S ou s, gravar a raia com a função
				//				gravar posicional.
				//			voltar ao menu principal
				break;								// cai fora do switch e volta ao menu
			case EXIBIR_DADOS_ALUNO:
				// <<<10>>>  Chamar a função que pede o periodo e a raia indicando que a ação é
				//			Mostrar dados do aluno
				//			Calcular o posicional para está raia.
				//			Chamar a função que lê posicional
				//			Verificar se a raia está ocupada
				//			Se não estiver ocupada avisar ao operador e voltar ao menu
				//			Se estiver ocupada, exibir todos os dados da raia e dar uma pausa
				break;								// voltar ao menu
			case LISTAR_PERIODO:				
				// <<<15>>> Pedir um período válido ou zero para cancelar a ação de listar
				//			Se foi informado um período válido listar todos as raias ocupadas
				//			no seguinte formato:
				//				Listagem das raias do periodo: ppppppp
				//			Raia Sobrenome  Mensalidade 
				//			 RR  SSSSSSSSS  MMMMMM,MM	
				//			.....
				//			.....
				//					       Total das Mensalidades: TTTTTT,TT
				//			Onde: PPPPPPP - periodo: "Manhã", "Tarde" ou "Noite"
				//				  RR - raia ocupada ( 1 a Qtde de Raias da Piscina)
				//				  SSSSSSSSS - sobrenome do aluno
				//				  MMMMM - valor da mensalidade
				//				  TTTTTTT = somatória das mensalidades dos alunos matriculados
				//		Para essa listagem considerar o seguinte:
				//		Calcular o posicional para a primeira raia do periodo.
				//		Fazer um looping lendo posicional de cada raia do periodo e
				//			listar no formato acima pedido se a raia estiver ocupada.
				//		Fazer a somatória de mensalidades deste período.
				break;								// cai fora do switch
			case SAIR_DO_PROGRAMA:					
				cout << "Vai sair realmente? (S ou N): ";
				cin >> cOpcao;
				if(cOpcao == 's' || cOpcao == 'S')	// sair realmente?
				{
					// fclose(fdRaia);				// ativar quando o programa estiver em 
													// condição de testes.
					return;			
				}
				break;								// cai fora do switch
			default:
				cout << "Opção inválida!" << endl;
				PAUSA;
		} // switch
	} // while
} // main
// 
// Funções do Programa
//
// Função que pede um período válido e uma raia da piscina válida
// Parâmetros:
//	Entrada: int *ptrPeriodo - ponteiro para receber o período desejado
//			 int *ptrRaia - ponteiro para receber a raia da piscina desejada
//			 int nQtdePeriodos - quantidade de períodos da Escola de Natação
//			 int nQtRaiasPiscina - quantidade de raias que tem a piscina da Escola de Natação
//			 char *ptrAcao - ponteiro de um string que contém a ação que está sendo executada
//	Retorno: bool - true - indica que foi informado um período e uma raia válidos
//					false - indica que o operador desistiu da ação que iria executar:
bool PedirPeriodoRaia(int *ptrPeriodo, int *ptrRaia, 
					  int nQtdePeriodos, int nQtRaiasPiscina, char *ptrAcao)
{
	do
	{
		cout << "\n\t" << ptrAcao << endl;
		cout << "Informe o período desejado " << endl <<
			"\t1 - Manhã" << endl << "\t2 - Tarde" << endl << "\t3 - Noite" << endl
			<< "Ou zero para cancelar está ação: ";
		cin >> *(ptrPeriodo);
		if(*(ptrPeriodo) == 0)				// cancelou a ação
			return false;					// indica que cancelou
	}while(*(ptrPeriodo) < PERIODO_MANHA ||
		*(ptrPeriodo) > nQtdePeriodos);
	do
	{
		cout << "Informe a raia entre 1 e " << nQtRaiasPiscina << endl
			<< "Ou zero para cancelar a execução desta ação: ";
		cin >> *(ptrRaia);
		if(*(ptrRaia) == 0)					// cancelou a ação?
			return false;
	}while(*(ptrRaia) < 1 ||
		*(ptrRaia) > nQtRaiasPiscina);
	return true;							// indica que foi digitado um período e uma raia
}
//
// Função que verifica se tem uma raia livre no período desejado
//	Parâmetros:
//		Entrada: int nPeriodo - período desejado
//				 int nQtRaiasPiscina - quantidade de raia que a piscina tem
//				 RAIA *ptrStRaia - ponteiro para uma struct a conter os dados da raia 
//									livre.
//				 FILE **fdRaia - file descriptor do arquivo de raias
//		Retorno: int - Número da raia que está livre ou zero se não existir nenhuma
//						raia livre no período desejado
int BuscarRaiaLivreNoPeriodo(int nPeriodo, int nQtRaiasPiscina, RAIA *ptrStRaia, FILE **fdRaia)
{
	RAIA stRaia;						// buffer de leitura de cada raia

	// em função do período desejado e a quantidade de raias da piscina
	//	calcular o posicional da primeira raia do periodo desejado.
	// posicionar com o fseek na primeira raia do período ( se der erro - devolve zero)
	// ficar em looping limitado a qtde de raias da piscina
	// lendo sequencialmente até encontrar uma raia livre
	// Se encontrou uma raia livre devolve o seu número e copie os dados desta raia em
	//		uma struct apontada por ptrStRaia
	// ou devolve zero se não encontrou nenhuma livre.
	
	return 0;							// para não dar erro
}

// Função que pede um período válido ou zero para cancelar a ação
//	Parâmetros:
//		Entrada: int nQtdePeriodos - quantidade de períodos da escola de natação
//				 char *ptrAcao - ponteiro para uma string que contem a ação sendo executada
//		Retorno: int - o período desejado ou zero para cancelar a ação
int PedirPeriodo(int nQtdePeriodos, char *ptrAcao)
{
	int nPeriodo;									// para receber o periodo
	do
	{
		cout << "\n\t" << ptrAcao << endl;
		cout << "Informe o período desejado " << endl <<
			"\t1 - Manhã" << endl << "\t2 - Tarde" << endl << "\t3 - Noite" << endl
			<< "Ou zero para cancelar está ação: ";
		cin >> nPeriodo;
	}while(nPeriodo < 0 || nPeriodo > nQtdePeriodos);
	// devolver o que foi válido digitado
	return nPeriodo;								// devolve o digitado
}
// Função que verifica se tem parentes com o mesmo sobrenome
//	Parâmetros:
//		Entrada: char *ptrSobrenome - ponteiro para um string que contém o sobrenome
//				 FILE **fdRaia - ponteiro para o file descriptor do arquivo de raias
//		Retorno: int - contendo a quantidade de parentes com o mesmo sobrenome (máximo de 4).
int VerificaParentes(char *ptrSobrenome, FILE **fdRaia)
{
	RAIA stRaia;						// buffer de leitura para cada raia do arquivo
	int nContador = 0;					// contador de parentes com mesmo sobrenome
	// posicionar o arquivo de raias na primeira raia do primeiro período (posicional zero).
	// fazer um loop de leitura sequencial até o fim do arquivo ou até encontrar 4 parentes
	// com o mesmo sobrenome (o máximo de desconto será de 40%)
	// a cada raia lida verificar se está ocupada e se tem o mesmo sobrenome
	// se tiver o mesmo sobrenome somar um no nContador e verificar se chegou a 4.
	// se chegou a 4 retornar este valor.
	// se chegou ao fim do arquivo retornar o nContador.
	return nContador;					// retornar o que foi encontrado
}

// Função que grava uma raia posicional no arquivo de raias
//	Parâmetros:
//		Entrada: int nPosicional - posicional para gravação da raia
//				 RAIA *ptrStRaia - ponteiro para a struct que contem os dados a serem gravados
//				 FILE **fdRaia - file descriptor do arquivo de raias.
//		Retorno: bool - true a gravação foi realizada OK
//						false - se houve erro de fseek ou fwrite
bool GravaPosicional(int nPosicional, RAIA *ptrStRaia, FILE **fdRaia)
{
	
	// posicionar na raia através do fseek
	// gravar os dados que foram passados com o fwrite.
	return true;								// para não dar erro de compilação ????????????
}

// Função que lê uma raia posicional do arquivo de raias
//	Parâmetros:
//		Entrada: int nPosicional - posicional para leitura da raia
//				 RAIA *ptrStRaia - ponteiro para a struct que receberá os dados a serem lidos
//				 FILE **fdRaia - file descriptor do arquivo de raias.
//		Retorno: bool - true a leitura foi realizada OK e os dados estão na struct informada
//						false - se houve erro de fseek ou fread_s
bool LerPosicional(int nPosicional, RAIA *ptrStRaia, FILE **fdRaia)
{
	
	// posicionar na raia através do fseek
	// ler os dados para a struct que foi passada com fread_s
	return true;								// para não dar erro de compilação ????????????
}

Escola.h

// Declarações do programa Escola de Natação
#include <iostream>
#include <windows.h>
using namespace std;
// Definições
#define PAUSA				system("pause")
#define LIMPAR_TELA			system("cls")
// Delimitação do programa
#define QTDE_PERIODOS		3			// quantidade de períodos (1 - manhã, 2 - tarde e 3 - noite)
#define QTDE_MINIMA_RAIAS_PISCINA	5	// quantidade minima de raias da piscina
#define QTDE_MAXIMA_RAIAS_PISCINA	15	// quantidade máxima de raias da piscina
#define PERIODO_MANHA		1			// período da manhã
#define PERIODO_TARDE		2			// período da tarde
#define PERIODO_NOITE		3			// período da noite
// opções do menu
#define MATRICULAR_ALUNO		'M'			
#define CANCELAR_MATRICULA		'C'
#define EXIBIR_DADOS_ALUNO		'E'
#define LISTAR_PERIODO			'P'
#define SAIR_DO_PROGRAMA		'S'
// valores e descontos de mensalidade
#define VALOR_MENSALIDADE			137.50	// valor da mensalidade do primeiro da família
#define VALOR_DESCONTO_POR_PARENTE	10		// porcentagem de desconto para cada parente com o mesmo sobrenome
#define EXTENSAO_NOME			20			
#define EXTENSAO_SOBRENOME		20
// caminho dos arquivos do programa
#define CAMINHO_QUANTIDADE		"..\\QtdeRaias.arq"
#define CAMINHO_RAIA			"..\\Raia.arq"

// struct para quantidade de raias da piscina
typedef struct tagQTDE_RAIAS
{
	int nQtdeRaias;							// quantidade de raias da piscina
} QTDE_RAIAS;

// struct para cada aluno da escola
typedef struct tagRAIA
{
	int	nPeriodo,							// períodos da escola (1, 2 e 3 - manhã tarde e noite
		nRaia;								// raia de 1, 2, 3, .......quantidade de raias da piscina
	bool flgRaiaOcupada;					// true indica que raia ocupada e false raia livre
	char cNome[EXTENSAO_NOME + 1],			// nome do aluno
		cSobreNome[EXTENSAO_SOBRENOME + 1];	// sobrenome do aluno (para dar desconto de família)
	double dVlrMensalidade;					// valor da mensalidade
} RAIA;										// struct de cada raia da piscina nos três períodos

// protótipos das funções
bool PedirPeriodoRaia(int *ptrPeriodo, int *ptrRaia, 
					  int nQtdePeriodos, int nQtRaiasPiscina, char *ptrAcao);
int BuscarRaiaLivreNoPeriodo(int nPeriodo, int nQtRaiasPiscina, RAIA *ptrStRaia, FILE **fdRaia);
int PedirPeriodo(int nQtdePeriodos, char *ptrAcao);
int VerificaParentes(char *ptrSobrenome, FILE **fdRaia);
bool GravaPosicional(int nPosicional, RAIA *ptrStRaia, FILE **fdRaia);
bool LerPosicional(int nPosicional, RAIA *ptrStRaia, FILE **fdRaia);