Unip Interativa PIM IV Sistema de Vendas de Ingressos

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

UNIP INTERATIVA
Projeto Integrado Multidisciplinar
Cursos Superiores de Tecnologia
DESENVOLVIMENTO DE SOFTWARE
Sistema de Venda de Passagens
Polo XXXXXXX/UF
Ano
UNIP INTERATIVA
Projeto Integrado Multidisciplinar
Cursos Superiores de Tecnologia
DESENVOLVIMENTO DE SOFTWARE
Sistema de Venda de Passagens
						NomeNomeNomeNomeNomeNome
						RA: 00000000000
						Curso: Análise e Desenvolvimento de Sistemas
						Semestre: 01
Polo XXXXXXX/UF
Ano
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 valores sã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ção de 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.