323266329-Unip-Interativa-PIM-IV-Sistema-de-Vendas-de-Passagem

Prévia do material em texto

UNIP INTERATIVA
Projeto Integrado Multidisciplinar
Cursos Superiores de Tecnologia
DESENVOLVIMENTO DE SOFTWARE
Sistema de Venda de Passagens
Polo Macaubas/BA
2019
UNIP INTERATIVA
Projeto Integrado Multidisciplinar
Cursos Superiores de Tecnologia
DESENVOLVIMENTO DE SOFTWARE
Sistema de Venda de Passagens
					 Leandro Nascimento Souza
						RA: 0531881
						Curso: Análise e Desenvolvimento de Sistemas
						Semestre: 01
Polo Macaubas/BA
2019
Resumo
	Este projeto tem por objetivo o desenvolvimento de um sistema de venda de passagens de ônibus. O sistema foi desenvolvimento na linguagem de programação C com a utilização da ferramenta DEV C++. Utilizando os conhecimentos e técnicas adquiridos ao longo do primeiro trimestre do curso de Análise e Desenvolvimento de Sistemas foi possível desenvolver o aplicativo de forma a atender os requisitos do projeto. As funções foram modularizadas sempre que possível a fim de tornar futuras manutenções mais simples. Foram adicionados comentários por todo o código a fim de facilitar sua compreensão.
Abstract
	This project aims to develop a bus tickets sale system . The system has been developed in the C programming language with the use of DEV C ++ tool. Using the knowledge and skills acquired during the first quarter of the course in Systems Analysis and Development was possible to grow the application to meet project requirements . The functions are modularized wherever possible in order to make future maintenance easier. Comments have been added throughout the code in order to make understanding easier.
Sumário
Introdução…………………………………………………………………………	5
1 – Dos Requisitos………………………………………………………………...	6
2 – Do Modelo de Desenvolvimento……………………………………………...	6
2.1 – Do Protótipo…………………………………………………………………	7
2.2 – Da Modelagem………………………………………………………………10
3 – Da Implementação das Funcionalidades………………………………………	11
3.1 – Da Implementação dos Veículos…………………………………………….	14
3.2 – Da Implementação das Vendas……………………………………………...	16
3.3 – Da Implementação do Fluxo de Caixa……………...………………………	18
Conclusão……………………………………………………………………...….	21
Referências………………………………………………………………………..	22
Introdução
	O sistema desenvolvido neste projeto é capaz de emitir um ticket contendo informações como data e horário da viagem, número da poltrona, número do ônibus e destino. Também deverá ser capaz de permitir até duas passagens gratuitas para idosos e fornecer desconto de 50% para estudantes. Deverá ser capaz de evitar a venda de uma mesma poltrona para mais de um passageiro. Por fim, deverá ser capaz de exibir as movimentações do caixa.
	Ao longo deste texto, detalharei como foi o processo de desenvolvimento do sistema e as soluções adotadas para que fosse possível atender aos requisitos.
1 – Dos Requisitos
	
	O sistema desenvolvido neste projeto deverá ser capaz de administrar vários aspectos da venda de passagens de ônibus.
	O primeiro requisito é que o sistema leve em consideração uma tabela de tarifação com o valor das passagens. A partir daí, deverá permitir que estudantes compre passagens com 50% de desconto. Também deverá permitir que até duas passagens tenham gratuidade de 100% para idosos.
	Após a finalização da venda, deverá ser emitido um ticket contendo a data e hora da partida do ônibus, o local de destino, o número do ônibus e o número da poltrona.
	O sistema não poderá permitir que a mesma poltrona seja vendida à mais de um passageiro.
	Não podem ser vendidos mais lugares do que os disponíveis no veículo.
	Deverá fazer a gestão do caixa, armazenando todas as movimentações do dia e o saldo do fechamento.
2 – Do Modelo de Desenvolvimento
	
	Considerando o pequeno tamanho do projeto, optei por seguir o conceito dos métodos ágeis, no sentido iniciar o projeto com um protótipo, de intercalar o planejamento com a escrita do código e de focar no funcionamento, mais do que na documentação. O desenvolvimento também se deu de forma incremental, pois após a inclusão de funcionalidades o processo retornava à fase análise das necessidades, passando por nova modelagem, codificação e testes.
	Para construção do protótipo, primeiramente foram definidos os menus e opções necessários. Assim, foram desenvolvidas as principais telas a serem exibidas pelo aplicativo porém sem as funcionalidades que seriam implementadas posteriormente.
	Toda a modelagem foi realizada por meio de descrição narrativa. As tarefas necessárias foram definidas e depois foram gradativamente detalhadas e transformadas em tarefas menores. Assim que estivessem suficientemente detalhadas, as funções eram então codificadas.
	Esta forma de desenvolvimento se mostrou bastante eficiente, para um projeto de pequeno como este. Porém, é necessário que a descrição narrativa seja capaz de atingir um nível de detalhamento adequado e que seja bastante clara.
2.1 – Do protótipo
	A elaboração do protótipo envolveu a identificação das opções necessárias no menu principal do aplicativo.
	Identifiquei que seria necessária uma opção para cada destino diferente e que a princípio o sistema trabalharia com 3 destinos: São Paulo, Curitiba e Belo Horizonte. Também seria necessária uma opção para que fosse exibido o fluxo de caixa. Por fim, seria necessária uma opção para sair do sistema.
	Definidas as necessidade do menu principal, foi providenciada sua codificação. Tomei o cuidado de não inserir o código de exibição do menu diretamente na função main() a fim de evitar que ficasse poluída. Optei por delegar essa tarefa à uma função chamada exibirMenuPrincipal() que é chamada pela função main(). O protótipo do menu ficou da seguinte forma:
 Bem vindo ao sistema de vendas de passagens da Viagens Tour Menu Principal 1 - Vender passagem para Sao Paulo 2 - Vender passagem para Curitiba 3 - Vender passagem para Belo Horizonte 4 - Gestao do Caixa 9 - Sair Selecione uma opcao: 
	A próxima etapa foi elaborar a exibição do menu secundário, que seria exibido após a seleção de um destino pelo usuário. Em minha concepção, o sistema deveria exibir na tela uma representação das poltronas do ônibus. Essa representação deveria exibir o número das poltronas e sua ocupação. A ocupação seria indicada pelo caracteres '-', 'I', 'C' e 'E' que representam respectivamente, uma poltrona vazia, uma poltrona ocupada por idoso com gratuidade, uma poltrona ocupada por um pagante comum e uma poltrona ocupada por um estudante. Na tela são exibidas 4 poltronas por linha, representando as duas poltronas do lado esquerdo e as duas poltronas do lado direito.
	Além de exibir as poltronas e suas ocupações, também é exibido o destino, os valores de todos os tipos de passagens.
	Por fim, o usuário é solicitado a digitar o número da poltrona a ser vendida ou digitar -1 para retornar ao menu principal. Eis o protótipo do menu:
 Exibindo Assentos Disponiveis para Curitiba 01| - | 02| - | 03| - | 04| - | 05| - | 06| - | 07| - | 08| - | 09| - | 10| - | 11| - | 12| - | 13| - | 14| - | 15| - | 16| - | 17| - | 18| - | 19| - | 20| - | 21| - | 22| - | 23| - | 24| - | 25| - | 26| - | 27| - | 28| - | 29| - | 30| - | 31| - | 32| - | 33| - | 34| - | 35| - | 36| - | 37| - | 38| - | 39| - | 40| - | 41| - | 42| - | 43| - | 44| - | 45| - | 46| - | 47| - | 48| - | O valor da passagem comum eh de R$60.00 Estudantes pagam R$30.00 Idosos pagam R$0.00 (maximo de 2 por veiculo) Digite o numero do assento a ser vendido ou -1 para voltar: 
	Os dois menus apresentados finalizaram a etapa inicial de prototipação e a partir de então foi possível inciar a próxima etapa.
	Como estamos trabalhando em um modelo incremental, depois de modeladas e desenvolvidas as funcionalidades dos menus principais e secundários, retornnei à fase de prototipação por mais duas vezes a fim de desenvolver os protótipos do fluxo de caixa e da emissão do ticket.
	Eis o protótipo do relatório de representa o fluxo de caixa com todas as transações realizadas durante a execução do sistema. Também é exibido o saldo de todas as transações efetudas. Os valoressão exibidos com o símbolo da moeda e com duas casas decimais.
 Movimentacao do Caixa R$27.50 R$55.00 R$22.50 R$45.00 R$30.00 R$60.00 O saldo no caixa eh de R$240.00 Press any key to continue . . . 
	
	Abaixo, o protótipo do módulo de impressão do ticket. São impressos: o local de destino, a data e o horário da partida, o número do ônibus e o número da poltrona.
 ************************************* * Comprovante de Compra de Passagem * ************************************* Destino Curitiba Partida as 14:30 do dia 16/12/2015 Onibus numero: 4433 Poltrona: 26 Press any key to continue . . . 
2.2 – Da Modelagem
	Com as principais interfaces prontas pude começar a elaborar a lógica a ser seguida pelo sistema. Como mencionei anteriormente, optei por descrever toda a lógica por meio de uma descrição narrativa. Concluí que tal abordagem seria mais efetiva em relação à utilização do portugol ou da elaboração de fluxogramas.
	Deitel e Deitel (2011), em seu livro “C: Como Programar”, também se utilizam do método de descrição narrativa, denominando-o como “Pseudocódigo”. Em sua definição, o pseudocódigo é uma linguagem artificial e informal, semelhante à linguagem do dia a dia que ajuda os programadores a desenvolver algoritmos.
	Voltando ao nosso sistema de passagens, a elaboração da lógica do menu principal foi bastante simples. Limitando-se à conduzir o usuário para o menu secundário correto. A descrição narrativa ficou da seguinte forma:
 Caso o usuário selecione a opção 1: 	Exiba a tela de venda do veículo que irá à São Paulo Caso o usuário selecione a opção 2: 	Exiba a tela de venda do veículo que irá à Curitiba Caso o usuário selecione a opção 3: 	Exiba a tela de venda do veículo que irá à Belo Horizonte Caso o usuário selecione a opção 4: 	Exiba o fluxo de caixa Caso o usuário selecione a opção 9: 	Permite a saída do loop que mantém o menu 
	Na tela de venda de passagens acabou sendo concentrada praticamente toda a lógica do programa, levando à uma descrição um pouco mais extensa. Aqui precisamos saber qual veículo foi selecionado no menu anterior e então exibir suas informações ao usuário. Depois será solicitado ao usuário que selecione uma poltrona e o tipo de passagem, efetuando-se as verificações de disponibilidade. Após a confirmação da venda, precisamos emitir um ticket, registrar a transação e indicar ao sistema que a poltrona se encontra ocupada.
	Abaixo segue a descrição narrativa do algoritmo elaborado para executar essas tarefas.
 Exibir as informações do veículo selecionado Exibir a tabela dos assentos do veículo selecionado Exibir os valores para todos os tipos de passagens Solicitar ao usuário que selecione uma poltrona Verificar se é uma poltrona válida – Se não for – exibir mensagem Verificar se a poltrona está vazia - Se não estiver – exibir mensagem 	Solicitar ao usuário que informe o tipo de passagem Se a passagem for de idoso, verificar disponibilidade – Se não, exibe msg 		Remover um dos lugares disponíveis para idosos 	Preencher a tabela de assentos do veículo com o caractere adequado Registrar a transação de acordo com o valor da passagem 	Imprimir Ticket Retornar ao menu de vendas 
3 – Da Implementação das Funcionalidades
	
	Antes de inicializar a implementação de qualquer funcionalidade, identifiquei que havia vários erros ocorrendo durante a execução dos protótipos. Então precisei tratá-los antes de iniciar o desenvolvimento.
	O primeiro desses erros se dava pela utilização da função scanf() para obtenção de uma opção a ser digitada pelo usuário. Todos os menus elaborados, solicitam ao usuário a seleção de uma opção por meio da entrada de um número inteiro. Porém, o sistema se comportava de forma inadequada quando o usuário digitava um caractere.
	Em uma rápida busca ao Google, percebi que vários novatos sofriam com o mesmo problema. Rapidamente acabei chegando ao site stackoverflow.com, onde é possível encontrar sugestões da comunidade para os mais diversos problemas. Ali, eu descobri que a função scanf() retorna um inteiro representando o número de atribuições efetuadas com sucesso. Se o valor de retorno da função scanf(“%d”, &opcao) for igual à 0, significa que a entrada do usuário foi inválida.	
	Então, para contornar os erros apresentados criei a função solicitarInt(), que solicita a entrada de um inteiro e o armazena na variável valorDigitado. É feita a verificação do retorno da função scanf(). Enquanto a função scanf(%d, %valorDigitado) não retornar o valor 1, indicando que a atribuição solicitada foi efetuada com sucesso, o sistema ficará em loop solicitando ao usuário a entrada de um número. Quando o usuário digitar um número a função o armazenará com sucesso na variável valorDigitado e o retornará à função chamadora.
	Mesmo tomando estes cuidados a função solicitarInt() ainda entrava em loop infinito quando o usuário entrava com um caractere. Segundo as experiências relatadas no site stackoverflow.com, isso se devia à existência de sujeira no buffer de entrada.
	Então precisei criar uma função para esvaziar o buffer de entrada do teclado, pois as informações ali armazenadas ainda causavam erros no sistema. Essa função é executada imediatamente após um scanf inválido e consiste em executar a função getchar() até que se encontre uma quebra de linha (\n) ou um indicador de fim de arquivo (EOF).
	Após esta implementação, os erros deixaram de ocorrer.
 int solicitarInt(){ int valorDigitado; while (scanf("%d", &valorDigitado)!=1){ esvaziarBufferEntrada(); printf("Digite um numero: "); } return valorDigitado; } 
 void esvaziarBufferEntrada(){ char c; while((c = getchar()) != '\n' && c != EOF); } 
	Outro problema identificado refere-se à portabilidade do sistema, pois sou usuário Linux e senti certa frustração ao não conseguir executar os protótipos desenvolvidos em Windows. Identifiquei que o problema residia na utilização da função system() com os argumentos “cls” e “pause” nativos do Windows. Segue abaixo a solução encontrada.
	Criei a função pausar() e substituí todos os usos de system(“pause”) pela função criada. Sua funcionalidade resume-se à exibir a mensagem “Pressione ENTER para continuar” enquanto uma chamada à função getchar() deixa o sistema à espera de uma entrada. A existência de resíduos de informação em buffer também prejudicaram o funcionamento da função. Desta forma incluí uma chamada à função esvaziarBufferEntrada(). Problema resolvido, com direito à uma demonstração da importância da criação de funções objetivas que possam ser reutilizadas.
 void pausar(){ printf("\nPressione ENTER para continuar.\n"); esvaziarBufferEntrada(); getchar(); } 
	A alternativa para utilização de system(“cls”) foi mais complexa e envolveu a utilização de outra sugestão encontrada em stackoverflow.com. A solução se utiliza da Compilação Condicional abordada por Deitel e Deitel(2011) no Capítulo 13 do livro “C Como Programar”. Através das diretivas #ifdef, #elif, #endif verifica-se o sistema operacional em execução e orienta-se o compilador a compilar apenas a instrução adequada. Criei a função limparTela() implementando essas diretivas.
 void limparTela(){ #ifdef linux system ("clear"); #elif defined WIN32 system ("cls"); #else printf("\e[H\e[2J"); #endif } 
	A partir deste momento o sistema se tornou portável. É possível compilá-lo e executá-lo com sucesso em sistemas Windows e Linux.
3.1 - Da Implementação dos Veículos
	De posse do protótipo e da descrição narrativa, concluí que a próxima etapa deveria ser a criação de uma estrutura que pudesse representar um veículo e as informações deste veículo que seriam necessárias ao sistema. A utilização de uma estrutura visa facilitar a adição de vários veículos com destinos, datas e horários diferentes.
	Assim, foi criado o struct de nome “veiculo” que contém as informações de: Destino, Valor da Passagem, Data da Partida, Hora da Partida, Número do Veículo, Poltronas Disponíveis para Gratuidade de Idosos e um vetor, com 48 posições,representando todas as poltronas do ônibus.
 struct veiculo{ 	char tabelaPoltronas[QUANTIDADE_POLTRONAS]; 	int idososDisponiveis; 	float valorPassagemComum; 	char destino[15]; 	char dataPartida[15]; 	char horaPartida[15]; 	int numeroVeiculo; }; 
	O campo idososDisponiveis foi criado para facilitar o gerenciamento das gratuidades já oferecidas. Sem este campo, uma das soluções alternativas seria percorrer todos os 48 assentos, a fim de identificar quantos idosos com passagens gratuitas estavam no ônibus.
	O vetor tabelaPoltronas[] foi criado para facilitar a administração das poltronas e exibir para o usuário a ocupação do veículo. Optei por criar um vetor do tipo caractere, criando também constantes que representam cada tipo de ocupação possível. O caractere 'I' representa um assento ocupado por idoso. O caractere 'E' representa um assento ocupado por estudante. O caractere 'C' representa um assento ocupado por quem comprou a passagem comum. Por fim o caractere '-' representa um assento vago. Se o cliente quiser que os assentos vagos passem a ser representados pelo caractere 'X', basta substituir o valor da respectiva constante.
	Criei o tipo “Veiculo” referindo-se à estrutura “veiculo” e criei três variáveis deste tipo a fim de representar os ônibus com destino à São Paulo, Curitiba e Belo Horizonte. As variáveis foram denominadas veiculoSP, veiculoCTB e veiculoBH respectivamente.
 /* Cria objetos do tipo struct veiculo para cada um dos veículos para o qual será disponibilizada a venda de passagens */ typedef struct veiculo Veiculo; Veiculo veiculoSP, veiculoCTB, veiculoBH; 
	A próxima etapa foi providenciar a inicialização das variáveis do tipo “Veiculo”. Criei a função inicializarVeiculos(). Nesta função são inicializadas as informações todos os veículos. Segue abaixo a inicialização do veículo com destino à São Paulo. Os demais veículos foram inicializados da mesma forma e dentro da mesma função mas com seus respectivos dados.
 void inicializarVeiculos(){ 	//incializa as informações do veículo com destino à São Paulo 	strcpy(veiculoSP.destino, "Sao Paulo");	 	strcpy(veiculoSP.dataPartida, "15/12/2015"); 	strcpy(veiculoSP.horaPartida, "11:20"); 	veiculoSP.numeroVeiculo = 7700; 	veiculoSP.valorPassagemComum = 45.0; 	veiculoSP.idososDisponiveis=2; 	inicializarPoltronas(&veiculoSP); } 
	O vetor tabelaPoltronas[] de cada veículo é inicializado pela função inicializarPoltronas() que preenche todos os itens do vetor com o caractere que representa um assento vago.
 /* Inicializa a tabela de poltronas do veiculo. Preenchendo todos os assentos com o indicador de assento vago. A tabela é representada por um vetor de char e o assento vago é representado pelo char definido na constante ASSENTO_VAGO */ void inicializarPoltronas(Veiculo *pVeiculo){ 	int cont; 	for(cont=0; cont<QUANTIDADE_POLTRONAS; cont++){ 		pVeiculo->tabelaPoltronas[cont] = ASSENTO_VAGO; 	} } 
3.2 – Da Implementação das Vendas
	O aplicativo se inicia com a exibição do menu principal através da função exibirMenuPrincipal(). Nesta função, o usuário será solicitado a selecionar um destino para o qual serão vendidas as passagens. Quando um destino for selecionado, será passada uma referência do respectivo veículo à função mnuVenderPassagem().
	Todo o sistema de vendas está implementado na função mnuVenderPassagem(), que recebe uma referência ao veículo referente ao destino selecionado pelo usuário. Ao receber uma referencia do tipo Veiculo, a função passa a ser reutilizável para qualquer veículo e assim evitamos a redundância de código. Esta função é responsável por exibir as informações do destino, os valores das passagens, a representação das poltronas com sua ocupação. Solicita ao usuário que informe o número da poltrona a ser vendida e depois solicita o tipo de passagem (comum, idoso ou estudante). Por fim realiza a venda, registra a transação no fluxo de caixa, por meio da função inserirTransacao() e emite o comprovante de compra por meio da função imprimirTicket().
	Dentro da função mnuVenderPassagem() também é verificado se a poltrona selecionada já está ocupada e se o limite de gratuidades para idosos já foi atingido.
	Como podemos notar, a função mnuVenderPassagem() é uma forte candidata à ser desmembrada em funções menores e mais específicas. Por falta de tempo e também por receio de fazer com que o código fique de difícil compreensão, optei por manter desta forma.
	Ainda assim, a função se utiliza de vários outras funções menores como imprimirTicket() que recebe o número da poltrona vendida e uma referência ao veículo e imprime todas as informações da viagem como data de horário da partida, número do ônibus, número da poltrona e destino.
 /* Exibe na tela o comprovante de compra da passagem */ void imprimirTicket(int numPoltrona, Veiculo *pVeiculo){ 	limparTela(); 	printf("*************************************\n"); 	printf("* Comprovante de Compra de Passagem *\n"); 	printf("*************************************\n"); 	printf("Destino %s\n\n", pVeiculo->destino); 	printf("Partida as %s do dia %s\n\n", pVeiculo->horaPartida, pVeiculo->dataPartida); 	printf("Onibus numero: %d Poltrona: %02d\n\n", pVeiculo->numeroVeiculo, numPoltrona); 	pausar(); } 
 void exibirAssentos(Veiculo *pVeiculo){ 	int numPoltrona; 	for(numPoltrona=0; numPoltrona<QUANTIDADE_POLTRONAS; numPoltrona++){ 		//Quebra uma linha a cada quatro poltronas 		if (numPoltrona % 4 == 0){ 			printf("\n"); 		} 		//Exibe o número da poltrona e um character representando sua ocupação		 		printf("%02d| %c | ", numPoltrona+1, pVeiculo->tabelaPoltronas[numPoltrona]); 	}} 
	A função mnuVenderPassagem() também se utiliza da função exibirAssentos() que recebe uma referência ao veículo e exibe na tela uma representação das poltronas do veículo e sua ocupação.
	A fim de facilitar eventual mudança nas regras de preços para idosos e estudantes, a função mnuVenderPassagem se utiliza das funções getValorEstudante() e getValorIdoso() que são responsáveis por calcular os valores das passagens para estudantes e idosos com base nas regras definidas.
 /* Calcula e retorna o valor da passagem de estudante para o veiculo informado. A existência desta função facilita e centraliza a implementaçõa de uma eventual alteração no valor da passagem para estudantes */ float getValorEstudante(Veiculo *pVeiculo){ 	return pVeiculo->valorPassagemComum/2; } /* Calcula e retorna o valor da passagem de idoso para o veiculo informado. A existência desta função facilita e centraliza a implementaçõa de uma eventual alteração no valor da passagem para idosos */ float getValorIdoso(Veiculo *pVeiculo){ 	return 0.0; } 
3.3 – Da implementação do Registro do Fluxo de Caixa
	A funcionalidade de registro do fluxo de caixa foi a última a ser inserida no projeto. Optei por utilizar uma estrutura de lista ligada pois não há como saber antecipadamente a quantidade de registros a serem armazenados e desta forma fica descartada a possibilidade de utilização de um vetor ou matriz estáticos.
	Criei uma estrutura chamada “transacao” contendo o valor da transação e um ponteiro para a próxima transação da lista. Futuramente pode-se adicionar outras propriedades à estrutura de forma a detalhar a transação.
 /* Cria a estrutura de uma transacao contendo os campos necessarios incluindo um ponteiro para o proximo item a fim de criar uma lista */ struct transacao{ 	float valor; 	//char descricao[]; 	struct transacao *proximaTransacao; }; /* Cria o tipo Transacao representantdo a estrutura transacao e cria um objeto listaTransacoes do tipo Transacao que armazenará as operações efetuadas, garantindo o controle do caixa */ typedef struct transacao Transacao; Transacao* listaTransacoes; 
	Toda vez que a função mnuVenderPassagem() finaliza uma venda, é chamada a função void registrarTransacao() que encapsula parte do código e em conjunto com a função inserirTransacao() insere o valor da venda na lista.
 /*Função a ser chamada diretamente para inserçãode transações. O objetivo é encapsular uma parte do código necessário e tornar mais simples a chamada de inserção.*/ void registrarTransacao(float num){ listaTransacoes = inserirTransacao(listaTransacoes, num); } 
 /*Função para inserir transações no relatório de caixa. Não deve ser chamada diretamente.*/ Transacao* inserirTransacao (Transacao *pLista, float num){ 	Transacao* nova_Transacao = (Transacao*)malloc(sizeof(Transacao)); 	nova_Transacao->valor = num; 	nova_Transacao->proximaTransacao = pLista; } 
	O registro do fluxo de caixa foi implementado com utilização dos conhecimentos adquiridos na Unidade VII da disciplina de Linguagem e Técnicas de Programação. Todo o registro se dá através das funções inicializarTransacoes(), inserirTransacao(), registrarTransacao, imprimeTansacoes() e da estrutura “transacao”.
 /* Imprime o relatório do caixa e o saldo existente */ void imprimeTransacoes (Transacao *pLista){ 	float total = 0.0; 	Transacao* aux; 	 	limparTela(); 	printf("Movimentacao do Caixa\n\n"); 	for (aux = pLista; aux !=NULL; aux = aux->proximaTransacao){ 		printf ("R$%.2f\n", aux->valor); 		total += aux->valor; 	} 	 	printf("\nO saldo no caixa eh de R$%.2f\n\n", total); 	pausar(); } 
	A impressão de todo o fluxo de caixa pode ser realizada através do menu principal.
Conclusão
	Para a implementação de um sistema de pequeno porte, os métodos adotados neste projeto como os conceitos essenciais dos métodos ágeis, prototipação e modelagem por meio de descrição narrativa foram adequados e eficientes.
	A versão final do sistema desenvolvido neste projeto atende às especificações previstas no manual, de forma satisfatória. Não foram identificados erros durante sua execução.
Referências:
UNIP – UNIVERSIDADE PAULISTA. Engenharia de Software I. São Paulo, 2014.
UNIP – UNIVERSIDADE PAULISTA. Linguagem e Técnicas de Programação. São Paulo, 2014.
MANZANO, José Augusto N. G.; OLIVEIRA, Jayr Figueiredo de. Algoritmos: Lógica para Desenvolvimento de Programação de Computadores. 21ª edição. São Paulo: Érica, 2008.
DEITEL, Paul; DEITEL, Harvey. Java: Como Programar. 8ª edição. São Paulo: Pearson, 2011.
DEITEL, Paul; DEITEL, Harvey. C: Como Programar. 6ª edição. São Paulo: Pearson, 2011.