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
 5

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.
 6

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.
 7

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
 8

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.
 9

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 . . .
 10

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.
 11

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
 12

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
 13

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.
 14

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
 15

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.
 16

/*
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.
 17

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

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.

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]);
}}
 18

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.
 19

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

/*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”.
A impressão de todo o fluxo de caixa pode ser realizada através do menu principal.

/*
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();
}
 21

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.
 22

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.