PIM IV TEATRO

Prévia do material em texto

UNIP INTERATIVA
Projeto Integrado Multidisciplinar
Cursos Superiores de Tecnologia
DESENVOLVIMENTO DE UM SISTEMA EM LINGUAGEM C
UNIP Polo Taquaral – Campinas - SP
2018
UNIP INTERATIVA
Projeto Integrado Multidisciplinar
Cursos Superiores de Tecnologia
PROJETO DE UM SISTEMA PARA
VENDA DE INGRESSO DE UM TEATRO
Nome: Daniela Cristina Rodrigues
RA: 1870235
Curso: Analise e Desenvolvimento de Sistemas
Semestre: 1º Semestre
UNIP Polo Taquaral – Campinas - SP
2018
RESUMO
O objetivo do presente trabalho é mostrar um sistema que foi desenvolvido para vendas de ingresso de um teatro em linguagem C com especificações dadas através do cenário, como diferentes tipos de ingressos (inteiras / meias / isentas), ter uma parte do sistema para a realização do fechamento do caixa, um espetáculo sobre temas especiais para crianças carentes da cidade com entrada franca todas as terças-feiras. Com o avanço da tecnologia torna-se mais rápido e seguro realizar tarefas, como administrar um teatro, e um dos principais objetivos desse projeto foi trazer agilidade e modernização para esse teatro. 
Palavras-chave: Teatro. Ingresso.
ABSTRACT
The aim of the present work is to show a system that was developed for ticket sales of a theater in C language with specifications given through the scenario, such as different types of tickets (whole / half / exempt), have a part of the system to perform of the closing of the box, a spectacle on special subjects for needy children of the city with free entrance every Tuesday. With the advancement of technology, it becomes faster and safer to perform tasks such as managing a theater, and one of the main goals of this project was to bring agility and modernization to this theater.
Keywords: Theater. Ticket.
SUMÁRIO
RESUMO	3
ABSTRACT	3
INTRODUÇÃO	5
1.	DESENVOLVIMENTO DO PROJETO	5
1.1.	Linguagem de programação	5
1.2.	Tipos de Linguagens de Programação	5
1.2.1.	Linguagem de Máquina	5
1.2.2.	Linguagem Assembly	5
1.2.3.	Linguagem de Alto Nível	6
2.	LINGUAGEM C – UM BREVE HISTÓRICO	6
3.	ENGENHARIA DE SOFTWARE	6
3.1.	Conceitos	7
3.2.	Processo de um software	7
3.3.	Modelos de processos de Software	7
3.4.	Modelo em cascata	8
3.5.	Modelos evolucionários	9
3.6.	Modelo de prototipagem	9
3.7.	Modelo espiral	9
3.8.	Rapid Application Development – Modelo RAD	10
3.9.	Teste e modificação	11
4.	PROCESSOS EMPREGADOS NO DESENVOLVIMENTO DO PROGRAMA	12
4.1.	Fase I – Análise	12
4.2.	Fase II Elaboração	13
4.3.	Fase III – Construção	13
4.4.	Fase IV – Transição	13
4.5.	Fase V – Operação	13
5.	REQUISITOS FUNCIONAIS	14
6.	CÓDIGO DO SISTEMA	14
7.	TELAS DO SISTEMA	29
8.	CONCLUSÃO	38
9.	REFERÊNCIAS BIBLIOGRÁFICAS	39
INTRODUÇÃO
Para o desenvolvimento deste projeto foi necessário um estudo baseado em pesquisas sobre as principais áreas que envolvem a construção de software.
 Neste estudo foi incluído linguagens de programação com um foco especial em linguagem C, a qual é utilizada nas disciplinas “Linguagem e Técnicas de Programação e de Engenharia de Software I” com suas principais ferramentas utilizadas na implantação do programa.
O trabalho será composto de uma parte teórica, onde será apresentado os conceitos da linguagem C e a outra o desenvolvimento do sistema propriamente dito.
DESENVOLVIMENTO DO PROJETO
Linguagem de programação
A Linguagem de programação foi criada para facilitar os processos de produção de Software mais ágeis e sofisticados, por isso são ferramentas importantes e poderosas. Para que os computadores executem os códigos da linguagem de programação, elas precisam primeiramente serem traduzidas para linguagem de máquina, ou seja, utilizando-se de compiladores como o DevC ++ (que foi utilizado para este projeto), CodeBlocks, Visual C++, Visual Studio, entre outros.
Tipos de Linguagens de Programação
Linguagem de Máquina 
Também conhecida como Código de Máquina, é a linguagem de baixo nível e muito simples, pois representa um conjunto de instruções sequenciais de bits, ou seja, uma sequência de números binários, zero e um, capaz de fazer com que um computador possa realizar operações lógicas, aritméticas e de armazenamento.
Linguagem Assembly
Também chamada de Linguagem de Montagem, é composta por representação dos códigos de máquina chamados mnemônicos, abreviações de expressões em inglês que descrevem a operação efetuada pelo comando do código de máquina. Isso torna mais fácil a compreensão por seres humanos.
Linguagem de Alto Nível 
É a linguagem onde a abstração é bastante elevada, e, isso facilita, bastante, na hora de programar, por se tratar de uma linguagem muito semelhante a linguagem natural. 
LINGUAGEM C – UM BREVE HISTÓRICO
Criado em 1972, no Laboratório de Bell, Estados Unidos, por Dennis Ritchie, a Linguagem C transformou-se em um dos grandes pilares da programação, tornando-se entre as linguagens mais populares entre os programadores, independentemente dos tipos de projetos que estivessem envolvidos.
Um dos fatores que propiciaram essa popularidade é o fato dessa linguagem possuir, como principal característica, a portabilidade, ou seja, é focado na Universidade, podendo então, ser usada em quase todos os tipos de projetos.
“A linguagem C pertence a uma família de linguagens cujas características são: portabilidade, modularidade, complicação separada, recursos de baixo nível, geração de código eficiente, confiabilidade, regularidade, simplicidade e facilidade de uso” (ITO, 2014, p.59).
Essas características qualificam a Linguagem C para o uso em desenvolvimento tanto de aplicativos quanto na implementação de sistemas operacionais.
ENGENHARIA DE SOFTWARE
A engenharia de software dedica-se a orientar o desenvolvimento e a manutenção de sistemas de software. Costa (2014, p. 11) traz a seguinte definição “A engenharia de software é composta de diversos conceitos fundamentais na área e abrange um conjunto de métodos ou práticas e diversas ferramentas que possibilitam aos profissionais desenvolverem software de alta qualidade”.
Baseando-se no que disse Costa, a engenharia de software é ampla no que diz respeito à elaboração e a eficaz manutenção de um software, durante todo o seu ciclo de vida. Faz-se necessário então, uma análise dos conceitos, dos métodos, das práticas e das ferramentas que à compõem.
Conceitos
Costa (2014 apud FERNANDES, 2003) afirma que: 
“A Engenharia de Software é a disciplina do conhecimento humano que tem por objetivo definir e exercitar processos (humanos atuando como máquina), métodos (planos de processo), ferramentas e ambientes (máquinas apoiando processos e métodos) para a construção de softwares que satisfaçam as necessidades clientes e usuários dento de prazos e custos previsíveis.”
Processo de um software
Em um processo de um software existe uma gama de atividades que tem como finalidade a construção de um produto final, e tem uma importância relativamente grande, aumentando bastante as chances de sucesso, qualidade e satisfação do cliente.
Não tendo um processo adequado, reduz drasticamente a qualidade ou, até mesmo inutilizar o produto, o que aumentaria o custo e atrasos na entrega, problemas estes que devem ser amplamente combatidos.
Essas atividades podem envolver o desenvolvimento de software propriamente dito, usando qualquer linguagem de programação como C++ ou a própria linguagem C.
Modelos de processos de Software
Existem diversos modelos, cada qual com sua característica e com vantagens e desvantagens. Modelos de processos de software podem ser comprometidas como uma abstração de um processo de software. Cada modelo tem suas particularidades que devem ser levadas em conta na hora da escolha.
São três os modelos principais: Modelo cascata ou “Waterfall”, desenvolvimento evolucionário e o modelo baseado em componentes. Segundo Sommervile (2007, p.43), “Essestrês modelos genéricos de processo são amplamente usados na prática atual de engenharia de software. Eles não são mutuamente exclusivos e frequentemente usados em conjunto, especialmente para desenvolvimento de sistemas de grande porte”.
Modelo em cascata
Também conhecido como modelo clássico e tendo como principal característica a abordagem “topdown” esse modelo é fortemente pautado em uma documentação abrangente, o que o transforma em um dos métodos mais importantes, servindo como referência para uma diversidade de outros modelos. Segundo Costa (2014, p. 65), “o paradigma do ciclo de vida clássico demanda uma abordagem sistemática e sequencial para o desenvolvimento de software. Começa no nível do sistema e progride, através da análise, do design, de codificação, do teste e da manutenção”.
A versão original desse projeto foi reformulada e continua sendo muito utilizada nos dias atuais. Entre diversas vantagens oferecidas por esse modelo, pode-se citar o foco no planejamento de fases. Esse planejamento tem que ser muito minucioso, tendo em vista, que esse tipo de modelo não prevê retorno para possíveis mudanças no projeto. Outra grande vantagem desse modelo é que só segue para o próximo passo após a validação e aceitação por parte dos clientes dos produtos finais de cada etapa, oferecendo, assim, uma previsão mais exata, quando se trata de cumprimento de prazos e os custos do projeto.
As desvantagens desse tipo de abordagem estão na dificuldade que os clientes tem em estabelecer todos os requisitos no começo do projeto, não acompanha a elaboração do mesmo, tendo acesso, somente no final de cada fase, e, podem ocorrer paradas no andamento do projeto, nas quais uma parte da equipe possa ter que esperar uma parte concluírem suas tarefas. 
Modelos evolucionários
Os modelos evolucionários diferem do modelo cascata, especialmente, por possuir maior interação com cliente e permitindo mudanças durante o desenvolvimento. A evolução do processo acontece da seguinte forma:
Quando uma parte do projeto é desenvolvida, o cliente avalia e propõe as mudanças necessárias, essas mudanças serão implementadas, até que se tenha um software adequado as necessidades do negócio.
Dois modelos fundamentais utilizam esse tipo de processo: O modelo de prototipagem e o modelo espiral.
Modelo de prototipagem
A prototipação se adapta a diversos tipos de processos de software, e tem como objetivo principal, o auxílio a equipe e ao cliente para que possam compreender melhor o que está para ser desenvolvido. Costa (2014, p. 70) diz o seguinte, sobre o modelo e prototipagem: o objetivo é entender os requisitos do usuário e, assim, obter a melhor definição dos requisitos do sistema. Possibilita que que o analista crie um modelo de (protótipo) do software que será construído.
Esse protótipo é apropriado para quando o cliente não tiver definido detalhadamente os requisitos, mas tiver prazo curto para o desenvolvimento. O protótipo dá maior assertividade ao projeto com relação as necessidades do cliente ou usuário.
Basicamente, a prototipação com auxílio de reuniões com todos que fazem parte da equipe que, tem como objetivo definir objetivos gerais do software e identificar possíveis erros e esquematizar as áreas que realmente precisam de uma definição mais global.
Modelo espiral
Apontado como uma evolução de modelos anteriores, principalmente, o modelo cascata e a de prototipação, o modelo espiral foi criado com o intuito de inovar as técnicas de construção de software prevendo um desenvolvimento evolutivo e cíclico. No início de cada ciclo são traçados os objetivos do processo e no final é feita uma avaliação por parte do cliente e as possíveis falhas serão corrigidas.
As principais vantagens do modelo espiral: 
Os ciclos constantes ajudam a gerir os riscos; 
Assemelha-se como os métodos utilizados em engenharia de outras áreas; 
A abordagem sistemática;
O progresso e as estimativas do trabalho tornam-se mais dinâmicos. 
Desvantagens: 
Requer conhecimento sênior da equipe; 
Só é aconselhado aos empregos em projetos grandes e de altos custos; 
Os protocolos devem ser seguidos de modo restrito. Só que, na prática isso dificilmente acontece;
O cliente pode não aceitar ou duvidar de que a abordagem evolutiva é controlável.
Rapid Application Development – Modelo RAD 
Para o desenvolvimento do programa de emissão de ingresso de um teatro foi empregado o Modelo de Desenvolvimento Rápido de Aplicação (RAD), é um modelo de processo de desenvolvimento interativo e incremental que enfatiza um ciclo muito curto, entre (60 a 90 dias).
O termo foi registrado por James Martin em 1991 e tem substituído gradativamente o tempo de prototipação rápida que já foi muito utilizada no passado. Esse modelo é adequado por ser ágil e permitir a mudança de requisitos durante o decorrer do processo.
Segundo Kerr, o processo se divide em 5 fases: 
 Modelagem de Negócio: O fluxo de informações entre as funções de negócio é modelado de modo a responder às seguintes questões: Que informação direciona o processo de negócio? Que informação é gerada? Para onde vai à informação? Na modelagem de negócio são levantados os processos suportados pelo sistema. 
Modelagem dos dados: modelagem de dados responde a um conjunto de questões especificas que são relevantes a qualquer aplicação. O fluxo de informação definido na fase de modelagem de negócio refinado e de forma a extrair os principais objetos de dados, onde costumam ficar, qual a relação entre eles e quais as relações entre os processos que os transformam.
Modelagem do Processo: os objetos de dados definidos na modelagem de dados são transformados para conseguir o fluxo necessário para implementar uma função do negócio. Descrições do processamento são criadas para adicionar, modificar, descartar ou recuperar um objeto de dados.
Geração de Aplicação: o RAD considera o uso de técnica de quarta geração, trabalha com a reutilização de componentes de programa existentes quando possível, ou cria componentes reusáveis. São usadas ferramentas automatizadas para facilitar a construção do software.
Teste e modificação
Como o processo do RAD enfatiza o reuso, muitos componentes já estão testados, isso reduz o tempo total do teste. Todavia os novos componentes devem ser testados e todas as interfaces devem ser exaustivamente exercitadas.
Vantagens: 
Baseados em componentes, podendo empregar em outros incrementos eliminados a duplicidade de código; 
Variação do modelo incremental;
Várias equipes trabalham em vários incrementos; 
- Desenvolvimentos paralelos;
- Desenvolvimentos rápidos.
Devido não ser um modelo indicado para desenvolvimento de projetos extensos e complicados e de alto risco técnico, acaba proporcionando benefícios e desenvolvimento acessível para todas as equipes envolvidas. E o ciclo empregado pode ser gerenciado com maior exatidão nos processos.
PROCESSOS EMPREGADOS NO DESENVOLVIMENTO DO PROGRAMA
Nesse capítulo serão abordados todos os itens que necessários para o desenvolvimento de um sistema de gerenciamento de venda de ingressos de um teatro. Inicialmente é importante ressaltar que todo projeto contém uma série de passos a serem seguidos que auxiliará no desenvolvimento dos processos e na conclusão que garante qualidade e o desempenho da criação do sistema. 
Fase I – Análise 
Na Fase I é analisado o cenário que deve conter o levantamento da situação atual, diagnosticando os maiores problemas a fim de aplicar as fases seguintes para atender a necessidade do cliente.
O que deve conter na análise para se desenvolver o programa: 
• Quantos lugares disponíveis no teatro?
• Como é controlado a numeração das poltronas?
• Vai contemplar meia entrada, entrada grátis ou isenta para qual perfil de usuário?
• Qual valor dos ingressos?
• como será o fluxo de caixa?
• Qual o layout da impressão dos ingressos?
Essas são as principaisindagações para iniciar a segunda fase do projeto.
 Tendo em mente que poderá haver algumas modificações que serão implementadas durante o decorrer do desenvolvimento.
Fase II Elaboração 
A elaboração é a fase que trará as definições de como realizar a construção do projeto. Diante das respostas de cada questionamento da primeira fase poderão através de um planejamento elaborar quais serão os processos para se iniciar o desenvolvimento.
Fase III – Construção 
A fase de Construção é onde inicia-se o Desenvolvimento e poderá ser concluído se a fase I e II for elaborada corretamente. A construção do projeto deverá ser iniciada imediatamente, utilizando recursos e ferramentas, trazendo vantagens e melhorias durante todo o desenvolvimento. É na fase de construção que poderá ter resultados positivos e negativos que mostra onde deverá ser corrigido ou alterado para funcionar de acordo com o desejo e o cenário proposto. Portanto, colocar todos os questionamento e necessidades em um programa após a elaboração e definição de como realizar é nada mais que desenvolver de acordo com o fluxo descoberto.
Fase IV – Transição 
A Transição pode ser denominada como a fase da homologação do desenvolvimento do programa. Após finalizar a construção deverá ser homologado e iniciado uma sequência de testes, que julgará se o sistema está em perfeita condição de utilização e se atenderá todos os requisitos impostos para seu funcionamento. 
Fase V – Operação 
Ao fim da construção e homologação concluídas devidamente, deverá ser realizado o funcionamento final do programa. O software de vendas de ingresso de um teatro estará pronto.
REQUISITOS FUNCIONAIS
O sistema irá realizar a venda de ingressos e gestão do caixa. 
A venda de ingressos acontecerá da seguinte maneira: o cliente informa o espetáculo desejado, a quantidade de cada tipo de ingresso (inteira / meia / isenta), logo após fará a escolha das poltronas, após a confirmação da compra acontecerá a emissão do ticket.
A gestão do caixa informará a quantidade de cada ingresso que já foi vendido, o total de ingressos vendidos, o valor arrecadado com cada tipo de ingresso e o valor arrecadado no total. Essas informações são atualizadas a cada compra confirmada.
Regras Desenvolvidas no Sistema
-Não será possível solicitar uma quantidade de ingressos maior que os lugares vagos.
- Os espetáculos destinados a crianças carentes da rede pública só irão aparecer caso o código 2 referente ao dia da semana (terça feira) for solicitado.
- Não será possível selecionar os ingressos para os espetáculos que já estejam esgotados.
- Os ingressos são impressos separadamente, cada um com sua poltrona e preço.
CÓDIGO DO SISTEMA
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <time.h>
#include <conio.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
setlocale(LC_ALL,"portuguese");	
 int cod_menu, cod_peca, cod_dia, num_polt, soma_ent, volta, total_ent, total_val, confirm, sair;
 int i, j, k; //variaveis dos for
 int valor50 = 50;
 int valor55 = 55;
 int peca1_disp = 30, peca2_disp = 30, peca3_disp = 30, peca4_disp = 30, peca5_disp = 30, peca6_disp = 30;
 int total_int = 0, total_meia = 0, total_gra = 0, total_pub = 0, pretotali = 0, pretotalm = 0, pretotalg = 0, pretotalp = 0;
 
 //Declaração dos vetores e seus valores
 char vetorx[30];
 char vetora[30];
 char vetorb[30];
 char vetorc[30];
 char vetord[30];
 char vetore[30];
 char vetorf[30];
 for (i=0; i<30; i++){
 vetorx[i]= ('\-');
 vetora[i]= ('\-');
 vetorb[i]= ('\-');
 vetorc[i]= ('\-');
 vetord[i]= ('\-');
 vetore[i]= ('\-');
 vetorf[i]= ('\-');
 }
 voltar:
 setlocale(LC_ALL, "Portuguese");
 
 printf("\n *BEM VINDO AO TEATRO * FAMÍLIA * GIUNGI* \n");
 printf(" ==============================================\n\n");
 printf("|----------------------------------------------|\n");
 printf("| SELECIONE UMA OPÇÃO DO MENU |\n");
 printf("|----------------------------------------------|\n");
 printf("| 1 - TABELA DE ESPETÁCULOS E PREÇOS |\n");
 printf("|----------------------------------------------|\n");
 printf("| 2 - FECHAMENTO DE CAIXA |\n");
 printf("|----------------------------------------------|\n");
 printf("| 0 - SAIR |\n");
 printf("|----------------------------------------------|\n\n");
 scanf ("%d", &cod_menu);
 system("cls");
 //Variaveis que precisam ser inicializadas com um valor padrão
 int pecax_disp = 0, soma_disp = 0, entrada_int = 0, entrada_meia = 0, entrada_gra = 0, entrada_pub = 0, valorx = 0, meiax = 0, pre_compra = 0;
 int ticket_polt[30][2];
 if (cod_menu == 1){ 
 printf("\n\n");
 printf("\t1-SEG 2-TER 3-QUA 4-QUI 5-SEX 6-SÁB 7-DOM \n\n");
 printf("\n\tINFORME O DIA DA SEMANA:");
 scanf ("%d", &cod_dia);
 system("cls");
 peca:
 	 printf ("|----------------------------------------------------------------------------------|\n");	
 printf ("| *TABELA DE ESPETÁCULOS* |\n");
 printf ("|----------------------------------------------------------------------------------|\n");
 printf ("| LUGARES |\n");
 printf ("|CÓDIGO NOME SALA PREÇO HORÁRIO VAGOS |\n");
 printf ("|----------------------------------------------------------------------------------|\n");
 printf ("| 1 'MUSICAL INFANTIL - A BELA E A FERA' 1 R$%d,00 13:00 %0.2d |\n", valor50, peca1_disp);
 printf ("|----------------------------------------------------------------------------------|\n");
 printf ("| 2 'COMEDIANTE, CASADO E PAI' 1 R$%d,00 16:30 %0.2d |\n", valor50, peca2_disp);
 printf ("|----------------------------------------------------------------------------------|\n");
 printf ("| 3 'NÓIS QUE É POBRE' 2 R$%d,00 11:30 %0.2d |\n", valor55, peca3_disp);
 printf ("|----------------------------------------------------------------------------------|\n");
 printf ("| 4 'MUSICAL O FANTASMA DA ÓPERA' 2 R$%d,00 15:30 %0.2d |\n", valor55, peca4_disp);
 printf ("|----------------------------------------------------------------------------------|\n");
 if (cod_dia == 2){
 printf ("\n DESTINADOS PARA CRIANÇAS CARENTES DA REDE PÚBLICA DE ENSINO ÀS TERÇAS FEIRAS) \n");
 printf ("|----------------------------------------------------------------------------------|\n");
 printf ("| 5 'MUSICAL INFANTIL - A BELA E A FERA' 3 GRÁTIS 12:30 %0.2d |\n", peca5_disp);
 printf ("|----------------------------------------------------------------------------------|\n");
 printf ("| 6 'MUSICAL O FANTASMA DA ÓPERA' 3 GRÁTIS 15:00 %0.2d |\n", peca6_disp);
 printf ("|----------------------------------------------------------------------------------|\n\n");
 }
 printf ("ESCOLHA O CÓDIGO DO ESPETÁCULO DESEJADO:");
 scanf ("%d", &cod_peca);
 system("cls");
 //Passa os valores dos vetores de cada espetáculo para o vetor generico
 switch(cod_peca){
 case 1:
 valorx = valor50;
 meiax = valorx/2;
 pecax_disp= peca1_disp;
 for(j=0;j<30;j++){
 vetorx[j]=vetora[j];
 }
 break;
 case 2:
 valorx = valor50;
 meiax = valorx/2;
 pecax_disp = peca2_disp;
 for(j=0;j<30;j++){
 vetorx[j]=vetorb[j];
 }
 break;
 case 3:
 valorx = valor55;
 meiax = valorx/2;
 pecax_disp = peca3_disp;
 for(j=0;j<30;j++){
 vetorx[j]=vetorc[j];
 }
 break;
 case 4:
 valorx = valor55;
 meiax = valorx/2;
 pecax_disp = peca4_disp;
 for(j=0;j<30;j++){
 vetorx[j]=vetord[j];
 }
 break;
 case 5:
 pecax_disp = peca5_disp;
 for(j=0;j<30;j++){
 vetorx[j]=vetore[j];
 }
 break;
 case 6:
 pecax_disp = peca6_disp;
 for(j=0;j<30;j++){
 vetorx[j]=vetorf[j];
 }
 break;
 }
 if ((cod_peca>4)&&(cod_dia!=2)){
 printf("\n |-----------------------------------------------|\n");
 printf(" | CÓDIGO NÃO ENCONTRADO NA LISTA DE ESPETÁCULOS |\n");
 printf(" |-----------------------------------------------|\n");
 sleep(2000);
 system("cls");
 goto peca;
 }
 if (pecax_disp==0){
 system("cls");
 printf("\n |----------------------------|\n");
 printf(" | INGRESSOS ESGOTADOS |\n");
 printf(" | SELECIONE OUTRO ESPETÁCULO |\n");
 printf(" |----------------------------|\n");
 sleep(20000);
 system("cls");
 goto peca;
 }
 //A quantidade dos ingressos
 ingresso:
 if(cod_peca<=4){
 printf("|---------------------------------------------------------------------------------");
 printf("\n| INFORME QUANTAS ENTRADAS SERÃO INTEIRAS: ");
 scanf("%d", &entrada_int);
 printf("|---------------------------------------------------------------------------------");
 printf("\n| INFORME QUANTAS ENTRADAS SERÃO MEIAS\n");
 printf("| CASO FOR ESTUDANTE / PROFESSOR DA REDE PÚBLICA / CRIANÇA *03 A 12 ANOS: ");
 scanf("%d", &entrada_meia);
 printf("|---------------------------------------------------------------------------------");
 printf("\n| INFORME QUANTAS ENTRADAS SERÃO ISENTAS\n");
 printf("| CASO FOR IDOSO / APOSENTADO:");
 scanf("%d", &entrada_gra);
 printf("|---------------------------------------------------------------------------------");
 }
 else
 if ((cod_peca<=6)&&(cod_dia==2)){
 printf("|---------------------------------------------------------------------------------");
 printf("\n| INFORME QUANTAS ENTRADAS SERÃO GRÁTIS\n");
 printf("| CASO FOR CRIANÇA CARENTE DA REDE PÚBLICA: "); 
 scanf("%d", &entrada_pub);
 }
 //soma todos os ingressos para fazer uma comparação com a quantidade de ingressos do espetáculo
 soma_disp = entrada_int + entrada_meia + entrada_gra + entrada_pub;
 if (soma_disp > pecax_disp){
 system("cls");
 printf("\n |-------------------------------------------|\n");
 printf(" | SESSÃO POSSUI APENAS: %0.2d LUGARES VAGOS |\n", pecax_disp);
 printf(" |-------------------------------------------|\n");
 sleep(3000);
 system("cls");
 goto ingresso;
 }
 //tipos de entrada 1 inteira, 2 meia, 3 idoso, 4 publica
 soma_ent = entrada_int;
 for(k=0; k<soma_ent; k++){
 ticket_polt[k][1]= 1;
 }
 soma_ent = entrada_int + entrada_meia;
 for(k; k<soma_ent; k++){
 ticket_polt[k][1]= 2;
 }
 soma_ent = entrada_int + entrada_meia + entrada_gra;
 for(k; k<soma_ent; k++){
 ticket_polt[k][1]= 3;
 }
 soma_ent = entrada_int + entrada_meia + entrada_gra + entrada_pub;
 for(k; k<soma_ent; k++){
 ticket_polt[k][1]= 4;
 }
 system("cls");
 //for baseado na quantidade de ingressos
 for(k=0; k<soma_ent; k++){
 poltrona:
 printf (" * POLTRONAS *\n\n");
 printf ("|---------------------------------------------------------------------|\n");
 printf ("| 01%c | 02%c | 03%c | 04%c | 05%c | 06%c | 07%c | 08%c | 09%c | 10%c |\n", vetorx[0], vetorx[1], vetorx[2], vetorx[3], vetorx[4], vetorx[5], vetorx[6], vetorx[7], vetorx[8], vetorx[9]);
 printf ("|---------------------------------------------------------------------|\n");
 printf ("| 11%c | 12%c | 13%c | 14%c | 15%c | 16%c | 17%c | 18%c | 19%c | 20%c |\n", vetorx[10], vetorx[11], vetorx[12], vetorx[13], vetorx[14], vetorx[15], vetorx[16], vetorx[17], vetorx[18], vetorx[19]);
 printf ("|---------------------------------------------------------------------|\n");
 printf ("| 21%c | 22%c | 23%c | 24%c | 25%c | 26%c | 27%c | 28%c | 29%c | 30%c |\n", vetorx[20], vetorx[21], vetorx[22], vetorx[23], vetorx[24], vetorx[25], vetorx[26], vetorx[27], vetorx[28], vetorx[29]);
 printf ("|---------------------------------------------------------------------|\n");
 printf ("| (TELA) |\n");
 printf ("|---------------------------------------------------------------------|\n");
 printf ("| * OCUPADO | - VAGO | + SELECIONADO |\n");
 printf ("|---------------------------------------------------------------------|\n");
 printf (" ESCOLHA O NÚMERO DA POLTRONA DESEJADA:");
 scanf ("%d", &num_polt);
 if ((num_polt > 30) || (num_polt<1)){
 system("cls");
 printf("\n |-----------------------------------------|\n");
 printf(" | ESCOLHA UM NÚMERO DE POLTRONA EXISTENTE |\n");
 printf(" |-----------------------------------------|\n");
 sleep(1000);
 system("cls");
 goto poltrona;
 }
 //adicionao numero da poltrona a uma matriz para mostrar no ticket
 ticket_polt[k][0]= num_polt;
 num_polt = num_polt - 1;
 //caso o lugar escolhido ja esteja com o *
 if (vetorx[num_polt]==('\*')){
 system("cls");
 printf("\n |---------------|\n");
 printf(" | LUGAR OCUPADO |\n");
 printf(" |---------------|\n");
 sleep(1500);
 system("cls");
 goto poltrona;
 }
 //caso o lugar escolhido ja esteja com o +
 if (vetorx[num_polt]==('\+')){
 system("cls");
 printf("\n |----------------------|\n");
 printf(" | LUGAR JÁ SELECIONADO |\n");
 printf(" |----------------------|\n");
 sleep(1500);
 system("cls");
 goto poltrona;
 }
 vetorx[num_polt] = ('\+');
 system("cls");
 }
 //confirmação da compra
 pre_compra = entrada_int*valorx + entrada_meia*meiax;
 printf("|----------------------------------------------------|\n");
 printf("|DESEJA CONCLUIR A COMPRA? (1 PARA SIM | 0 PARA NÃO) |\n");
 printf("|TOTAL DA COMPRA: R$%d,00 \n", pre_compra);
 printf("|----------------------------------------------------|\n\n");
 scanf("%d", &confirm);
 if (confirm == 0){
 system("cls");
 printf("\n |------------------|\n");
 printf(" | COMPRA CANCELADA |\n");
 printf(" |------------------|\n");
 sleep(1500);
 system("cls");
 goto voltar;
 }
 system("cls");
 //impressão dos tickets baseado na soma dos ingressos
 for(k=0; k<soma_ent; k++){
 //parte fixa do ticket
 printf("|-----------------------------------------------------------|\n");
 printf("|* TEATRO FAMÍLIA GIUNGI DATA :%s Hora:%s|\n",__DATE__,__TIME__);
 printf("|-----------------------------------------------------------|\n");
 printf("| TICKET |\n");
 //parte alterada com base no filme
 switch(cod_peca){
 case 1:
 printf("|PEÇA: 'MUSICAL INFANTIL - A BELA E A FERA' SALA: 1 |\n");
 printf("|SESSÃO: 13:00 POLTRONA: %0.2d|\n", ticket_polt[k][0]);
 break;
 case 2:
 printf("|PEÇA: 'COMEDIANTE, CASADO E PAI' SALA: 1 |\n");
 printf("|SESSÃO: 16:30 POLTRONA: %0.2d|\n", ticket_polt[k][0]);
 break;
 case 3:
 printf("|PEÇA: 'NÓIS QUE É POBRE' SALA: 2 |\n");
 printf("|SESSÃO: 11:30 POLTRONA: %0.2d|\n", ticket_polt[k][0]);
 break;
 case 4:
 printf("|PEÇA: 'MUSICAL O FANTASMA DA ÓPERA' SALA: 2 |\n");
 printf("|SESSÃO: 15:30 POLTRONA: %0.2d|\n", ticket_polt[k][0]);
 break;
 case 5:
 printf("|PEÇA: 'MUSICAL INFANTIL - A BELA E A FERA' SALA: 3 |\n");
 printf("|SESSÃO: 12:30 POLTRONA: %0.2d|\n", ticket_polt[k][0]);
 break;
 case 6:
 printf("|Filme: 'MUSICAL O FANTASMA DA ÓPERA' SALA: 3 |\n");
 printf("|SESSÃO : 12:30 POLTRONA: %0.2d|\n", ticket_polt[k][0]);
 break;
 }
 //parte alterada pelo tipo do ingresso
 switch(ticket_polt[k][1]){
 case 1:
 printf("|PREÇO: R$%0.2d,00 INTEIRA|\n", valorx);
 printf("|-----------------------------------------------------------|\n");
 break;
 case 2:
 printf("|PREÇO: R$%0.2d,00 MEIA ENTRADA|\n", meiax);
 printf("|-----------------------------------------------------------|\n\n\n");
 break;
 case 3:
 printf("|PREÇO: ISENTO ISENTO|\n");
 printf("|-----------------------------------------------------------|\n\n\n");
 break;
 case 4:
 printf("|PREÇO: GRÁTIS GRÁTIS|\n");
 printf("|-----------------------------------------------------------|\n\n\n");
 break;
 }
 }
 //transforma os lugares escolhidos na compra em ocupados
 for (j=0;j<30;j++) {
 if (vetorx[j]==('\+')){
 vetorx[j]=('\*');
 }
 }
 //ingressos disponiveis
 pecax_disp = pecax_disp - soma_disp;
 //passa os valores do vetor generico para o vetor de cada espetáculo
 switch(cod_peca){
 case 1:
 peca1_disp = pecax_disp;
 for(j=0;j<30;j++){
 vetora[j] = vetorx[j];
 }
 break;
 case 2:
 peca2_disp = pecax_disp ;
 for(j=0;j<30;j++){
 vetorb[j] = vetorx[j];
 }
 break;
 case 3:
 peca3_disp = pecax_disp ;
 for(j=0;j<30;j++){
 vetorc[j] = vetorx[j];
 }
 break;
 case 4:
 peca4_disp = pecax_disp;
 for(j=0;j<30;j++){
 vetord[j] = vetorx[j];
 }
 break;
 case 5:
 peca5_disp = pecax_disp;
 for(j=0;j<30;j++){
 vetore[j] = vetorx[j];
 }
 break;
 case 6:
 peca6_disp = pecax_disp;
 for(j=0;j<30;j++){
 vetorf[j] = vetorx[j];
 }
 break;
 }
 //todas as somas de ingressos
 pretotali = pretotali + entrada_int*valorx;
 pretotalm = pretotalm + entrada_meia*meiax;
 pretotalg = pretotalg + entrada_gra*0;
 pretotalp = pretotalp + entrada_pub*0;
 total_int= entrada_int + total_int;
 total_meia= entrada_meia + total_meia;
 total_gra= entrada_gra + total_gra;
 total_pub= entrada_pub + total_pub;total_ent= total_int + total_meia + total_gra + total_pub;
 total_val= pretotali + pretotalm + pretotalg + pretotalp;
 printf("DIGITE 0 PARA VOLTAR AO MENU PRINCIPAL:");
 scanf("%d", &volta);
 system("cls");
 goto voltar;
 }
 else
 if (cod_menu == 2){
 //atualiza os numeros a cada compra
 printf("|------------------------------------------------------------------------|\n");
 printf("| FECHAMENTO DE CAIXA |\n");
 printf("|------------------------------------------------------------------------|\n");
 printf("| INGRESSOS | VALOR ARRECADADO|\n");
 printf("|------------------------------------------------------------------------|\n");
 printf("|INGRESSOS VENDIDOS COMO INTEIRAS...............: %0.4d | R$%0.4d,00 |\n", total_int, pretotali);
 printf("|INGRESSOS VENDIDOS COMO MEIAS..................: %0.4d | R$%0.4d,00 |\n", total_meia, pretotalm);
 printf("|INGRESSOS ISENTOS(IDOSO/APOSENTADO)............: %0.4d | R$%0.4d,00 |\n", total_gra, pretotalg);
 printf("|INGRESSOS GRÁTIS(CRIANÇAS CARENTES)............: %0.4d | R$%0.4d,00 |\n", total_pub, pretotalp);
 printf("|------------------------------------------------------------------------|\n");
 printf("| TOTAL: %0.4d | R$%0.4d,00 |\n", total_ent, total_val);
 printf("|------------------------------------------------------------------------|\n\n\n");
 printf("DIGITE 0 PARA VOLTAR AO MENU PRINCIPAL:");
 scanf("%d", &volta);
 system("cls");
 goto voltar;
 }
 else
 if (cod_menu == 0){
 printf("\n |-----------------------------------------------------|\n");
 printf(" | DESEJA MESMO SAIR DO PROGRAMA? (1 - SIM / 0 - NÃO) |\n");
 printf(" |-----------------------------------------------------|\n");
 scanf("%d", &sair);
 if (sair == 1){
 exit(0);
 }
 else{
 system("cls");
 goto voltar;
 }
 }
 else{
 printf("\n |---------------------------|\n");
 printf(" | ESCOLHA UMA OPÇÃO DO MENU |\n");
 printf(" |---------------------------|\n");
 sleep(1500);
 system("cls");
 goto voltar;
 }
 getch();
 return 0;
}
TELAS DO SISTEMA
Figura 01 – Tela do Menu Principal
Tela inicial do sistema que possibilita ao usuário acessar uma das 2 funções do sistema ou sair do programa. (selecionado o item 1 do Menu)
Figura 02 – Tela do Dia da Semana
Tela acessada após entrar no item 1 do menu principal, caso o dia selecionado seja 2 teremos os espetáculos na tabela de preços destinados a crianças carentes da rede pública de ensino. (selecionado item 2)
Figura 02 – Tela da Tabela de Espetáculos (Dia =2)
Tela acessada após entrar no item 2 no dia da semana, é possível ver as informações dos espetáculos que estão em cartaz no teatro, como seu preço, lugares vagos, sala e horário. (selecionado item 1)
Figura 04 - Tela dos Ingressos
Tela acessada após entrar com qualquer valor abaixo de 5 na tabela de espetáculos, é possível selecionar a quantidade e o tipo de ingresso (inteira / meia / isento). (selecionado o valor 1 para cada tipo de ingresso)
Figura 05 - Tela das Poltronas
Tela acessada após escolher a quantidade de ingressos, é possível visualizar os lugares já ocupados, os que acabaram de ser selecionados e os vagos. (selecionado os valores 1, 2 e 3)
Figura 06 - Tela de Confirmação de Compra
Tela acessada após escolher as poltronas, possível confirmar ou cancelar a compra, e ver o preço total da compra. (selecionado o valor 1)
Figura 07 - Tela dos Tickets
 Tela acessada após entrar com o valor 1 na confirmação da compra, é possível visualizar as informações de cada ticket, como o nome do espetáculo, sessão, sala, data, poltrona, preço (inteira / meia / isento).
Figura 08 - Tela da Tabela de Filmes
Tela acessada após entrar com qualquer valor diferente de 2 no dia da semana, é possível ver as informações dos espetáculos que estão em cartaz no teatro, como seu preço, lugares vagos, sala e horário. (selecionado o valor 1)
Figura 09 - Tela das Poltronas
 Tela acessada após escolher a quantidade de ingressos, é possível visualizar os lugares já ocupados, os que acabaram de ser selecionados e os vagos. (selecionado o valor 1, que já está ocupado)
Figura 10 - Tela de Lugar Ocupado
Tela acessada após escolher um lugar já ocupado na tela de poltronas.
Figura 11 - Tela das Poltronas
Tela acessada após escolher a quantidade de ingressos, é possível visualizar os lugares já ocupados, os que acabaram de ser selecionados e os vagos. (selecionado o valor 4, que acabou de ser selecionado)
Figura 12 - Tela de Lugar Selecionado
 Tela acessada após escolher um lugar já selecionado na tela de poltronas.
Figura 13 - Tela das Poltronas
 Tela acessada após escolher a quantidade de ingressos, é possível visualizar os lugares já ocupados, os que acabaram de ser selecionados e os vagos. (selecionado o valor 32, que não está presente na numeração das poltronas)
Figura 14 - Tela do Número de Poltrona Errado
Tela acessada após escolher que não está presente na numeração das poltronas.
Figura 15 - Tela de Confirmação de Compra
 Tela acessada após escolher as poltronas, possível confirmar ou cancelar a compra, e ver o preço total da compra. (selecionado o valor 0, para cancelar a compra)
Figura 16 - Tela de Compra Cancelada
Tela acessada após entrar com o valor 0 na tela de confirmação da compra, após essa mensagem vai para o menu principal.
Figura 17 - Tela da Tabela de Espetáculos (Dia = 2)
Tela acessada após entrar com o valor 2 no dia da semana, é possível ver as informações dos Espetáculos que estão em cartaz no teatro, como seu preço, lugares vagos, salas e horários. (selecionado o valor 5, para acessar o espetáculo destinado as crianças carentes da rede pública)
Figura 18 - Tela de Ingressos (Espetáculos 5 e 6)
Tela acessada após entrar com o valor 5 ou 6, é possível selecionar a quantidade de ingressos. (Digitado o valor 52, maior do que a quantidade de lugares vagos)
Figura 19 - Tela de Lugares Vagos
 Tela acessada após entrar com um valor na tela de ingressos acima da quantidade de lugares vagos.
Figura 20 - Tela do Menu Principal
 Tela inicial do sistema que possibilita que o usuário acesse uma das duas funções do sistema ou feche o programa. (Selecionado item 2)
Figura 30 - Tela de Gestão do Caixa
Tela acessada após entrar com o valor 2 no menu principal, é possível visualizar a quantidade de cada tipo de ingresso vendido, o total de ingressos vendidos, o valor arrecadado com cada tipo de ingresso e o valor total arrecadado. As informações são atualizadas a cada compra.
Figura 31 - Tela do Menu Principal
 Tela inicial do sistema que possibilita que o usuário acesse uma das duas funções do sistema ou feche o programa. (Entraremos com o valor 0)
Figura 32 - Tela de Sair
 Tela acessada após entrar com o valor 0 no menu principal. (Entraremos com o valor 1)
Figura 33 - Tela de Saída Realizada
 Tela acessada após entrar com o valor 1 na tela de sair, informa que o programa foi finalizado com sucesso.
Figura 34 - Tela de Sair
 Tela acessada após entrar com o valor 0 no menu principal. (Entraremos com o valor 0)
Figura 35 - Tela do Menu Principal
 Tela inicial do sistema que possibilita que o usuário acesse uma das duas funções do sistema ou sair do programa.
CONCLUSÃOO processo de criação de uma solução informatizada para um teatro ou qualquer empresa é um processo complexo, pois conceber soluções práticas exige conhecimento, muita informação, documentação e planejamento para uma decisão adequada. No centro deste processo de desenvolvimento estão as atividades-chave: análise e especificação de requisitos, projeto, implementação e testes, que são a base sobre a qual o processo de desenvolvimento deve ser construído. Entretanto, a definição de um processo envolve a escolha de um modelo de ciclo de vida, o detalhamento de suas macros atividades, a escolha de métodos, técnicas e roteiros para a sua realização e a definição de recursos e artefatos necessários.
Para ser eficaz e conduzir à construção de produtos de boa qualidade, um processo deve ser adequado ao domínio da aplicação e ao projeto específico. Deste modo, processos devem ser definidos caso a caso, considerando-se as especificidades da aplicação, a tecnologia a ser adotada na sua construção, a organização onde o produto será desenvolvido e o grupo de desenvolvimento.
REFERÊNCIAS BIBLIOGRÁFICAS
ITO, Olavo. Linguagem e Técnicas de Programação. São Paulo: Sol, 2014. 59 p.
COSTA, Ivanir. Engenharia de Software I . São Paulo: Sol, 2014. 11 p.
CARBONI, I. D. Lógica de programação. São Paulo: Pioneira/Thomson Learning, 2002.
FARRER, H. et al. Algoritmos estruturados. 3. Ed. Rio de Janeiro: LTC, 1999.
GORDON, S. R.; GORDON, J.R. Sistemas de informação: uma abordagem gerencial. 3 ed. Rio de Janeiro: LTC, 2006.
LAUREANO, M. Estrutura de dados com algoritmos e C. Rio de Janeiro: Brasport, 2008.
O’BRIEN, J. A. Sistemas de informação e as decisões gerenciais na era da internet. 2. Ed. São Paulo: Saraiva, 2004.
SINGH, S. O livro dos códigos. Rio de Janeiro: Record, 2001.
SALVETTI, D.D.;BARBOSA, L. M. Algoritmos. São Paulo: Makron Books, 1998.SCHILDT, H. Borland C++ Builder, a referência completa. Rio de Janeiro: Elsevier, 2001.