PMI IV - Sistema em linguagem C (Venda de Ingressos de Teatro)

Prévia do material em texto

1 
 
 
 
Unip EaD 
Projeto Integrado Multidisciplinar 
Cursos Superiores de Tecnologia 
 
 
 
 
 
 
 
Desenvolvimento de um sistema em linguagem C. 
(Venda de Ingressos de Teatro) 
 
 
 
 
 
 
 
 
 
Polo Paulista 
2019 
 
2 
 
 
 
Unip EaD 
Projeto Integrado Multidisciplinar 
Cursos Superiores de Tecnologia 
 
 
 
 
 
 
 
Desenvolvimento de um sistema em linguagem C. 
(Venda de Ingressos de Teatro) 
 
Silvio Agnoleto 
RA 1962510 
Curso: Análise e Desenvolvimento de 
Sistemas 
Semestre: 2º 
 
 
 
 
Polo Paulista 
2019 
3 
 
Resumo 
Introdução - O software pode ser aplicado a qualquer situação em qualquer área 
de estudo em que um conjunto de algoritmos é definido e executado para alcançar os 
resultados. Nossa tentativa é aplicar essa característica ao trabalho proposto pela 
Universidade Paulista para este bimestre (4°/2019). Objetivo - Desenvolver um 
sistema em linguagem C para venda de ingressos de teatro. Métodos – Utilizar-se-á 
dos conhecimentos adquiridos através das aulas ministradas de LINGUAGEM E 
TÉCNICAS DE PROGRAMAÇÃO e ENGENHARIA DE SOFTWARE I e com a 
possibilidade de orientação através do fórum de discussão o pelo telefone 0800-010-
9000. Conclusão – O correto uso das técnicas ensinadas junto com um código limpo 
e eficaz, trará um programa que possa atender todas as necessidades apresentadas, 
possibilitando controle, eficácia e agilidade nas operações referente a vendas de 
ingressos para o teatro. 
Descritores: Software; Técnicas de Programação; Ingressos; Teatro. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4 
 
Abstract 
Introduction - Software can be applied to any situation in any area of study where 
a set of algorithms is defined and executed to achieve the results. Our attempt is to 
apply this feature to the work proposed by the Paulista University for this quarter (4 ° / 
2019). Objective - To develop a C language system for theater ticket sales. Methods 
- It will use the knowledge acquired through the classes taught in LANGUAGE AND 
PROGRAMMING TECHNIQUES and SOFTWARE ENGINEERING I and with the 
possibility of guidance through the discussion forum or by telephone 0800-010-9000. 
Conclusion - The correct use of the techniques taught together with a clean and 
effective code will bring a program that can meet all the needs presented, enabling 
control, effectiveness and agility in theater ticket sales operations. 
 
Keywords : Software; Programming techniques; Tickets; Theater. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5 
 
Sumário 
1 INTRODUÇÃO ................................................................................................06 
2 DESENVOLVIMENTO ....................................................................................07 
2.1 6653-60 Engenharia de Software ..................................................................07 
2.1.1 O processo de Software ..................................................................................07 
2.1.2 Atividades do Processo de Software ...............................................................07 
2.1.3 Descrição Visual do Modelo ............................................................................08 
2.1.4 As Desvantagens deste Modelo ......................................................................08 
2.2 6654-120 Linguagem e Técnicas de Programação .....................................09 
2.2.1 História da Linguagem C .................................................................................09 
2.2.2 A Evolução: Linguagem C++ ...........................................................................09 
2.3 Detalhes do Arquivo Fonte do Programa ....................................................11 
2.3.1 Printa Menu .....................................................................................................11 
2.3.2 Lista Pecas ......................................................................................................13 
2.3.3 Cad Pecas .......................................................................................................14 
2.3.4 Vende Ingresso ...............................................................................................19 
2.3.5 Cad Venda ......................................................................................................22 
2.3.6 Emite Ticket .....................................................................................................22 
2.3.7 Printa Vendas ..................................................................................................24 
2.3.8 Encerra Dia .....................................................................................................25 
3 CONCLUSÃO .................................................................................................27 
4 REFERÊNCIAS ..............................................................................................28 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6 
 
Introdução 
Para o desenvolvimento do sistema de vendas de ingressos para teatro foram 
passadas algumas especificações, são elas: Controle referente ao valores dos 
ingressos, a qual deverá contemplar meia-entrada (50% de desconto) para 
estudantes, crianças de 02 a 12 anos, adultos a partir de 60 anos e professores da 
rede pública de ensino e 100% de desconto para crianças carentes da rede pública 
de ensino. Emissão (mostrar na tela) de um ticket com a data, a hora, o nome da peça 
teatral e o número da poltrona. 
Nenhum espectador pode ter um ingresso com o mesmo número da poltrona de 
outro espectador da mesma peça teatral de um determinado horário. Imprescindível 
informar quando não existir mais lugares disponíveis e, consequentemente, não 
permitir mais a venda de ingressos para a peça em questão. Deverá também fazer a 
gestão do caixa, isto é, informar no fechamento do caixa todas as movimentações do 
dia e o saldo do fechamento. 
Será tambem adotado um modelo de ciclo de vida para o desenvolvimento do 
sistema para venda dos ingressos e apresentar-se-á as justificativas para escolha de 
tal modelo. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7 
 
Desenvolvimento 
6653-60: ENGENHARIA DE SOFTWARE I 
 
O processo de Software 
 
A utilização de um processo de software tem sido apontada como um fator 
primordial para o sucesso de empresas de desenvolvimento de software. Na 
definição de um processo de software devem ser consideradas as seguintes 
informações: atividades a serem realizadas, recursos necessários, artefatos 
requeridos e produzidos, procedimentos adotados e o modelo de ciclo de vida 
utilizado. 
As principais fases de um processo de software são : Especificação de 
Requisitos, Projeto de Sistema, Programação e Verificação. 
 
Atividades do Processo de Software 
 
Em cada fase de um processo de software definido, (Figura A), são 
executadas as atividades básicas para que sejam atingidos os objetivos 
propostos. São elas: Especificação, Projeto, Implementação, Validação e 
Manutenção e Evolução 
 
 
Figura A – Atividades do Processo de Software 
 
 
 
 
 
 
 
 
 
Fonte: Própria (2019) 
 
8 
 
Desta forma as atividades relacionadas a um processo de software estão 
diretamente vinculadas com a produção do software como produto final . 
Foi adotado o modelo Cascata , devido ao fato do programa ser de fácil 
desenvolvimento e não haver praticamente qualquer interatividade com o 
usuário/cliente. 
Este modelo foi idealizado por Royce em 1970 , também conhecido como 
abordagem ‘top-down’ , tem como principal característica a sequência de 
atividades onde cada fase transcorre completamente e seus produtos são 
vistos como entrada para uma nova fase. 
 
Descrição Visual do Modelo 
 
A ideia principal do modelo é que as diferentes etapas de desenvolvimento 
seguem uma sequência. 
O modelo pressupõe que o cliente sabe muito bemo que quer. Este modelo 
minimiza o impacto da compreensão adquirida no decurso de um projeto, uma 
vez que se um processo não pode voltar atrás de modo a alterar os modelos 
e as conclusões das tarefas anteriores, é normal que as novas ideias sobre o 
sistema não sejam aproveitadas. 
 
As Desvantagens deste Modelo são : 
 
• Dificuldade em acomodar mudanças depois que o processo está sendo 
executado; 
• Partição inflexível do projeto em estágios distintos; 
• Dificuldade em responder a mudanças dos requisitos; 
• É mais apropriado quando os requisitos são bem compreendidos; 
• Os projetos reais raramente se adaptam ao modelo linear e sequencial; 
• É difícil capturar os requisitos de uma só vez; 
• Cliente tem de pacientemente esperar o resultado; 
• Alto custo de correção das especificações quando nas fases de Teste 
e Implantação. 
 
9 
 
6654-120: LINGUAGEM E TÉCNICAS DE PROGRAMAÇÃO 
História da Linguagem C 
A linguagem C foi criada em 1972 por Dennis Ritchie no Bell Laboratories. C é 
derivada de duas outras linguagens: Algol 68 e BCPL. 
O foco da linguagem C inicialmente foi o desenvolvimento de sistemas operacionais 
e compiladores. C foi usada com grande êxito na construção de uma nova versão do 
sistema operacional Unix, que inicialmente foi escrito em Assembly. Após o sucesso 
obtido no mundo do Unix fez com que a linguagem ganhasse mais e mais adeptos e 
atualmente, quase todos os grandes sistemas operacionais são construídos em 
C/C++. No início dos anos 80 C passou a ser reconhecida como uma linguagem de 
propósito geral. 
Um grande esforço de padronização foi feito a fim de padronizar a linguagem. 
Atualmente ainda há versões de compiladores próprias de cada fabricante, porém a 
maioria dos fabricantes oferece uma opção de compatibilidade com o padrão ANSI C. 
A linguagem C se adapta a praticamente qualquer tipo de projeto, altamente 
portável e extremamente rápida em tempo de execução. A linguagem C++ é uma 
evolução da linguagem C que incorpora orientação a objetos. Linguagens como Java 
e C# foram influenciadas pela linguagem C. 
 
A Evolução: Linguagem C++ 
A primeira versão oficial do C++ apareceu em 1985, juntamente com o livro “The 
C++ Programming Language”, que esclareceu vários pontos sobre o C++. Em 1989 
foi lançada uma segunda versão da linguagem, com acréscimo das características: 
Herança múltipla, classes abstratas, métodos estáticos, métodos constantes e 
membros protegidos, incrementando tambem um suporte de orientação a objeto. 
O C++ tem uma enorme variedade de códigos, os seus próprios e uma quantidade 
grande da linguagem C. Esta variedade possibilita a programação em alto e baixo 
níveis. O C++ apresenta grande flexibilidade, embora seja bom, este fato faz com que 
a programação seja muito mais cuidadosa para não terem erros. 
10 
 
Alguns dos mais conhecidos programas são feitos em C++, ou parte dos seus 
códigos são nessa linguagem. Alguns deles são: Adobe Photoshop, MySQL, Mozilla 
Firefox, Internet Explorer, Microsoft Windows, entre vários outros. 
Baseado no conteúdo e nas técnicas apresentadas durante a disciplina de 
LINGUAGEM E TÉCNICAS DE PROGRAMAÇÃO, acrescido de pesquisas e algum 
conhecimento de causa, segue a descrição das funcionalidades do sistema proposto, 
bem como a apresentação de suas telas, concebidos a partir do fluxo. (Figura 1). 
Figura 1 – Fluxo dos Processos 
Fonte: Própria (2019) 
11 
 
Detalhes do Arquivo Fonte do Programa 
 
Praticamente todo sistema desenvolvido em linguagens estruturadas se iniciam por 
um Menu. Baseado nas necessidades fornecidas, nosso menu, (Figura 2), conterá 6 
(seis) opções: 
Cadastrar, Listar Peças em Cartaz, Vender Ingressos, Listar Vendas, Encerrar 
Salas e Sair. 
 
Figura 2 - Menu 
 
 
 
 
Fonte: Própria (2019) 
 
/* função que imprime e valida menu 
****************************************** 
********* PRINTA MENU ******** 
****************************************** 
*/ 
 
void menu() 
{ 
int opcao; 
do //laco de verificacao 
{ 
 system("cls"); 
 //printa as opcoes do menu 
 { 
 foreground(GREEN); 
 printf("\n [ INGRESSOS TEATRO MAZZAROPI ] \n\n"); 
 style(RESETALL); 
 } 
 printf(" 1) CADASTRAR PECAS \n"); 
 printf(" 2) LISTAR PECAS EM CARTAZ \n"); 
 printf(" 3) VENDER INGRESSOS \n"); 
 printf(" 4) LISTAR VENDAS \n"); 
 printf(" 5) ENCERRAR SALAS \n"); 
 printf(" 6) SAIR "); 
 { 
 foreground(GREEN); 
 printf("\t\n\n Digite a Opcao Desejada: "); 
 style(RESETALL); 
 } 
 fflush(stdin); 
 scanf("%d",&opcao); 
 //verifica a entrada 
 if ( opcao != 1 && opcao !=2 && opcao != 3 && opcao != 4 && opcao != 5 && opcao != 6) 
12 
 
 { 
 foreground(RED); 
 printf ("\n OPCAO INVALIDA DIGITE NOVAMENTE!!"); // em caso de erro 
 style(RESETALL); 
 getch(); 
 } 
}while( opcao != 1 && opcao !=2 && opcao != 3 && opcao != 4 && opcao != 5 && opcao != 6); 
 switch(opcao) 
 { 
 case 1: 
 { 
 system("cls"); 
 cad_pecas(); 
 } 
 case 2: 
 { 
 system("cls"); 
 lista_pecas(); 
 menu(); 
 } 
 case 3: 
 { 
 system("cls"); 
 vende_ticket(); 
 break; 
 } 
 case 4: 
 { 
 system("cls"); 
 printa_vendas(); 
 break; 
 } 
 case 5: 
 { 
 system("cls"); 
 reset_salas(); 
 break; 
 } 
 case 6: 
 { 
 system("cls"); 
 exit(0); 
 } 
 } 
} 
 
Sempre antes de alguma ação que envolva as peças de teatro em si, seja listagem, 
cadastro, venda de ingressos, a tela a seguir, (Figura 3), irá aparecer 
antecipadamente, proporcionando ao usuário/operador do sistema a possibilidade de 
conhecer com quais “produtos” está se trabalhando naquele momento. 
Dessa forma após escolher a opção 1) Cadastrar Peças, será exibida a listagem 
das peças em cartaz com conteúdo VAZIO. 
 
 
13 
 
 Figura 3 – Tela Lista Peças 
 
 
 
 
 
 
 
 
 
 
 
Fonte: Própria (2019) 
 
/* função mostra pecas em cartaz 
********************************************* 
********** LISTA PECAS *********** 
********************************************* 
*/ 
 
void lista_pecas() 
{ 
 { 
 foreground(GREEN); 
 printf("\n [ INGRESSOS TEATRO MAZZAROPI ] \n\n"); 
 style(RESETALL); 
 } 
 int cont,cont2; 
 for(cont=0;cont<5;cont++) 
 { 
 printf("\n Peca %d:",cont+1); 
 printf(" %s",peca[cont].nomepeca); 
 printf("\n Valor R$ %.2f",peca[cont].valor_cheio); 
 printf("\n Horarios:"); 
 for(cont2=0;cont2<5;cont2++) 
 { 
 printf(" %02d:%02d",peca[cont].hora[cont2],peca[cont].min[cont2]); 
 } 
 printf("\n Sala: %d\n",peca[cont].sala+1); 
 } 
 foreground(GREEN); 
 printf ("\n <Presione qualquer tecla para continuar>"); 
 style(RESETALL); 
 getch(); 
} 
14 
 
Qualquer tecla para continuar e entramos na rotina de cadastro (Figura 4). 
O teatro tem 5 salas disponíveis para apresentação, numeradas de 1 a 5, as 
mesmas devem ser identificadas na hora da inclusão/edição de uma peça. 
Item 1 – Qual peça teatral você deseja cadastrar? - Opções de 1 a 5 ou Opção 6 
para Sair. 
Item 2 – Digite o nome daPeça: - Texto com o nome da apresentação. 
Item 3 – Digite o valor da peça: - Valor Integral e em Reais. 
Item 4 – [ Digite os Horarios da Peça ] - Será solicitado que seja digitado 5 (cinco) 
horários distintos para cada peça cadastrada. Caso não haja sessões suficientes no 
dia para tantos horários, é permitido deixar o valor EM BRANCO após terem sido 
cadastrados todas as sessões existentes. Tecle <ENTER> no horário em questão sem 
preencher nada e continue. 
Item 5 – Digite a sala da peça: - Confirme a sala que você está cadastrando. 
 
Figura 4 – Tela Cadastro Peças 
 
 
 
 
 
Fonte: Própria (2019) 
 
/* função cadastra as peças 
******************************************* 
********** CAD PEÇAS ********** 
******************************************* 
*/ 
 
void cad_pecas() 
{ 
 int opcao=1,cont,hora,minuto,opsala; 
 char nome[100]; 
 lista_pecas(); 
 do //laco de verificacao 
 { 
 printf("\n\n Qual peca teatral voce deseja cadastrar/alterar? [6]-> SAIR "); //laco de escolha 
 fflush(stdin); 
 scanf(" %d",&opcao); 
 opcao--; 
 fflush(stdin); 
 if(opcao!=0 && opcao!=1 && opcao!=2 && opcao!=3 && opcao!=4 && opcao!=5) 
 { 
15 
 
 foreground(RED); 
 printf("\n [ OPCAO INVALIDA DIGITE NOVAMENTE!! ] \n"); // em caso de erro 
 style(RESETALL); 
 } 
 }while(opcao!=0 && opcao!=1 && opcao!=2 && opcao!=3 && opcao!=4 && opcao!=5); 
 switch (opcao) 
 { 
 case (5): 
 { 
 menu(); 
 break; 
 } 
 default: 
 { 
 printf("\n Digite o nome da peca: "); 
 gets(peca[opcao].nomepeca); 
 fflush(stdin); 
 printf("\n Digite o valor da peca: "); 
 scanf("%f",&peca[opcao].valor_cheio); 
 fflush(stdin); 
 foreground(GREEN); 
 printf("\n [ Digite os Horarios da Peca ] \n\n"); 
 style(RESETALL); 
 for(cont=0;cont<5;cont++) 
 { 
 printf(" Digite o %d horario: ",cont+1); //horario escolhido 
 scanf("%d:%d",&peca[opcao].hora[cont],&peca[opcao].min[cont]); 
 fflush(stdin); 
 } 
 do // valida a escolha da sala 
 { 
 printf("\n Digite a sala da peca: "); // escolhe a sala 
 scanf("%d",&peca[opcao].sala); 
 peca[opcao].sala=peca[opcao].sala-1; 
 fflush(stdin); 
 if(peca[opcao].sala !=0 && peca[opcao].sala !=1 && peca[opcao].sala !=2 && 
peca[opcao].sala !=3 && peca[opcao].sala !=4) 
 { 
 foreground(RED); 
 printf("\n [ OPCAO INVALIDA DIGITE NOVAMENTE!! ] \n"); // em caso de erro 
 style(RESETALL); 
 } 
 }while(peca[opcao].sala!=0 && peca[opcao].sala!=1 && peca[opcao].sala!=2 && 
peca[opcao].sala!=3 && peca[opcao].sala!=4); 
 foreground(RED); 
 printf("\n Peca cadastrada com sucesso!! \n\n"); 
 style(RESETALL); 
 foreground(GREEN); 
 printf (" <Presione qualquer tecla para continuar>"); 
 style(RESETALL); 
 getch(); 
 gravabd(); 
 menu(); //vai para o menu 
 } 
 } 
} 
16 
 
Ao final de cada rotina o sistema voltará a tela de Menu (Figura 2) novamente até 
que seja escolhida a opção 6) Sair. 
Entramos novamente na opção 1) Cadastrar Peças e agora já vemos (Figura 5) a 
nossa primeira peça de teatro cadastrada. Repetimos o procedimento de cadastro 
para todas as peças em cartaz, e o resultado será o apresentado na (Figura 6). 
 
Figura 5 – Tela Lista Peças Figura 6 – Tela Lista Peças 
Fonte: Própria (2019) Fonte: Própria (2019) 
 
A partir de agora e até que alguma alteração no cadastro de peças seja feita, o 
resultado apresentado quando se entrar na opção do menu 2) Listar Peças em Cartaz, 
será o resultado apresentado na (Figura 6). 
O momento mais esperado do dia chegou!!! Hora de vender os ingressos... 
Na nossa opção 3) Vender Ingresso, (Figura 2), teremos todas as rotinas 
pertinentes a venda de ingresso (escolha da peça, horário, cadeira e o tipo de 
ingresso). 
Ao adentrar na opção, primeiramente e como já foi mencionado, irá aparecer a 
listagem das peças em cartaz, (Figura 6), pressionando uma tecla o sistema solicita 
que se: Selecione a peça? (Figura 7) ou tecle 6 para Sair. 
 
 Figura 7 – Tela Venda Ingressos 
 
Fonte: Própria (2019) 
 
Na tela de vendas (Figura 8), temos três itens principais, (1) Tipos de Ingressos, (2) 
Opções de Horário e (3) Número da Cadeira. Iniciamos a venda pela escolha do tipo 
de ingresso (Inteiro, Meia Estudantes e Professores, Meia Crianças e Idosos e 
17 
 
Gratuito). A opção Gratuito, vem atender as crianças carentes da rede pública que 
possuem a gratuidade assegurada. 
 
Figura 8 – Tela Venda Ingressos 
 
 
 
 
 
 
 
 
 
 
 
Fonte: Própria (2019) 
Perceba que os valores dos ingressos já são calculados de acordo com cada 
categoria e apresentado ao lado da mesma. 
Após a escolha do Tipo de Ingresso, o sistema solicita a escolha do Horário. 
Verifica-se que da mesma forma que o Tipo de Ingresso, o sistema se antecipa e 
mostra a quantidade de cadeiras disponíveis em cada um dos horários. A quantidade 
de cadeiras em questão é de 60 por sala/apresentação. 
Com o horário definido, abre-se a opção para escolha da cadeira. Com valores que 
vão de 00 a 59, o sistema valida e não permite a venda de uma cadeira na mesma 
sala e no mesmo horário para dois ou mais expectadores distintos. 
Feita a escolha da cadeira, é emitido na tela o ingresso da venda do cliente e gerado 
simultaneamente um ingresso para impressão gravado em arquivo texto em diretório 
específico, respectivamente (Figuras 9 e 10). 
Um detalhe interessante quanto ao nome do arquivo gerado, é a composição 
numérica que faz parte dele. No arquivo em questão Ingresso_21445225, temos: 2 
(Peça) / 1445 (Horário) / 2 (Sala) / 25 (Cadeira). Foi criada essa rotina com o intuito 
de não permitir num mesmo dia, já que o diretório de gravação é o mesmo para todos 
os ingressos vendidos, que um ingresso sobrepôs-se outro. 
 
18 
 
Figura 9 – Arquivo Salvo no Diretório Ingressos 
 
 
Fonte: Própria (2019) 
 
Figura 10 – Conteúdo do Arquivo Gravado 
 
 
 
 
 
Fonte: Própria (2019) 
 
Concluída a primeira venda, o sistema retorna ao menu.(Figura 2). 
Uma observação: o sistema vende ingressos de forma individual, um para cada 
expectador. Numa versão posterior será observado a alteração para que seja 
vendidos ingressos para um grupo de pessoas. 
Nessa condição, voltamos a tela de vendas e observamos agora que ao escolher 
a mesma peça para venda de ingresso, o sistema já posiciona uma quantidade de 
cadeiras disponíveis diferentes da existente na primeira venda. Agora só existem 59 
cadeiras para vender. (Figura 11). 
É possível observar também que a cadeira escolhida, na ocasião a Nº 25, já está 
marcada [ X ], como ocupada. Observe que numa tentativa de se comprar a mesma 
cadeira na mesma sala e no mesmo horário, retornou CADEIRA OCUPADA!! 
 
19 
 
Figura 11 – Tela Venda Ingressos 
 
 
 
 
 
 
 
 
 
 
 
 
Fonte: Própria (2019) 
 
Vendas após vendas até que cheguemos à condição de LOTAÇÃO da sala a qual 
se deseja assistir à peça. (Figura 12). 
Para evitarmos que o usuário entrasse na sala o que poderia vir ocasionar um 
looping, restringimos o acesso a ela, já na tela de Vendas, onde se a quantidade de 
cadeirasfor igual a ZERO, não é permitida a venda para aquele horário, 
consequentemente a rotina que escolhe cadeiras não é executada. (Figura 12). 
 
Figura 12 – Tela Venda Ingressos 
 
 
 
 
 
Fonte: Própria (2019) 
 
/* função que vende os ingressos 
******************************************** 
********** VENDE INGRESSO ********** 
******************************************** 
*/ 
20 
 
 
void vende_ticket() 
{ 
 int opcao,opcao_hora,opcao_cadeira,cont,opcao_valor; 
 
 lista_pecas(); 
 do //laco de verificacao 
 { 
 //escolha da peça para venda do ticket 
 printf("\n\n Selecione a peca? [6]-> SAIR "); //laco de escolha 
 fflush(stdin); 
 scanf("%d",&opcao); 
 opcao--; 
 fflush(stdin); 
 if(opcao!=0 && opcao!=1 && opcao!=2 && opcao!=3 && opcao!=4 && opcao!=5) 
 { 
 foreground(RED); 
 printf("\n [ OPCAO INVALIDA DIGITE NOVAMENTE!! ] \n"); // em caso de erro 
 style(RESETALL); 
 } 
 }while(opcao!=0 && opcao!=1 && opcao!=2 && opcao!=3 && opcao!=4 && opcao!=5); 
 if(opcao==5) 
 { 
 menu(); 
 } 
 else // mostra o horarios das peças para escolha do cliente 
 { 
 system("cls"); 
 foreground(GREEN); 
 printf("\n [ INGRESSOS TEATRO MAZZAROPI ] \n\n"); 
 printf("\n Tipos de Ingressos\n"); 
 style(RESETALL); 
 printf("\n 1-Inteira (%.2f)\n 2-Meia Estudantes e Professores (%.2f)\n 3-Meia 
Criancas e Idosos (%.2f)\n 4-Gratuito 
(0)\n",peca[opcao].valor_cheio,peca[opcao].valor_cheio/2,peca[opcao].valor_cheio/2); 
 printf("\n Digite a opcao escolhida: "); 
 scanf("%d",&opcao_valor); 
 float valor; 
 if (opcao_valor==1) { valor=peca[opcao].valor_cheio; } 
 if (opcao_valor==2 || opcao_valor==3) { valor=peca[opcao].valor_cheio/2; } 
 if (opcao_valor==4) { valor=0; } 
 printf("\n Peca: %s \n",peca[opcao].nomepeca); 
 foreground(GREEN); 
 printf("\n Opcoes de Horario:\n\n"); 
 style(RESETALL); 
 int sala_cheia[5]; 
 for(cont=0;cont<5;cont++) 
 { 
 int vagos=0,j; 
 for(j=0;j<60;j++) 
 { 
 if (sala[peca[opcao].sala].cadeiras[j][cont]!='X') 
 { 
 vagos++; 
 } 
 } 
21 
 
 printf(" 
%d)%02d:%02d(%02d)\t",cont+1,peca[opcao].hora[cont],peca[opcao].min[cont],vagos); 
 if (vagos==0) 
 { 
 sala_cheia[cont]=1; 
 } else { 
 sala_cheia[cont]=0; 
 } 
 } 
 do //laco validador do horario 
 { 
 //escolha da peça para venda do ticket 
 printf("\n\n Digite o horario escolhido: ");//laco de escolha 
 fflush(stdin); 
 scanf("%d",&opcao_hora); 
 opcao_hora--; 
 fflush(stdin); 
 if(opcao_hora!=0 && opcao_hora!=1 && opcao_hora!=2 && opcao_hora!=3 && 
opcao_hora!=4) 
 { 
 foreground(RED); 
 printf("\n [ OPCAO INVALIDA DIGITE NOVAMENTE!! ] \n"); // em caso de erro 
 style(RESETALL); 
 } 
 if(sala_cheia[opcao_hora]==1) 
 { 
 foreground(RED); 
 printf("\n [ OPCAO INVALIDA (LOTACAO ATINGIDA) ESCOLHA OUTRO HORARIO!! ] 
\n"); // em caso de erro 
 style(RESETALL); 
 } 
 }while((opcao_hora!=0 && opcao_hora!=1 && opcao_hora!=2 && opcao_hora!=3 && 
opcao_hora!=4) || sala_cheia[opcao_hora]!=0); 
 //chama a funcao printa sala para a escolha do lugar 
 do 
 { 
 printa_sala(peca[opcao].sala,opcao_hora); 
 printf("\n Digite a cadeira escolhida: "); 
 scanf("%d",&opcao_cadeira); 
 if(sala[peca[opcao].sala].cadeiras[opcao_cadeira][opcao_hora]=='X') 
 { 
 foreground(RED); 
 printf("\n CADEIRA OCUPADA!!"); 
 style(RESETALL); 
 foreground(GREEN); 
 printf ("\n\n <Presione qualquer tecla para continuar>"); 
 style(RESETALL); 
 getch(); 
 system("cls"); 
 } 
 else 
 { 
 foreground(GREEN); 
 printf("\n Compra Realizada com Sucesso!!"); 
 style(RESETALL); 
 } 
22 
 
 }while(sala[peca[opcao].sala].cadeiras[opcao_cadeira][opcao_hora]=='X'); 
 sala[peca[opcao].sala].cadeiras[opcao_cadeira][opcao_hora]='X'; // prenche a cadeira 
escolhida 
 cad_venda(opcao,opcao_hora,opcao_cadeira,valor); 
 gravabd(); 
 menu(); 
 } 
} 
 
Mais duas rotinas que são chamadas através da rotina de Vendas de Ingressos, 
uma que cria o incremento da venda para poder depois mostrar a quantidade de 
vendas realizas e a outra que emite o ingresso na tela e grava o mesmo em arquivo 
para controle ou impressão, respectivamente cad_venda e emite_ticket. 
 
/* 
*************************************** 
********** CAD VENDA ********** 
*************************************** 
*/ 
 
void cad_venda(int opcao_pec, int opcao_hor, int opcao_cad, float opcao_valor) 
{ 
 int cont=0,ult_venda,link=0; 
 // ler no arquivo ultimo codigo da venda 
 do //laco de verificacao 
 { 
 if(venda[cont].cod_venda==0) 
 { 
 ult_venda=cont; 
 ++link; 
 } 
 cont++; 
 }while(link==0); 
 link; 
 venda[ult_venda].cod_venda=ult_venda+1; //gera o incremento da venda 
 venda[ult_venda].horario=opcao_hor; 
 venda[ult_venda].peca=opcao_pec; 
 venda[ult_venda].cadeira=opcao_cad; 
 venda[ult_venda].valor=opcao_valor; 
 emite_ticket(ult_venda); 
} 
 
/* 
****************************************** 
********** EMITE TICKET ********** 
****************************************** 
*/ 
 
void emite_ticket(int opcao_venda) 
{ 
 FILE *ticket; 
 char nome_ticket[0x100]; 
 //imprime na tela 
 foreground(GREEN); 
23 
 
 printf("\n\n [ INGRESSOS TEATRO MAZZAROPI ]"); 
 style(RESETALL); 
 printf("\n\n"); 
 printf(" Peca: %s\n",peca[venda[opcao_venda].peca].nomepeca); 
 printf(" Valor R$ %.2f\n",venda[opcao_venda].valor); 
 printf(" Horario: 
%02d:%02d\n",peca[venda[opcao_venda].peca].hora[venda[opcao_venda].horario],peca[venda[opcao
_venda].peca].min[venda[opcao_venda].horario]); 
 printf(" Sala: %d\n",peca[venda[opcao_venda].peca].sala+1); 
 printf(" Cadeira: %d\n",venda[opcao_venda].cadeira); 
 // gera o ingresso para impressão 
snprintf(nome_ticket,sizeof(nome_ticket),"Ingresso_%1d%02d%02d%1d%02d.txt",venda[opcao_vend
a].peca+1,peca[venda[opcao_venda].peca].hora[venda[opcao_venda].horario],peca[venda[opcao_ven
da].peca].min[venda[opcao_venda].horario],peca[venda[opcao_venda].peca].sala+1,venda[opcao_ve
nda].cadeira); 
 ticket=fopen(nome_ticket,"w"); 
 if(ticket==NULL) 
 { 
 menu(); 
 } 
 else 
 { 
 fprintf(ticket,"\n [ INGRESSOS TEATRO MAZZAROPI ] \n"); 
 fprintf(ticket,"\n\n"); 
 fprintf(ticket," Peca: %s\n",peca[venda[opcao_venda].peca].nomepeca); 
 fprintf(ticket," Valor R$ %.2f\n",venda[opcao_venda].valor); 
 fprintf(ticket," Horario: 
%02d:%02d\n",peca[venda[opcao_venda].peca].hora[venda[opcao_venda].horario],peca[venda[opcao
_venda].peca].min[venda[opcao_venda].horario]); 
 fprintf(ticket," Sala: %d\n",peca[venda[opcao_venda].peca].sala+1); 
 fprintf(ticket," Cadeira: %d\n",venda[opcao_venda].cadeira); 
 fclose(ticket); 
 } 
 getch(); 
} 
 
 
Na sequência iremos para aopção do menu 4) Lista Vendas, nela o sistema 
apresenta em tela os ingressos vendidos até o momento e a somatória do valor 
vendido por peça apresentada no dia. 
 
 
24 
 
Figura 13 – Tela Lista Vendas 
 
 
 
 
 
 
 
 
Fonte: Própria (2019) 
/* 
************************************************ 
********** PRINTA VENDAS ********** 
************************************************ 
*/ 
 
void printa_vendas() 
{ 
 int cont=0,link=0; 
 foreground(GREEN); 
 printf("\n\n [ INGRESSOS TEATRO MAZZAROPI ] \n"); 
 style(RESETALL); 
 float acum_vendas=0; 
 float acum_vendas_sala[5]; 
 for (int j=0;j<5;j++) 
 { 
 acum_vendas_sala[j]=0; 
 } 
 do 
 { 
 if(venda[cont].cod_venda!=0) 
 { 
 foreground(BLUE); 
 printf("\n Venda NR:%d\n",cont+1); 
 style(RESETALL); 
 printf(" Peca: %s\n",peca[venda[cont].peca].nomepeca); 
 printf(" Valor R$ %.2f\n",venda[cont].valor); 
 printf(" Sala: %d\n",peca[venda[cont].peca].sala+1); 
 printf(" Cadeira: %d\n",venda[cont].cadeira); 
 printf(" Horario: 
%02d:%02d\n",peca[venda[cont].peca].hora[venda[cont].horario],peca[venda[cont].peca].min[venda[c
ont].horario]); 
 cont++; 
 acum_vendas = acum_vendas + venda[cont].valor; 
 acum_vendas_sala[peca[venda[cont].peca].sala] = 
acum_vendas_sala[peca[venda[cont].peca].sala] + venda[cont].valor; 
 } 
 else 
25 
 
 { 
 for (int j=0;j<5;j++) 
 { 
 printf("\n Valor Acumulado da Peca %d no Dia: R$ %.2f", peca[j].sala+1, 
acum_vendas_sala[j]); 
 } 
 printf("\n\n Valor Acumulado do Dia: R$ %.2f", acum_vendas); 
 ++link; 
 } 
 }while(link==0); 
 gravabd(); 
 foreground(GREEN); 
 printf ("\n <Presione qualquer tecla para continuar>"); 
 style(RESETALL); 
 getch(); 
 menu(); 
} 
 
Penúltima opção do nosso menu, 5) Encerrar Salas, há uma rotina que limpa todas 
as cadeiras ocupadas, permitindo assim que no dia seguinte possam ser novamente 
comercializadas. Repare que a quantidade de cadeiras disponíveis voltou a 60 e as 
marcas de ocupado [ X ], já não aparecem mais. 
 
Figura 15 – Tela Venda Ingressos 
 
 
 
 
 
 
 
Fonte: Própria (2019) 
 
/* função limpa ocupacao da sala e mostra faturamento do dia 
********************************************* 
********** ENCERRA DIA ********** 
********************************************* 
*/ 
 
void reset_salas() 
{ 
 int opcao,cont,cont2,cont3; 
 do 
 { 
 foreground(GREEN); 
26 
 
 printf("\n\n [ INGRESSOS TEATRO MAZZAROPI ] \n"); 
 style(RESETALL); 
 printf("\n Deseja Encerrar o Dia e Zerar a Lotacao das Salas? \n\n"); 
 printf("\n 1)Sim \n"); 
 printf(" 2)Nao "); 
 fflush(stdin); 
 scanf(" %d",&opcao); 
 if(opcao!=1 && opcao!=2) 
 { 
 foreground(RED); 
 printf("\n OPCAO INVALIDA DIGITE NOVAMENTE!!\n\n"); // em caso de erro 
 style(RESETALL); 
 foreground(GREEN); 
 printf (" <Presione qualquer tecla para continuar>"); 
 style(RESETALL); 
 getch(); 
 system("cls"); 
 } 
 }while(opcao!=1 && opcao!=2); 
 if(opcao==1) 
 { 
 for(cont=0;cont<1500;cont++) 
 { 
 venda[cont].cod_venda=0; 
 venda[cont].horario=0; 
 venda[cont].peca=0; 
 venda[cont].cadeira=0; 
 venda[cont].valor=0; 
 } 
 gravabd(); 
 for(cont=0;cont<5;cont++) 
 { 
 for(cont2=0;cont2<5;cont2++) 
 { 
 for(cont3=0;cont3<60;cont3++) 
 { 
 sala[cont].cadeiras[cont3][cont2]=' '; 
 } 
 } 
 menu(); 
 } 
 } else { 
 menu(); 
 } 
} 
 
Todas as especificações foram contempladas no sistema e o programa fonte será 
anexo ao trabalho para que seja possível conferir a veracidade do texto apresentado. 
 
 
 
27 
 
Conclusão 
O desenvolvimento do presente estudo possibilitou uma análise mais apurada e de 
forma prática, de como um software feito através das técnicas aprendidas durante as 
aulas de LINGUAGEM E TÉCNICAS DE PROGRAMAÇÃO e ENGENHARIA DE 
SOFTWARE I tende a ter mais sucesso observadas tais orientações. Apesar da dificuldade 
encontrada, uma vez que o programa exigiu também conhecimentos diferentes dos 
aprendidos, a busca e a pesquisa desse complemento, só veio a avultar nosso programa de 
funcionalidades, proporcionando o atendimento de forma integral de todas as necessidades 
do cliente. Assim como todo programa, o programa de vendas de ingressos para teatro, não 
termina por aqui, seu ciclo de vida só se iniciou e através de atualizações que virão 
posteriormente o intuito é que ele se torne um sistema completo e abrangente dentro do seu 
ramo específico de atividade. Uma vez cumprida a meta inicial de desenvolvimento, dar-se 
por encerrado essa primeira fase. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
28 
 
Referências 
O processo de software. Macoratti , 2019. Disponível em 
<http://www.macoratti.net/proc_sw1.htm>. Acesso em 05 de nov. de 2019. 
BACKES , A. Estrutura de dados descomplicada - em linguagem C. 1ª Ed. Elsevier, 
2016. 
C++. Info Escola Navegando e Aprendendo , 2019. Disponível em 
<https://www.infoescola.com/informatica/cpp/>. Acesso em 07 de nov. de 2019. 
Martins , J.C.C. Gerenciando Projetos De Desenvolvimento De Software Com PMI, 
RUP E UML. 5ª Ed. Brasport ,2011. 
Breve História da Linguagem C. Intellectuale , 2019. Disponível em 
<http://linguagemc.com.br/breve-historia-da-linguagem-c/>. Acesso em: 08 de nov. 
de 2019 
 
PAES, R.B. Introdução a Programação com a Linguagem C. 1ª Ed. Novatec, 2016. 
 
Castro , J. Aprendendo C++ na prática. 1ª Ed. Ciência Moderna, 2014. 
 
Sommerville , I. Estudando o livro Engenharia de Software. 8ª Ed. Pearson,2007.