UNIP INTERATIVA

Projeto Integrado Multidisciplinar

Cursos Superiores de Tecnologia

SISTEMA PARA VENDA DE PASSAGENS DE ÔNIBUS EM LINGUAGEM C.

PIM IV DP

2017
 UNIP INTERATIVA
Projeto Integrado Multidisciplinar
Cursos Superiores de Tecnologia

SISTEMA PARA VENDA DE PASSAGENS DE ÔNIBUS EM LINGUAGEM C.

PIM IV DP

Alex Skopek Abrão RA: 1514095

Luis Fernando Alves Ferreira RA: 1616430
Rafael Martins Maciel RA: 1400550
Rafael Navarro Cintra RA: 1528679

Curso: Análise e Desenvolvimento de Sistemas

POLO MARQUÊS
2017
RESUMO
 O presente trabalho consiste na elaboração de um sistema para vendas de
passagens de ônibus, sistema esse que foi solicitado por uma nova empresa que
atuará fazendo transporte intermunicipal de passageiros dentro do estado de São
Paulo, mediante as exigências e necessidades colhidas juntamente com a empresa
foram feitos todos os levantamentos de requisitos e a estruturação do projeto, e com
a utilização do software DEV C++ e a linguagem C, foi desenvolvido o sistema
solicitado, suprindo assim todas as demandas apresentadas pela empresa, tais
como limite de gratuidades, um bom controle de vendas de passagens e controle de
fluxo de caixa, trazendo assim maior agilidade para a empresa e segurança e
comodidade para seus passageiros.

Palavras-chave: DEV C++, Linguagem C, Sistema, Transporte, Venda de

Passagem.

ABSTRACT
 The present work consists in the elaboration of a system for sales of bus
passes, a system that was requested by a new company that will act as intermodal
transport of passengers within the state of São Paulo, through the requirements and
necessities collected together with the company were The requirements and the
structuring of the project, and with the use of the software DEV C ++ and the C
language, the requested system was developed, thus supplying all the demands
presented by the company, such as gratuity limit, a good control of Ticket sales and
cash flow control, thus bringing greater agility to the company and safety and
convenience to its passengers.

Keywords: DEV C ++, Language C, System, Transport, Ticket Sale.

SUMÁRIO

1. INTRODUÇÃO..........................................................................................................6
2. PROPOSTA DO TRABALHO...................................................................................7
3. CICLO DE VIDA DO SISTEMA................................................................................7
4. LEVANTAMENTO DE REQUISITOS........................................................................8
4.1. Requisitos funcionais:.........................................................................................8
4.2. Requisitos não funcionais:.................................................................................8
5. MODELAGEM E DESENHO DE ARQUITETURA...................................................9
5.1. Casos de uso......................................................................................................10
6. LÓGICA DE PROGRAMAÇÃO..............................................................................11
7. CODIFICAÇÃO.......................................................................................................12
8. O SISTEMA - LAYOUT...........................................................................................17
8.1. Fundo de caixa...................................................................................................17
8.2. Tela inicial...........................................................................................................18
8.3. Comprar passagem............................................................................................18
8.3.1 Escolha de assento..........................................................................................19
8.4. Passagem estudante..........................................................................................21
8.5. Emissão de Ticket..............................................................................................21
8.6. Controle de caixa...............................................................................................23
9. TESTES...................................................................................................................24
10. IMPLANTAÇÃO....................................................................................................26
10.1. Suporte e manutenção.....................................................................................26
11. CONCLUSÃO........................................................................................................27
REFERÊNCIAS...........................................................................................................28
ANEXOS.....................................................................................................................29

LISTA DE FIGURAS

Figura 1– Ciclo Cascata................................................................................................7

Figura 2 – Casos de uso.............................................................................................10
Figura 3 – Fluxograma................................................................................................11
Figura 4 – Fundo de caixa..........................................................................................17
Figura 5 – Tela inicial...................................................................................................18
Figura 6 – Comprar passagem...................................................................................19
Figura 7 – Escolha de assento....................................................................................19
Figura 8 – Idade passageiro.......................................................................................20
Figura 9 – Gratuidade.................................................................................................20
Figura 10 – Estudante.................................................................................................21
Figura 11 – Ticket Estudante.......................................................................................22
Figura 12 – Ticket Idoso Gratuito................................................................................22
Figura 13 – Ticket Integral...........................................................................................23
Figura 14 – Controle de Caixa....................................................................................24
Figura 15 – Ônibus Lotado..........................................................................................25
Figura 16 – Gratuidade esgotada...............................................................................25
Figura 17 – Assento Indisponível................................................................................26
 1. INTRODUÇÃO

O objetivo desse projeto é apresentar os procedimentos adotados para a

realização da documentação e a elaboração de um sistema para vendas de
passagens de ônibus, sistema esse que foi solicitado por uma nova empresa
que atuará fazendo transporte intermunicipal de passageiros dentro do estado
de São Paulo.
O primeiro passo para elaboração do sistema foi a realização de uma
reunião com os sócios da empresa, onde os mesmos tiveram a oportunidade
de expor suas necessidades e expectativas com relação ao funcionamento do
sistema e suas ferramentas, foi proposto a elaboração do processo de software
que nada mais é que o conjunto de atividades que constituem o
desenvolvimento de um sistema e dentro desse processo foi escolhido o
modelo de ciclo de vida a ser adotado. O modelo de ciclo de vida adotado foi o
em Cascata, pois dará ênfase às fases de análise e projeto antes de partir para
a programação, a fim de que o objetivo do software esteja bem definido e que
sejam evitados retrabalhos.
Colocando em prática os conceitos aprendidos nas disciplinas de
Linguagem e técnicas de programação e Engenharia de software foi feito toda
a análise e o levantamento de requisitos do sistema e através da utilização da
ferramenta DEV C++ juntamente com a linguagem C foi desenvolvido o
sistema de acordo as necessidades da empresa.

6
 2. PROPOSTA DO TRABALHO

A empresa solicitante dos serviços para desenvolvimento do sistema

atua no ramo de transportes, mais precisamente fazendo transporte
intermunicipal de passageiros dentro do estado de São Paulo. A fim de prestar
um serviço com qualidade e segurança para seus clientes e tornar mais ágil o
seu processo de trabalho, seus sócios decidiram implementar um novo sistema
de vendas de passagens.

3. CICLO DE VIDA DO SISTEMA

Mediante reunião com os sócios da empresa o modelo de ciclo de vida

adotado foi o em Cascata. O modelo cascata sugere uma abordagem
sequencial e sistemática para o desenvolvimento de sistema, começamos com
o levantamento de requisitos ou necessidades junto ao cliente, após essa fase
vamos para a fase de planejamento onde são definidas as estimativas e
acompanhamento, em seguida iremos para a modelagem onde fazemos a
análise e projeto, na parte final passamos para a codificação e teste do sistema
para só assim podermos entregar o sistema concluído.

Figura 1– Ciclo Cascata

4. LEVANTAMENTO DE REQUISITOS

7
 Para o levantamento de requisitos foi utilizado à técnica de entrevista,
pois a entrevista é uma das técnicas tradicionais mais simples de utilizar e que
produz bons resultados na fase inicial de obtenção de dados. Isso ocorre, pois
entrevistador dá espaço ao entrevistado (Sócios da empresa) para esclarecer
as suas necessidades. Suas vantagens é que com um plano geral bem
elaborado, o analista terá facilidade em descobrir qual informação o usuário
está mais interessado, podendo alterar o curso da entrevista de forma a obter
informações sobre aspectos importantes que não tinham sido previstos no
planejamento da entrevista, além de poder motivar o entrevistado no decorrer
do processo.
Mediante entrevista realizada foram levantados os requisitos funcionais
e não funcionais do sistema.

4.1. Requisitos funcionais:

 O sistema deverá levar em consideração uma tabela de tarifação

com um determinado valor para as passagens;
 Até duas passagens podem ter gratuidade de 100% (para idosos);
 Estudante tem direito de comprar passagens com 50% de desconto;
 Ao concretizar a compra da passagem o sistema deverá emitir um
ticket com a data e a hora da partida do ônibus, o local de destino, o
número do ônibus e o número da poltrona;
 O Sistema deverá fazer a gestão do caixa, informando no
fechamento do caixa todas as movimentações do dia e o saldo do
fechamento.

4.2. Requisitos não funcionais:

 O Sistema terá uma interface simples, amigável e intuitiva;

 O sistema deve ser confiável;
 O sistema deve ter um bom desempenho, ser eficiente e exato;
 Nenhum passageiro pode ter uma passagem com o mesmo número
de poltrona de outro passageiro no mesmo ônibus;
8
  O sistema deverá informar quando não existir mais lugares
disponíveis e, consequentemente, não permitir mais a venda de
passagens para o ônibus em questão;

5. MODELAGEM E DESENHO DE ARQUITETURA

Após a produção e aprovação do documento de requisitos, a equipe

técnica traduz os requisitos do produto em desenhos de arquitetura, identifica e
pontos de integração, nesse momento a prioridade passar a ser a modelagem
e o desenho de arquitetura, a modelagem de software trata-se de construir
modelos gráficos que expliquem as características ou o comportamento de um
software ou de um sistema. Na construção do software os modelos podem ser
usados na identificação das características e funcionalidades que foram
colhidas na fase de análise de requisitos que o software deverá prover, e no
planejamento de sua construção.
Para construção do design são utilizadas ferramentas CASE, utilizamos
para o desenvolvimento nesse projeto a ferramenta chamada DIA que é uma
ferramenta baseada no Microsoft VISIO onde é possível fazer layouts,
organogramas, fluxogramas e diagramas em geral. As ferramentas de
modelagem de sistemas fornecem ao engenheiro de software a habilidade de
modelar todos os elementos de um sistema baseado em computador usando
uma notação que é específica para aquela ferramenta. Em geral, as
ferramentas nessa categoria possibilitam a um engenheiro modelar a estrutura
de todos os elementos funcionais do sistema, o comportamento estático e
dinâmico do sistema, e a interface homem-máquina (BOOCH, RUMBAUGH, &
JACOBSON, 2000).

5.1. Casos de uso

O diagrama de casos de uso é usado para definir o que deve ser

realizado pelo sistema e o que existe fora dele, mostrando as interações entre
os atores e o sistema em seu cenário específico, portanto cada caso de uso
está ligado a um requisito funcional. Os principais elementos de um diagrama

9
de casos de uso são os Atores que são agentes externos que interagem com o
sistema, os casos de uso que apresenta cada funcionalidade do sistema, os
requisitos funcionais que serão implementados e as interações que se tratam
da comunicação do sistema com seus respectivos atores, ou seja, qual ator
tem ligação com o determinado caso de uso.
Conforme será ilustrado abaixo a interação com o sistema será feita pelo
atendente e o administrador do sistema, o cliente apenas fará a solicitação
para o atendente e não terá contato com o sistema.

Figura 2 – Casos de uso

6. LÓGICA DE PROGRAMAÇÃO

A lógica de programação é a técnica de desenvolver algoritmos para

atingir determinados objetivos, o algoritmo por sua vez é uma sequência não
ambígua de instruções que são executadas até que determinada condição se
verifique, mais especificamente, em matemática, constitui o conjunto de
processos e símbolos que os representam para efetuar um cálculo. Para
demonstrarmos a lógica do sistema usamos o fluxograma, pois representa a

10
graficamente o algoritmo por desenhos geométricos e sempre seguindo uma
sequencia lógica coerente, assim tornando mais simples o seu entendimento.

Figura 3 – Fluxograma
7. CODIFICAÇÃO

Para o desenvolvimento do software envolvido neste trabalho utilizamos

o DEV C++ como IDE (Integrated Development Environment) ou Ambiente de
Desenvolvimento Integrado.
Este compilador utiliza os compiladores do projeto GNU para conseguir
compilar programas baseados no sistema operacional Microsoft Windows. É
possível escrever programas utilizando-se das linguagens C e C++, possuindo
ainda suporte a toda biblioteca ANSI. A IDE foi desenvolvida utilizando-se a
linguagem que não será objetivo deste trabalho.

11
 No caso especifico de nosso projeto utilizamos a linguagem C para toda
a codificação desenvolvida no projeto. Seguem abaixo algumas características
importantes da linguagem C:

1. Um programa em C é composto por um conjunto de Funções.

2. A função pela qual o programa começa a ser executado chama-se
main.

3. Após cada comando em C deve-se colocar um ; (ponto-e-vírgula).

4. Um programa em C deve ser identado para que possa ser lido

com mais facilidade.

Além disso é importante discutirmos que tipos de componentes e

estruturas da linguagem foram utilizados em nosso desenvolvimento para
correto entendimento dos trechos de código produzidos em nosso trabalho.
Começaremos discutindo os identificadores, que nada mais são do que os
nomes que daremos as nossas funções ou variáveis.
Identificadores como dissemos acima são os nomes que daremos as
nossas funções ou variáveis. Para que isso seja feito de forma correta é
necessário seguir algumas regras universais que foram convencionadas para
que os códigos sejam compilados com sucesso.

 Um identificador deve iniciar por uma letra ou por um "_"

(underscore);
 A partir do segundo caractere pode conter letras, números e
underscore;

 Deve-se usar nomes significativos dentro do contexto do

programa;

 C é uma linguagem case-sensitive, ou seja, faz diferença entre

nomes com letras maiúsculas e nomes com letras minúsculas.
Peso e peso são diferentes;

 Costuma-se usar maiúsculas e minúsculas para separar palavras:

"PesoDoCarro";

12
  Deve ser diferente dos comandos da linguagem;

 Deve ter no máximo 31 caracteres (no caso do TurboC);

 Pode conter números a partir do segundo caractere.

Variáveis são formas que temos de dar nomes a posições em memória

para armazenamos valores que precisaremos para utilizar em nossa lógica de
programação. É possível atribuir novos valores através de comandos de
atribuição, onde alteramos o valor armazenado naquela posição de memória
para um novo valor durante a execução de nosso software.
Cada variável na linguagem C, assim como em outras linguagens,
possuem tipos diferentes que podem ser atribuídos a cada uma delas.
Especificamente em C, temos alguns tipos de variáveis e seus respectivos
exemplos abaixo:

 Char: letras e símbolos: 'a', 'b', 'H', '^', '*','1','0';

 Int: de -32767 até 32767 (apenas números inteiros)

 Float: de -3.4 x 1038 até +3.4 x 10+38com até 6 dígitos de

precisão

 Double: de -1.7 x 10308 até +1.7 x 10+308com até 10 dígitos de

precisão

É importante notar que cada variável possui apenas, e somente um tipo.

Além disso todas as variáveis de seu programa devem ser declaradas
corretamente antes de serem iniciadas com quaisquer valores.
No caso das variáveis vimos que elas podem ter seu valor alterado ao
longo do programa, caso tenhamos casos onde precisaremos lidar com valores
que não se alteram, temos um tipo especifico de estrutura chamada
CONSTANTES para este fim.
Usualmente em C utiliza-se o comando #define para se declarar
constantes no início do código-fonte do seu programa.
Existem ainda as variáveis do tipo String que são utilizadas para
armazenamento de um conjunto de caracteres que são declarados sempre
entre aspas duplas, ao se declarar estas variáveis é mandatório determinar a

13
quantidade de caracteres que esta variável será capaz de armazenar. Este
comando de atribuição de um valor a uma variável do tipo String se dá pelo
comando strcpy.
A função printf exibe dados na tela. Esta função deve receber pelo
menos dois parâmetros, separados por vírgula:

 String de formato que define, através de caracteres especiais, os tipos

dos dados a serem impressos e suas posições na linha de impressão;
 Dado a ser impresso. Este dado pode ser qualquer um dos dados visto
anteriormente.

Segue um exemplo do uso da função printf abaixo:

printf("%s","Codigo-Fonte");

"%s" : é a string de formato

"Codigo-Fonte" : é o dado a ser impresso.

A string de formato define quais os tipos dos dados a serem impressos,

enquanto o símbolo %s será substituído pelo dado que vem após a vírgula. Os
dados definem quais os valores a serem impressos.
Em alguns casos é necessário que um string de formato pode ter a
necessidade de definir que mais de um dado será impresso. Para que isso seja
possível, ao se utilizar a string de formato deve haver mais de um %, quantas
vezes tivermos dados a serem impressos. Neste caso, os dados devem vir
após a string de formato separados por vírgulas.

É possível ainda imprimir números inteiros utilizando-se da função printf

ao se utilizar o sinalizador %d. Caso estejamos trabalhando com números reais
deve-se utilizar o sinalizador %f, no caso dos números reais é possível ainda
determinar via código, de que forma o número será exibido na tela, para isso
usamos em conjunto com o %f uma determinação de quantas casas decimais o
número deve ter. Determina-se também o número total de caracteres do
número a ser impresso.

Por exemplo: %4.2f especifica que se quer imprimir um float com 2

casas decimais e com um tamanho total de 4 caracteres no total.

14
Seguem-se regras para impressão de um número real:

 O número de casas decimais é sempre respeitado. Se for preciso,

zeros serão acrescentados à direita do número
 O tamanho total significa o número de caracteres do número
incluíndo o ponto decimal e um eventual sinal de menos (-), se for
o caso;

 Se a soma do número de caracteres da parte inteira, mais o ponto

decimal, mais a parte fracionária, mais um eventual sinal de
menos ainda for menor do que o tamanho total especificado no
formato, então, espaços em branco serão acrescentados à
esquerda da parte real do número.

 Se a soma do número de caracteres da parte inteira, mais o ponto

decimal, mais a parte fracionária, mais um eventual sinal de
menos for maior do que o tamanho total especificado no formato,
então, apenas o número de casas decimais é respeitado.

Ainda se tratando de números, podemos lidar com os operadores

aritméticos:

 -: sinal de menos (unário) - Maior precedência (avaliado antes)

 *,/ - multiplicação e divisão

 % - módulo (reto da divisão)

 +,- - soma e subtração - Menor precedência (avaliado depois)

No caso de nosso programa ainda lidamos com uma parte importante da

linguagem C: as bibliotecas.
O nome e as características de cada função que fazem parte de
determinada biblioteca estão em um arquivo chamado cabeçalho, mas a
implementação das funções está em um arquivo separado. A nomenclatura e o
objetivo dos cabeçalhos é comum a diferentes implementações, mas a
organização das bibliotecas pode ser feita de forma diferente, isto significa que
cada compilador C possui sua implementação da biblioteca padrão C
especifica ao seu contexto.
15
 Como os compiladores C geralmente oferecem funcionalidades
adicionais que não são especificadas pelo ANSI C, a implementação da
biblioteca padrão de um compilador tende a não funcionar com os demais. Em
nosso programa utilizamos especificamente utilizamos as bibliotecas stdio.h e
stdlib.h.
A biblioteca stdio.h é uma das principais e mais usadas bibliotecas em C
pois é quem nos permite interagir com a entrada e saída de dados para os
programas sendo desenvolvidos, o seu nome vem do significado de standard
input and output, ou seja, padrão de entrada e saída.
Ela inclui as operações mais comuns como tratamento de entrada/saída
e conjunto de caracteres. Ao contrário de outras linguagens como COBOL,
Fortran e, C não inclui palavras-chave nativas para essas tarefas, o que
significa que praticamente todos os programas desenvolvidos em C farão uso
dela.
A biblioteca stdio.h por exemplo contem funções importantes como printf
e scanf, ambas amplamente usados em programas desenvolvidos em C.
Já a biblioteca stdlib.h funciona como um emulador do terminal do
sistema operacional em que você está trabalhando, caso seja Windows ele
emula todos os comandos do terminal do DOS, e caso você estiver trabalhando
no Linux, quem será emulado é o Terminal.
É através desta biblioteca que conseguimos com apenas algumas linhas
de código acessar pastas, mover diretórios e executar programas por exemplo.

8. O SISTEMA - LAYOUT

Mediante conclusão dos processos de levantamento de requisitos,

entendido a lógica que o sistema teria que seguir, feito a modelagem e design
do sistema, bem como a codificação, chegamos a finalização do sistema,
conforme todas as informações passadas pelo cliente foi elaborado um sistema
seguro, ágil e intuitivo onde os funcionários não terão problemas pois o próprio
sistema irá os guiando para os passos seguintes e em caso de advertência
sugiram mensagens com opções do que fazer.
Abaixo segue as telas com o layout do sistema e uma breve explicação
da função de cada tela.

16
 8.1. Fundo de caixa

Assim que o sistema é acessado a primeira tela que é exibida é a de

fundo de caixa, onde o funcionário digitara o valor inicial constante na abertura
de seu caixa.

Figura 4 – Fundo de caixa.

8.2. Tela inicial

Uma vez informado o valor inicial do caixa, chegamos a tela principal do

sistema, a tela inicial apresenta as funcionalidades do sistema com as opções
de compra de passagem, controle de caixa e a opção de sair do sistema,
abaixo está ilustrado o layout do mesmo o nos tópicos seguintes explicaremos
cada opção dessa tela.

17
Figura 5 – Tela inicial

8.3. Comprar passagem

Uma vez digitado a opção 1 – Comprar passagem, o sistema

automaticamente levará o usuário para a seguinte tela onde possui
informações como o Destino, horário de partida e o valor de cada passagem.

Figura 6 – Comprar passagem

8.1 Escolha de assento

Mediante escolha do destino solicitado pelo cliente a próxima tela a ser

exibida no sistema é a de escolha de assento.

18
Figura 7 – Escolha de assento

O funcionário digitará o assento escolhido pelo cliente, caso o assento

esteja ocupado o sistema emitirá o alerta de assento indisponível (tópico
testes), retornando novamente para a tela acima de escolha de assento, se o
assento informado estiver disponível a próxima tela que surgirá perguntara a
idade do passageiro.

Figura 8 – Idade passageiro

Caso o passageiro tenha idade inferior a 65 anos a próxima tela será a

respeito de passagens com 50% de desconto (tópico estudante) caso seja igual
ou superior a 65 anos o sistema avisará o direito a gratuidade e perguntará se
o funcionário quer verificar disponibilidade de assentos gratuitos, lembrando
que cada ônibus possui duas gratuidades para idosos

19
Figura 9 – Gratuidade

Após o sistema fazer a verificação caso tenha gratuidade disponível no

ônibus o mesmo já emitira a passagem gratuita (Varemos no tópico Ticket),
caso não tenha o sistema avisará (tópico testes) e dará a opção de comprar a
passagem com valor integral.

8.4. Passagem estudante

Informado a idade do passageiro caso o mesmo tenha idade inferior a 65

anos, ou tenha idade superior a 65, porém não haja mais gratuidade no ônibus,
o sistema automaticamente irá para a tela onde será perguntado ao atendente
se o passageiro é estudante ou não, caso o passageiro não seja estudante o
sistema emitira a passagem com o valor integral, caso o passageiro seja
estudante o sistema emitirá a passagem com 50% de desconto sobre o valor
integral, lembrando que não há limite de passagens com 50% de desconto no
ônibus.

20
Figura 10 – Estudante

8.5. Emissão de Ticket

Passado pelas etapas acima e na conclusão da venda o sistema emitira

o ticket onde será informado no mesmo o numero do ônibus, o destino
juntamente com o horário de saída, a data da viagem, o numero da poltrona e o
valor da passagem.

Figura 11 – Ticket Estudante

21
Figura 12 – Ticket Idoso Gratuito

Figura 13 – Ticket Integral

8.6. Controle de caixa

A última tela do sistema trata-se do controle de caixa, o controle de caixa

engloba a quantia que é inserida na abertura do caixa e vai somando conforme
o atendente vai efetuando as vendas de passagem, a opção pode ser
acessada a qualquer momento pela pagina inicial do sistema, opção 3.
Acessando a opção é mostrado todas as vendas efetuadas no dia contendo o
destino, o valor e se a passagem teve desconto, as passagem gratuitas
também aparecem por questão de controle, ao final é mostrado o SALDO EM

22
CAIXA onde é exibido a soma do fundo de caixa somado ao movimento diário
conforme explicado anteriormente.

Figura 14 – Controle de Caixa

9. TESTES

Com o objetivo de prevenir erros do sistema e se certificar de que todas

as funções estão com seu funcionamento perfeito, bem como atendendo a
todas as expectativas dos usuários conforme informações colhidas com
mesmo, foram realizados testes do sistema por completo, todas as funções
estão com o funcionamento correto, como uma grande preocupação da
empresa contratante era de trazer agilidade para seus funcionários e não trazer
problemas para os clientes, problemas esses que além da segurança poderiam
ser ocasionados por erros do sistemas como por exemplo vender mais
assentos que a capacidade do ônibus, ou até mesmo vender o mesmo assento
para mais de uma pessoa, englobamos no sistema funções para que o mesmo
faça controle de assentos disponíveis e que em caso de lotação do ônibus,
gratuidades esgotadas ou escolha de um assento já ocupado o sistema emitirá
um alerta para o funcionário informando a ocorrência e dando ao funcionário de
forma ágil a solução para o conflito.
Abaixo segue as telas do próprio sistema onde é tratado o conflito citado
acima.

23
 Quando todos os assentos do ônibus estiverem ocupados o sistema
emitira a seguinte mensagem (figura baixo), e não deixara mais vender
passagens para o ônibus em questão retornando para a tela inicial do Sistema.

Figura 15 – Ônibus Lotado

Caso o passageiro seja idoso, mas as duas passagens gratuitas que

cada ônibus oferece já estejam vendidas o sistema emitira o seguinte aviso:

Figura 16 – Gratuidade esgotada

Caso o atendente escolha um assento já ocupado o sistema emitira a

seguinte mensagem na tela (Figura abaixo), e depois retornará para tela de
escolha e assento novamente.

24
Figura 17 – Assento Indisponível

10. IMPLANTAÇÃO

Uma vez o programa codificado e validado pelo cliente, pode-se dar

início ao processo de implantação.
O processo de implantação de software tem como principal objetivo
disponibilizar o programa ao usuário final, de forma que este, atenda ás
necessidades iniciais para o qual fora desenvolvido.

10.1. Suporte e manutenção

Visando viabilizar o suporte e manutenção do software, utilizamos de

técnicas de engenharia de software, tanto na coleta de requisitos (para evitar
retrabalho) como no processo de desenvolvimento em si.
Para o processo de desenvolvimento foi utilizado o modelo cascata, o
qual possui como forte característica, ser orientado à documentação, ou seja,
tudo o que é desenvolvido, é devidamente documentado. Esta característica,
além de ser indispensável durante o desenvolvimento, torna-se uma base para
o suporte e manutenções futuras no software já em produção.

11. CONCLUSÃO

25
 Ao termino do trabalho alcançamos os objetivos propostos e soluções
aos desafios apresentados para o desenvolvimento do sistema para venda de
passagens de ônibus de viagens em linguagem C com a qualidade de software
desejada.

Uma vez levantados os requisitos do software o uso de diagramas de

casos de usos e fluxograma determinou a lógica de programação que foi
adotada. Ter em mente o que se queria alcançar e ter uma visão gráfica geral
do caminho que o sistema tinha que percorrer foi um pilar no desenvolvimento
do sistema proposto. Ajudou a identificar passos chaves para a codificação do
sistema, como por exemplo, a diferenciação de preços das passagens e limites
de passagens e gratuidade.

O modelo cascata foi escolhido como o modelo de ciclo de vida e

terminou os rumos do desenvolvimento do programa. Com isso observamos
como é uma boa prática levantarmos os requisitos, analisar e projetar antes de
começar qualquer codificação em si. O modelo cascata proporcionou uma base
consistente para uma codificação de sucesso e forneceu parâmetros para as
fases de testes eficientes e por fim estabeleceu os procedimentos para
implantação, suporte e manutenção do sistema.

O DEV C++ se mostrou como uma ferramenta de ambiente gráfico

integrado eficiente e eficaz na elaboração do código fonte do programa na
linguagem C. Proporcionou uma forma fácil de desenvolver um código
visivelmente amigável e organizado. Para tanto contamos com ferramentas do
DEV C++ como a endentação automática, recurso de autocompletar,
detectores de erro de sintaxe, dentre outros.

Seguindo esses procedimentos para elaborar a lógica de programação,

adotando as atividades propostas pelo modelo cascata e com auxilio do
programa DEV C++, constitui-se os módulos do sistema proposto e sua
implantação com qualidade desejada.

26
 REFERÊNCIAS

http://www.devmedia.com.br/ciclos-de-vida-do-software-artigo-revista
engenharia-de-software-magazine-36/21099

http://www.danresa.com.br/fabrica-de-software/index.php/principais-tecnicas-
de-levantamento-de-requisitos-de-sistemas/

CARVALHO, Adriane M. B. Rizzoni; CHIOSSI, Thelma C. dos Santos.

Introdução à engenharia de software. Campinas, SP. Ed UNICAMP, 2001

FILHO, Wilson de Pádua Paula. Engenharia de software Fundamentos,

Métodos e Padrões. Rio de Janeiro, RJ. Ed LTC, 2001

FOURNEIR, Roger. Guia prático para desenvolvimento e manutenção de

sistemas estruturados. São Paulo. Ed. Makron Books, 1994

https://www.profissionaisti.com.br/2011/06/levantamento-de-requisitos-voce-
sabe-o-que-e/

https://pt.wikipedia.org/wiki/Diagrama_de_caso_de_uso

http://academicotech.blogspot.com.br/2014/02/v-behaviorurldefaultvmlo.html

http://www.bloodshed.net/devcpp.html

https://programacaodescomplicada.wordpress.com/indice/linguagem-c/

http://www.inf.pucrs.br/~pinho/LaproI/IntroC/IntroC.htm

http://programando-ads.blogspot.com.br/2012/02/para-que-servem-as-
bibliotecas-e.html

https://www.tutorialspoint.com/c_standard_library/

ANEXOS

27
1. CÓDIGO FONTE

28