Ir para conteúdo
Fórum Script Brasil

The_Kings688

Membros
  • Total de itens

    4
  • Registro em

  • Última visita

Posts postados por The_Kings688

  1. 1 hora atrás, Michel Farina da Costa disse:

    Consegui algo amigo?

    Poderia me ajudar com este novo?

    #include<stdio.h>
    #include<string.h>
    #include <locale.h>

    struct sala {
      int cod_sala;
      int num_sala;
      int capacidade; 
    } Sala;

    struct peca {
      int cod_peca;
      char nome[100];
      char data[20];
      char horario[10];
      int sala;
      int capacidade;
      float valor;
    } Peca;

    struct ingresso {
      int cod_ingresso;
      char nome[100];
      char data[20];
      char horario[10];
      int sala;
      char tipo[20];
      float total;
    } Ingresso;

    main()
    {
        setlocale(LC_ALL, "Portuguese");
        
      struct sala lista_sala[1000];
      struct peca lista_peca[100];
      struct ingresso lista_ingresso[200];

      int indice_sala; 
      int indice_peca;
      int indice_ingresso;
      int opcao;
      int i;
      char temp[256];
      char buffer[256];
      int k;
      int tipo;
            
      indice_sala = 0;
      indice_peca = 0;
      indice_ingresso = 0;

      while(1) {
        puts("________________________________________ MENU ________________________________________\n\n");
        puts(" 1 - Cadastrar Sala");
        puts(" 2 - Listar Salas");
        puts(" 3 - Cadastrar Peça");
        puts(" 4 - Listar Peças");
        puts(" 5 - Reservar Ingresso");
        puts(" 6 - Listar Ingressos");
        puts(" 7 - Procurar Peça");
        puts(" 8 - Procurar Ingresso");
        puts("11 - Remover Peça");
        puts("12 - Remover Ingresso");
        puts("0 - Sair");
        puts("______________________________________________________________________________________\n\n");
        scanf("%d",&opcao);
        getchar();
        system("cls");
        switch(opcao) {
          case 1: // Cadastrar Sala
            lista_sala[indice_sala].cod_sala = indice_sala + 1;
            printf("Digite o número da sala: ");
            scanf("%d",&lista_sala[indice_sala].num_sala);
            printf("Digite a capacidade: ");
            scanf("%d",&lista_sala[indice_sala].capacidade);
            indice_sala = indice_sala + 1;
            puts("\n\n----->Sala Cadastrada com Sucesso<-----\n");    
            puts("\n\nPressione ENTER para sair...");    
            break;
          case 2: // Listar Salas
            puts("\n__________________________________________________________________");      
            printf("\t\tLISTA DE SALAS");
            printf("\nCódigo | Número |  Capacidade ");
            puts("\n__________________________________________________________________");
            for(i = 0; i < indice_sala; i++) {
              printf("%d         %d         %d", lista_sala.cod_sala, lista_sala.num_sala, lista_sala.capacidade);
              puts("\n__________________________________________________________________");
            }
            puts("\n\nPressione ENTER para sair...");
            break;
          case 3: // Cadastrar Peça
            lista_peca[indice_peca].cod_peca = indice_peca + 1;
            printf("Nome da peça: ");
            gets(lista_peca[indice_peca].nome);
            printf("Data: ");
            gets(lista_peca[indice_peca].data);
            printf("Horário: ");
            gets(lista_peca[indice_peca].horario);
            printf("Sala: ");
            scanf("%d",&lista_peca[indice_peca].sala);
            printf("Capacidade: ");
            scanf("%d",&lista_peca[indice_peca].capacidade);
            fflush(stdin);
            printf("Valor: ");
            scanf("%f",&lista_peca[indice_peca].valor);
            indice_peca = indice_peca + 1;
            puts("\n\n----->Peça Cadastrada com Sucesso<-----\n");
            puts("\n\nPressione ENTER para sair...");        
            break;
          case 4: // Listar Peças
            puts("\n__________________________________________________________________");      
            printf("\t\tLISTA DE PEÇAS");
            printf("\nCódigo     |     Peça     |     Data     |     Horário     |     Sala     |     Capacidade     |     Valor");
            puts("\n__________________________________________________________________");
            for(i = 0; i < indice_peca; i++) {
              printf("%d          %s          %s          %s          %d          %d          %f", lista_peca.cod_peca, lista_peca.nome, lista_peca.data, lista_peca.horario, lista_peca.sala, lista_peca.capacidade, lista_peca.valor);
              puts("\n__________________________________________________________________");
            }
            puts("\n\nPressione ENTER para sair...");
            break;
          case 5: // Reservar ingresso.
              lista_ingresso[indice_ingresso].cod_ingresso = indice_ingresso + 1;
            printf("\nCódigo da peça: ");
            scanf("%d", &lista_peca[indice_peca].cod_peca);
            for(i = 0; i < indice_peca; i++){
                if(lista_peca.cod_peca == lista_peca[indice_peca].cod_peca){
                    strcpy(lista_ingresso[indice_ingresso].nome, lista_peca.nome);
                    strcpy(lista_ingresso[indice_ingresso].data, lista_peca.data);
                    strcpy(lista_ingresso[indice_ingresso].horario, lista_peca.horario);
                    lista_ingresso[indice_ingresso].sala = lista_peca.sala;
                    break;
                }
                break;
            }
            printf("\n\nTipo:\n\n1 - Inteira\n2 - Meia\n3 - Gratuita\n\nEscolha o tipo: ");
            scanf("%d", &tipo);
            if(tipo == 1)
            {
                lista_ingresso.tipo == 'Inteira';
                lista_ingresso.total = lista_peca.valor;
                break;
            }
            else if(tipo == 2)
            {
                lista_ingresso.tipo == 'Meia';
                lista_ingresso.total = lista_peca.valor / 2;
                break;
            }
            else if(tipo == 3)
            {
                lista_ingresso.tipo == 'Gratuita';
                lista_ingresso.total = 0;
                break;
            }
            else
            {
                printf("\nTipo inválida. Pressione ENTER para sair...");
                break;
            }
            printf("\n\n------------------------------ RECIBO ------------------------------\n\n");
            printf("Código: %d  Peça: %s Sala %d\n", lista_ingresso[indice_ingresso].cod_ingresso, lista_ingresso[indice_ingresso].nome, lista_ingresso[indice_ingresso].sala);
            printf("Data: %s  Horário: %s\n", lista_ingresso[indice_ingresso].data, lista_ingresso[indice_ingresso].horario);
            printf("Tipo: %s\n", lista_ingresso[indice_ingresso].tipo);
            printf("Valor: %f\n\n", lista_ingresso[indice_ingresso].total);
            printf("--------------------------------------------------------------------\n\n");
            break;
          case 6: // Listar Reservas
            puts("\n__________________________________________________________________");      
            printf("\t\tLISTA DE RESERVAS");
            printf("\nCódigo  |      Peça      |  Sala  |  Data  |  Horário  |  Tipo  |  Total");
            puts("\n__________________________________________________________________");
            for(i = 0; i < indice_ingresso; i++) {
              printf("  %d     %s              %d      %s      %s      %s      %f", lista_ingresso.cod_ingresso, lista_ingresso.nome, lista_ingresso.sala, lista_ingresso.data, lista_ingresso.horario, lista_ingresso.tipo, lista_ingresso.total);
              puts("\n__________________________________________________________________");
            }
            puts("\n\nPressione ENTER para sair...");
            break;
          case 7: // Procurar Peça
            printf("\nCódigo da peça: ");
            scanf("%d", &lista_peca[indice_peca].cod_peca);
            for(i = 0; i < indice_peca; i++) {
              if(lista_peca.cod_peca == 0) {
                printf("%d - ",&lista_peca.cod_peca);
                getchar();
                printf("%s\n", lista_peca.nome);
                printf("%s\n", lista_peca.data);
                printf("%s\n", lista_peca.horario);
                printf("%d\n", lista_peca.sala);
                printf("%s\n", lista_peca.tipo);
                printf("%f", lista_peca.valor);
                puts("\n\n----->Código Encontrado com Sucesso<-----\n");    
                puts("\n\nPressione ENTER para sair...");  
                break;                               
              } //fim do if
            } //fim do for    
            break;
          case 8: // Procurar Ingresso
            printf("\nCódigo do ingresso: ");
            scanf("%d", &lista_ingresso[indice_ingresso].cod_ingresso);
            for(i = 0; i < indice_ingresso; i++) {
              if(lista_ingresso.cod_ingresso == 0) {
                printf("%d - ",&lista_ingresso.cod_ingresso);
                getchar();
                printf("%s\n", lista_ingresso.nome);
                printf("%s\n", lista_ingresso.data);
                printf("%s\n", lista_ingresso.horario);
                printf("%d\n", lista_ingresso.sala);
                printf("%s\n", lista_ingresso.tipo);
                printf("%f", lista_ingresso.valor);
                puts("\n\n----->Código Encontrado com Sucesso<-----\n");    
                puts("\n\nPressione ENTER para sair...");  
                break;                               
              } //fim do if
            } //fim do for    
            break;
          case 9: // Remover Peça
            printf("\nCódigo da peça: ");
            scanf("%d", &lista_peca[indice_peca].cod_peca);
            for(i = 0; i < indice_peca; i++) {
              if(lista_peca.cod_peca==0) {
                printf("Remova a peça [%s]: ", lista_peca.nome);
                gets(buffer);
                if(strlen(buffer) > 0) {
                  strcpy(lista_peca.nome, buffer);                                    
                }
                for(k = 1; k < indice_peca; k++) {
                  lista_peca[k] = lista_peca[k+1];
                }     
                indice_peca--;                       
              }
            }
            break;
          case 10: // Remover Ingresso
            printf("\nCódigo do ingresso: ");
            scanf("%d", &lista_ingresso[indice_ingresso].cod_ingresso);
            for(i = 0; i < indice_ingresso; i++) {
              if(lista_ingresso.cod_ingresso==0) {
                printf("Remova o ingresso [%s]: ", lista_ingresso.nome);
                gets(buffer);
                if(strlen(buffer) > 0) {
                  strcpy(lista_ingresso.nome, buffer);                                    
                }
                for(k = 1; k < indice_ingresso; k++) {
                  lista_ingresso[k] = lista_ingresso[k+1];
                }
                indice_ingresso--;                   
              }
            }
            break;
          case 99: // Sair
            return(0);
          default: // Opcao Invalida
            puts("Opção Inválida.");
            puts("\n\nPressione ENTER para sair...");
        } //fecha o switch            
        system("pause>>null");
        system("cls");
      } //fecha o while
    } //fecha o main

  2. Boa tarde! Fiz um código de uma bilheteria de teatro, mas não consigo pensar em uma função para o reservar o ingresso, alguém poderia me ajudar, por favor.

     

    #include <stdio.h>
    #include <conio.h>
    #include <string.h>
    #include <stdlib.h>
    
    // Estrutura da Peça Teatral.
    typedef struct peca
    {
    	unsigned long int codigo;
    	char nome[100];
    	char data[10];
    	char horario[5];
    	unsigned long int capacidade;
    	float valor;
    	struct peca* prox;
    } Peca;
    
    typedef struct ingresso
    {
    	unsigned long int codigo;
    	char nome[100];
    	char data[10];
    	char horario[5];
    	char tipo[20];
    	float total;
    	struct ingresso* prox;
    } Ingresso;
    
    // Declaração de funções da estrutura peça.
    Peca* inserir_pecas(Peca* primeiro);
    void listar_pecas(Peca* primeiro);
    Peca* excluir_pecas(Peca* primeiro);
    void alterar_pecas(Peca* primeiro);
    
    // Declaração de funções da estrutura ingresso.
    Ingresso* reservar_ingressos(Ingresso* segundo);
    void listar_ingressos(Ingresso* segundo);
    Ingresso* excluir_ingressos(Ingresso* segundo);
    
    main()
    {
    	// Declaração de variáveis.
    	Peca *primeiro = NULL;
    	Ingresso *segundo = NULL;
    	int opcao;
    	
    	// Artifício para repetir o programa.
    	while(opcao != 0)
    	{
    		// Menu de Opções.
    		printf("%c----------------------------------------------------------------------------%c\n", 201, 187);
    		printf(" | ");
    		printf("\t\t\t\t MENU DE OPÇÕES \t\t\t\t");
    		printf(" | ");
    		printf("\n\n");
    		printf("| 1 - Cadastrar peças |\n");
    		printf("| 2 - Listar peças |\n");
    		printf("| 3 - Alterar peças |\n");
    		printf("| 4 - Excluir peças |\n");
    		printf("| 5 - Reservar ingressos |\n");
    		printf("| 6 - Listar ingressos |\n");
    		printf("| 7 - Excluir ingressos |\n");
    		printf("| 0 - Finalizar sistema |\n\n");
    		printf("%c----------------------------------------------------------------------------%c\n\n", 200, 188);
    		printf("Comando: ");
    		scanf("%d", &opcao);
    		
    		// Lendo a opção do menu
    		fflush(stdin);
    		opcao = getch();
    		
    		// Executando as funções de acordo com a opção escolhida.
    		switch(opcao)
    		{
    			case 1:
    				// Inserindo peças.
    				fflush(stdin);
    				system("cls");
    				printf("%c----------------------------------------------------------------------------%c\n", 201, 187);
    				printf(" | ");
    				printf("\t\t\t CADASTRAR NOVA PEÇA \t\t\t");
    				printf(" | ");
    				printf("%c----------------------------------------------------------------------------%c\n\n", 200, 188);
    				primeiro = inserir_pecas(primeiro);
    				getch();
    				system("cls");
    				break;
    			case 2:
    				// Listando peças.
    				system("cls");
    				printf("%c----------------------------------------------------------------------------%c\n", 201, 187);
    				printf(" | ");
    				printf("\t\t\t PEÇAS CADASTRADAS \t\t\t");
    				printf(" | ");
    				printf("%c----------------------------------------------------------------------------%c\n\n", 200, 188);
    				listar_pecas(primeiro);
    				getch();
    				system("cls");
    				break;
    			case 3:
    				// Alterando peças da lista.
    				system("cls");
    				printf("%c----------------------------------------------------------------------------%c\n", 201, 187);
    				printf(" | ");
    				printf("\t\t\t ALTERAR PEÇAS CADASTRADAS \t\t\t");
    				printf(" | ");
    				printf("%c----------------------------------------------------------------------------%c\n\n", 200, 188);
    				alterar_pecas(primeiro);
    				getch();
    				system("cls");
    				break;
    			case 4:
    				// Excluindo peças da lista.
    				system("cls");
    				printf("%c----------------------------------------------------------------------------%c\n", 201, 187);
    				printf(" | ");
    				printf("\t\t\t EXCLUIR PEÇA CADASTRADA \t\t\t");
    				printf(" | ");
    				printf("%c----------------------------------------------------------------------------%c\n\n", 200, 188);
    				primeiro = excluir_pecas(primeiro);
    				getch();
    				system("cls");
    				break;
    			case 5:
    				// Reservando ingressos.
    				fflush(stdin);
    				system("cls");
    				printf("%c----------------------------------------------------------------------------%c\n", 201, 187);
    				printf(" | ");
    				printf("\t\t\t RESERVAR INGRESSO \t\t\t");
    				printf(" | ");
    				printf("%c----------------------------------------------------------------------------%c\n\n", 200, 188);
    				segundo = reservar_ingressos(segundo);
    				getch();
    				system("cls");
    				break;
    			case 6:
    				// Listando ingressos.
    				system("cls");
    				printf("%c----------------------------------------------------------------------------%c\n", 201, 187);
    				printf(" | ");
    				printf("\t\t\t INGRESSOS CADASTRADOS \t\t\t");
    				printf(" | ");
    				printf("%c----------------------------------------------------------------------------%c\n\n", 200, 188);
    				listar_ingressos(segundo);
    				getch();
    				system("cls");
    				break;
    			case 7:
    				// Excluindo peças da lista.
    				system("cls");
    				printf("%c----------------------------------------------------------------------------%c\n", 201, 187);
    				printf(" | ");
    				printf("\t\t\t EXCLUIR INGRESSO CADASTRADO \t\t\t");
    				printf(" | ");
    				printf("%c----------------------------------------------------------------------------%c\n\n", 200, 188);
    				segundo = excluir_ingressos(segundo);
    				getch();
    				system("cls");
    				break;
    			case 0:
    				// Artifício para finalizar o programa.
    				opcao = 0;
    				break;
    			default:
    				// Artifício que previne a situação de um usuário qualquer, digitar uma opção inexistente no menu.
    				system("cls");
    				break;
    		}
    	}
    }
    
    Peca* inserir_pecas (Peca *primeiro){
    	Peca peca;
    	Peca *atual = primeiro;
    	char identificador = 'F';
    	
    	// Lendo as informações da peça.
    	printf("Nome da peça: ");
    	fflush(stdin);
    	fgets(peca.nome, 100, stdin);
    	printf("\n");
    	printf("Data: ");
    	fflush(stdin);
    	fgets(peca.data, 10, stdin);
    	printf("\n");
    	printf("Horário: ");
    	fflush(stdin);
    	fgets(peca.horario, 5, stdin);
    	printf("\n");
    	printf("Valor do ingresso: ");
    	scanf("%f", &peca.valor);
    	printf("\n");
    	printf("Capacidade: ");
    	scanf("%u", &peca.capacidade);
    	printf("\n");
    	printf("Código: ");
    	scanf("%u", &peca.codigo);
    	printf("\n");
    	
    	// Verificando se o cadastro já existe.
    	for(atual=primeiro; atual!=NULL; atual=atual->prox){
    		if(atual->codigo==peca.codigo){
    			identificador = 'V';
    			break;
    		}
    	}
    	
    	if(identificador!='V' && (strlen(peca.nome)!=1 && strlen(peca.data)!=1)){
    		// Alocando os espaços e guardando as informações da peça.
    		Peca* NovaPeca=(Peca*) malloc (sizeof(Peca));
    		strcpy(NovaPeca->nome, peca.nome);
    		strcpy(NovaPeca->data, peca.data);
    		strcpy(NovaPeca->horario, peca.horario);
    		NovaPeca->capacidade= peca.capacidade;
    		NovaPeca->valor= peca.valor;
    		NovaPeca->codigo= peca.codigo;
    		NovaPeca->prox= primeiro;
    		printf(" Cadastro realizado com sucesso.");
    		printf("\n\n Pressione QUALQUER TECLA para voltar ao menu...");
    		return NovaPeca;
    	}else{
    		printf(" Cadastro inválido.");
    		printf("\n\n Pressione QUALQUER TECLA para voltar ao menu...");
    		exit(0);
    	}
    }
    
    void listar_pecas (Peca* primeiro){
    	Peca* atual; // Ponteiro para percorrer a lista sem perder a referência do primeiro elemento da lista.
    	
    	// Imprimindo as peças da lista, e suas respectivas informações.
    	for(atual= primeiro; atual!= NULL; atual= atual->prox){
    		printf("\nCódigo: ");
    		printf("%u", atual->codigo);
    		printf("\nPeça: ");
    		printf("%s", atual->nome);
    		printf("\nData: ");
    		printf("%s", atual->data);
    		printf("\nHorário: ");
    		printf("%s", atual->horario);
    		printf("\nCapacidade: ");
    		printf("%u", atual->capacidade);
    		printf("\nValor: ");
    		printf("%f", atual->valor);
    		printf("\n\n");
    	}
    	if(primeiro==NULL)
    		printf(" Nenhuma peça cadastrada.");
    		printf("\n\n Pressione QUALQUER TECLA para voltar ao menu...");
    }
    
    Peca* excluir_pecas(Peca *primeiro){
    	
    	Peca *anterior= NULL; // Ponteiro para saber o elemento anterior ao elemento atual da lista.
    	Peca *atual= primeiro; // Ponteiro para percorrer a lista sem perder o primeiro elemento da lista.
    	unsigned long int codigo=0;
    	
    	// Requisitando e lendo o código da peça a ser excluída.
    	printf("Código da peça: ");
    	fflush(stdin);
    	scanf("%u", &codigo);
    	
    	// Procurando a peça na lista.
    	while(atual!= NULL && atual->codigo!=codigo){
    		anterior= atual;
    		atual= atual->prox;
    	}
    	
    	// Mensagem caso a peça não seja encontrada.
    	if(atual==NULL){
    		printf("\n Peça não encontrada.");
    		printf("\n\n Pressione QUALQUER TECLA para voltar ao menu...");
    		return primeiro;
    	}
    	
    	// Excluindo a primeira peça da lista.
    	if(anterior==NULL){
    		printf("\n Conteúdo excluído com sucesso.");
    		primeiro= atual->prox;
    	// Excluindo uma peça do meio da lista.
    	}else{
    		printf("\n Conteúdo excluído com sucesso.");
    		anterior->prox= atual->prox;
    	}
    	
    	// Desalocando o espaço da memória.
    	free(atual);
    	printf("\n\n Pressione QUALQUER TECLA para voltar ao menu...");
    	return primeiro;
    }
    
    // Função para alterar peças.
    void alterar_pecas(Peca* primeiro){
    	char nome_substituto[100], data_substituta[10], horario_substituto[5];
    	unsigned long int capacidade_substituta;
    	float valor_substituto;
    	unsigned long int codigo;
    	Peca* atual=primeiro;
    	
    	// Requisitando e lendo o código da peças a ser alterada.
    	printf("\nCódigo da peça: ");
    	fflush(stdin);
    	scanf("%u", &codigo);
    	
    	// Procurando a peça na lista.
    	while(atual!= NULL && atual->codigo!=codigo){
    		atual= atual->prox;
    	}
    	
    	// Alterando os dados da peça.
    	if(atual!=NULL){
    		printf("\nNovo nome: ");
    		fflush(stdin);
    		fgets(nome_substituto, 100, stdin);
    		strcpy(atual->nome,nome_substituto);
    		printf("\nNova data: ");
    		fflush(stdin);
    		fgets(data_substituta, 10, stdin);
    		strcpy(atual->data,data_substituta);
    		printf("\nNovo horário: ");
    		fflush(stdin);
    		fgets(horario_substituto, 5, stdin);
    		strcpy(atual->horario,horario_substituto);
    		printf("\nNova capacidade: ");
    		fflush(stdin);
    		scanf("%u", &capacidade_substituta);
    		atual->capacidade == capacidade_substituta;
    		printf("\nNovo valor: ");
    		fflush(stdin);
    		scanf("%f", &valor_substituto);
    		atual->valor == valor_substituto;
    		printf("\n");
    		printf("Dados alterados com sucesso.");
    	}else{
    		printf("\nPeça não encontrada.");
    	}
    	printf("\n\n\nPressione QUALQUER TECLA para voltar ao menu...");
    	
    }
    
    void listar_ingressos (Ingresso* segundo){
    	Ingresso* atual; // Ponteiro para percorrer a lista sem perder a referência do primeiro elemento da lista.
    	
    	// Imprimindo od ingressos da lista, e suas respectivas informações.
    	for(atual= segundo; atual!= NULL; atual= atual->prox){
    		printf("\nCódigo: ");
    		printf("%u", atual->codigo);
    		printf("\nPeça: ");
    		printf("%s", atual->nome);
    		printf("\nData: ");
    		printf("%s", atual->data);
    		printf("\nHorário: ");
    		printf("%s", atual->horario);
    		printf("\nTipo: ");
    		printf("%s", atual->tipo);
    		printf("\nValor: ");
    		printf("%f", atual->total);
    		printf("\n\n");
    	}
    	if(segundo==NULL)
    		printf(" Nenhum ingresso cadastrado.");
    		printf("\n\n Pressione QUALQUER TECLA para voltar ao menu...");
    }
    
    Ingresso* excluir_ingressos(Ingresso *segundo){
    	
    	Ingresso *anterior= NULL; // Ponteiro para saber o elemento anterior ao elemento atual da lista.
    	Ingresso *atual= segundo; // Ponteiro para percorrer a lista sem perder o primeiro elemento da lista.
    	unsigned long int codigo=0;
    	
    	// Requisitando e lendo o código do ingresso a ser excluído.
    	printf("Código do ingresso: ");
    	fflush(stdin);
    	scanf("%u", &codigo);
    	
    	// Procurando o ingresso na lista.
    	while(atual!= NULL && atual->codigo!=codigo){
    		anterior= atual;
    		atual= atual->prox;
    	}
    	
    	// Mensagem caso o ingresso não seja encontrado.
    	if(atual==NULL){
    		printf("\n Ingresso não encontrado.");
    		printf("\n\n Pressione QUALQUER TECLA para voltar ao menu...");
    		return segundo;
    	}
    	
    	// Excluindo o primeiro ingresso da lista.
    	if(anterior==NULL){
    		printf("\n Conteúdo excluído com sucesso.");
    		segundo= atual->prox;
    	// Excluindo um ingresso do meio da lista.
    	}else{
    		printf("\n Conteúdo excluído com sucesso.");
    		anterior->prox= atual->prox;
    	}
    	
    	// Desalocando o espaço da memória.
    	free(atual);
    	printf("\n\n Pressione QUALQUER TECLA para voltar ao menu...");
    	return segundo;
    }

     

  3. Boa tarde!

    Preciso para essa semana fazer o desenvolvimento de um código de bilheteria de um teatro e não estou conseguindo, alguém poderia me ajudar, já pesquisei em muito fóruns e ninguém me ajuda.

     

    #include <stdio.h>
    #include <stdlib.h>
    
    int main(){
    	
    	int CAD[30][60];
    	int opcao,total,quant,q;
    	int i;
    	int j;
    	
    	for(i=0;i<=30;i++){
    		for(j=0;j<=60;j++){
    			CAD[i][j]=0;
    		}
    	}
    	
    	do{
    		printf("********** SEJA BEM-VINDO(A) AO TEATRO AURORA! **********");
    		printf("\n\n");
    		printf("1 - Ver Assentos Disponiveis\n");
    		printf("2 - Comprar Ingressos\n");
    		printf("3 - Cancelar Ingresso\n");
    		printf("4 - Faturar\n");
    		printf("5 - Encerrar o Sistema\n");
    		printf("\n");
    		printf("Comando: ");
    		scanf("%d", &opcao);
    		printf("\n");
    		
    		switch(opcao){
    			case 1:
    				for(i=0;i<=30;i++){
    					for(j=0;j<=60;j++){
    						if(CAD[i][j]==1){
    							printf("\nAssentos Ocupados: [%d][%d]", i, j);
    						}else{
    							printf("\nNenhum assento ocupado!\n");
    						}
    					}
    				}
    				break;
    			case 2:
    				for(i=0;i<=30;i++){
    					for(j=0;j<=60;j++){
    						printf("\nFila: ");
    						scanf("%d", &i);
    						printf("\nAssento: ");
    						scanf("%d", &j);
    						if(CAD[i][j]==0){
    							printf("\nAssento reservado com sucesso!\n");
    							CAD[i][j]=1;
    							main();
    						}else{
    							printf("\nAssento ocupado!");
    							main();
    						}
    					}
    				}
    				break;
    			case 3:
    				break;
    			case 4:
    				break;
    		}
    	}while(opcao!=5);
    	
    	system("pause");
    	return 0;
    }

     

×
×
  • Criar Novo...