Ir ao conteúdo
  • Cadastre-se

C++ Vetor multidimensional: programa em C++


Posts recomendados

Preciso de ajuda em uma atividade, que pede o seguinte:

Crie um programa que simule a ''compra de passagens aéreas de uma empresa'', mostrando ao usuário um menu inicial com as opções de reserva e cancelamento, em seguida os destino disponíveis, os dias disponíveis, os horários disponíveis, a fila pretendida e por ultimo a poltrona desejada. No final, o programa deve mostrar ao usuário um mapa de lugares do voo desejado: caso o lugar esteja vago, mostre seu número, seguinte forma, o número da fila com dois dígitos seguindo do número da
poltrona com dois dígitos. Ex: primeira poltrona na primeira fila, o número será 0101. Caso a poltrona já esteja ocupada, informe no lugar do código, imprimir “OCUP”. Se o usuário escolher uma poltrona inválida ou já reservada, mostre uma mensagem de erro. Caso escolha um lugar vago, mostre a mensagem, reserva foi efetuada com sucesso e retorne ao menu principal. O programa será feito com um vetor multidimensional, ele deve ler o ARQUIVO DE ENTRADA que contém o mapa de reservas. Na
primeira linha do arquivo deve conter a quantidade de destinos (máximo 8), a quantidade de dias
(máximo 7), a quantidade de horários (máximo de 4), a quantidade de filas (máximo de 20), e a
quantidade de poltronas por fila (máximo de 8). O sistema informatizado deve ser capaz de fazer a
venda semanal de lugares, e ao ser finalizado o mapa atual de reservas deve ser gravado e sobrescrito
sobre o arquivo de entrada.  OBS: Não devem ser utilizadas variáveis globais, não deve ser utilizada a biblioteca string.h.

Não sei como fazer sem o uso da string.h, desde já agradeço quem puder me auxiliar, pois estou com muita dificuldade.

Link para o post
Compartilhar em outros sites

Eu consegui fazer apenas dessa forma:

 

#include <stdio.h>
#include <stdlib.h> 

int LeOpcaoMenu(void) {
    int op;

    system("cls");
    printf("\n\nBem vindo ao sistema de venda de passagens aereas\n\n\n");
    printf("\n\nOpcoes Disponiveis\n\n");
    printf("1 - Fazer Reserva\n");
    printf("2 - Cancelar Reserva\n");
    printf("3 - Sair\n");
    printf("\n\nOpção desejada: ");

    scanf("%d", &op);
    return(op);
}

int LeDestino(int qdestino, char destinos[8][20]) {
    int op, i;

    do { 
        system("cls");
        printf("\n\nDestinos Disponiveis\n\n");
        for (i = 0; i < qdestino; i ++ ) {
            printf("%d - %s\n", i+1, destinos[i]);
         }
        printf("%d - Volta ao Menu Inicial\n", i+1);
        printf("\n\nOpcao desejada: ");

        scanf("%d", &op);
        if (op <1 || op > qdestino +1) {
            printf("\nOpcao invalida !! \n");
            system("pause");
        }
    }while (op <1 || op > qdestino+1);
    return(op);
}


int LeDia(int destino, char destinos[8][20], int qdias, char dias_semana[7][8]) {
    int op, i;

    do { 
        system("cls");
        printf("\n\nDias Disponiveis para o destino %s\n\n", destinos[destino-1]);
        for (i = 0; i < qdias; i ++ ) {
            printf("%d - %s\n", i+1, dias_semana[i]);
         }
        printf("%d - Volta ao Menu Inicial\n", i+1);
        printf("\n\nOpcao desejada: ");

        scanf("%d", &op);
        if (op <1 || op > qdias +1) {
            printf("\nOpcao invalida !! \n");
            system("pause");
        }
    }while (op <1 || op > qdias+1);
    return(op);
}


int LeHorario(int destino, char destinos[8][20], int dia, char dias_semana[7][8], int qhorario, char horarios[4][8]) {
    int op, i;

    do { 
        system("cls");
        printf("\nHorarios Disponiveis para o destino %s na %s:\n\n", destinos[destino-1], dias_semana[dia-1]);
        for (i = 0; i < qhorario; i ++ ) {
            printf("%d - %s\n", i+1, horarios[i]);
         }
        printf("%d - Volta ao Menu Inicial\n", i+1);

        printf("\n\nOpcao desejada: ");

        scanf("%d", &op);
        if (op <1 || op > qhorario+1) {
            printf("\nOpcao Invalida !! \n");
            system("pause");
        }
    }while (op <1 || op > qhorario+1);
    return(op);
}


int LeFila(int destino, char destinos[8][20], int dia, char dias_semana[7][8], int horario, char horarios[4][8], int qfila, char filas[20][8]) {
    int op, i;

    do { 
        system("cls");
        printf("\nEscolha uma dentre as seguintes filas:\n\n");
        for (i = 0; i < qfila; i ++ ) {
            printf("%d - %s\n", i+1, filas[i]);
         }
        printf("%d - Volta ao Menu Inicial\n", i+1);

        printf("\n\nOpcao desejada: ");

        scanf("%d", &op);
        if (op <1 || op > qfila+1) {
            printf("\nOpcao Invalida !! \n");
            system("pause");
        }
    }while (op <1 || op > qfila+1);
    return(op);
}

int LePoltrona(int destino, char destinos[8][20], int dia, char dias_semana[7][8], int horario, char horarios[4][8], int fila, char filas[20][8], int qpoltrona, char poltronas[8][20]) {
    int op, i;

    do { 
        system("cls");
        printf("\nEscolha uma dentre as seguintes poltronas disponiveis:\n\n");
        for (i = 0; i < qpoltrona; i ++ ) {
            printf("%d - %s\n", i+1, poltronas[i]);
         }
        printf("%d - Volta ao Menu Inicial\n", i+1);

        printf("\n\nOpcao desejada: ");

        scanf("%d", &op);
        if (op <1 || op > qpoltrona+1) {
            printf("\nOpcao Invalida !! \n");
            system("pause");
        }
    }while (op <1 || op > qpoltrona+1);
    return(op);
}

void ReservaVagas(int qdestino, int qdias, int qhorarios, int qfila, int qpoltrona, char destinos[8][20], char dias_semana[7][8], char horarios[4][8], char filas[20][8], char poltronas[8][20]) {
    int p, d, h, f, a;
    p = LeDestino(qdestino, destinos);
    if (p <= qdestino) {
        d = LeDia(p, destinos, qdias, dias_semana);
        if (d <= qdias) {
            h = LeHorario(p, destinos, d, dias_semana, qhorarios, horarios);
            if (h <= qhorarios){
                f = LeFila(p, destinos, d, dias_semana, h, horarios, qfila, filas);
                if (f <= qfila){
                    a = LePoltrona(p, destinos, d, dias_semana, h, horarios, f, filas, qpoltrona, poltronas);
                    if (a <= qpoltrona){
                        
                    printf("\n\nVoce fez reserva para viagem com destino a %s, %s, as %s, voce escolheu a poltrona %s na %s\n\n", destinos[p-1],dias_semana[d-1], horarios[h-1], poltronas[a-1], filas[f-1]);
                    system("pause");
                    }
                
                }
                
            }
        }
    }

}

void CancelaReserva(int qdestino, int qdias, int qhorarios, char destinos[8][20], char dias_semana[7][8], char horarios[4][8]) {
    
    int p, d, h;
    p = LeDestino(qdestino, destinos);
    if (p <= qdestino) {
        d = LeDia(p, destinos, qdias, dias_semana);
        if (d <= qdias) {
            h = LeHorario(p, destinos, d, dias_semana, qhorarios, horarios);
            if (h <= qhorarios){
                    printf("\n\nCancelamento Realizado com sucesso\nVoce cancelou a sua viagem para %s, que seria em uma %s, no horario das %s\n\n", destinos[p-1],dias_semana[d-1], horarios[h-1]);
                    system("pause");
            }
                 
        }
         
    }
}
    


int main() {
    int op;
    
    char destinos[8][20]={"Rio de Janeiro RJ", "Sao Paulo SP", "Belo Horizonte MG", "Santa Catarina RS", "Salvador BA", "Recife PE", "Palmas TO", "Belem do Para PA "};
    char dias_semana[7][8]={"Segunda", "Terca", "Quarta", "Quinta", "Sexta", "sábado", "Domingo"};
    char horarios[4][8]={"09:00 h", "13:00 h", "17:00 h", "21:00 h"};
    char filas[20][8]={"fila 1", "fila 2", "fila 3", "fila 4", "fila 5", "fila 6", "fila 7", "fila 8", "fila 9", "fila 10", "fila 11", "fila 12", "fila 13", "fila 14", "fila 15", "fila 16", "fila 17", "fila 18", "fila 19", "fila 20"};
    char poltronas[8][20]={"1", "2", "3", "4", "5", "6", "7", "8"};

      do {
        
        op = LeOpcaoMenu();
        switch (op) {
            case 1:
                system("cls");
                ReservaVagas(8, 7, 4, 20, 8, destinos,  dias_semana, horarios, filas, poltronas);    
                break;
               case 2:
                system("cls");
                CancelaReserva(8, 7, 4, destinos, dias_semana, horarios);
                break;
               case 3:
                system("cls");
                printf("\n\nPROGRAMA FINALIZADO !!!\n\n");
                system("pause");
                break;
            default:
                 printf("\nOpcao invalida.\n");
                system("pause");
           }
    } while (op != 3);
}

 

 

Ao longo do programa precisaria mostrar ao usuário, as opções de vagas em forma de matriz (filas por poltronas) em que cada vaga seria representada por 4 dígitos, ex: 0102, 1ª fila, 2ª poltrona. Além de mostrar algumas das vagas já ocupadas, pelo texto OCUP. No fim, mostraria a matriz final com sua vaga secionada. É estas matrizes que eu não consegui fazer para se adequar ao código, necessitaria ser um vetor multidimensional (*****) para cada dimensão ser ocupada (destinos, dias, horários, filas e poltronas).

Link para o post
Compartilhar em outros sites
21 horas atrás, Valdeir Medeiros disse:

OBS: Não devem ser utilizadas variáveis globais, não deve ser utilizada a biblioteca string.h.

Não sei como fazer sem o uso da string.h, desde já agradeço quem puder me auxiliar, pois estou com muita dificuldade

 

Usar variáveis globais só iria aumentar sua dificuldade, então é um bonus.

 

Sobre string.h: De que função está sentindo falta a ponto de ser um problema nesse caso?

 

Funções em string.h, como em TutorialsPoint

 

Em resumo lá tem 22 funções. Qual delas está fazendo falta aqui?

 

memset(), memcpy(), strlen(), strcpy()? Qual?

 

Escreva seu programa em torno dos dados. Vai ler um arquivo. É por aí que começa, não por um menu. Assim só vai perder tempo. Escreva separado o processo e a interface. 

 

34 minutos atrás, Valdeir Medeiros disse:

necessitaria ser um vetor multidimensional (*****) para cada dimensão ser ocupada (destinos, dias, horários, filas e poltronas)

 

Não Precisa. 

 

C sequer tem vetores multidimensionais como em FORTRAN. Apenas vetores. E vetores de vetores e assim por diante.

 

Use uma estrutura com os dados. Se preocupe com o voo, origem, destino. Com os limites que estão no enunciado.
 

21 horas atrás, Valdeir Medeiros disse:

a quantidade de destinos (máximo 8), a quantidade de dias
(máximo 7), a quantidade de horários (máximo de 4), a quantidade de filas (máximo de 20), e a
quantidade de poltronas por fila (máximo de 😎

 

Isso é tudo que existe: 8 destinos. Escreva em torno ds dados. É o mais simples. 

 

Um vetor de destinos, com 8 destinos. E por aí vai.

 

Não escreva o programa todo ANTES de entender os dados

Vai levar 10x mais e conseguir 10x menos. Ou algo assim :) 

  • Obrigado 1
Link para o post
Compartilhar em outros sites

O arquivo de entrada será o mesmo de saída, para o usuário! 

 

Fiz essa primeira parte da leitura/impressão do arquivo de entrada:

 

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

#define MAX_DESTINOS     8
#define MAX_DIAS         7
#define MAX_HORARIOS     4
#define MAX_FILAS        20
#define MAX_POLTRONAS     8


int ***** LeVetorArquivo(int *qdestinos, int *qdias, int *qhorarios, int *qfilas, int *qpoltronas) {
      FILE *fr;
      int *****v;
      int i, j, k, l, m;

      fr = fopen ("reserva.txt", "r");

      if (fr == NULL) {
            perror("reserva.txt");
            exit(-1);  /* Abandona o programa */  
      }
  
      fscanf(fr, "%d %d %d %d %d", qdestinos, qdias, qhorarios, qfilas, qpoltronas);

    if ((*qdestinos < 1 || *qdestinos > MAX_DESTINOS)|| (*qdias < 1 || *qdias > MAX_DIAS) || (*qhorarios < 1 || *qhorarios > MAX_HORARIOS) ||
          (*qfilas < 1 || *qfilas > MAX_FILAS) || (*qpoltronas < 1 || *qpoltronas > MAX_POLTRONAS)) {
        printf("Arquivo invalido\n");
        exit(-2);
    }
    
      v = (int *****) malloc (*qdestinos * sizeof(int ****));
        for (i = 0; i < *qdestinos; i++)
            v[i] = (int ****) malloc (*qhorarios  * sizeof(int ***));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
                v[i][j] = (int ***) malloc (*qhorarios * sizeof(int **));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
            for (k =0; k < *qhorarios; k ++) 
                    v[i][j][k] = (int **) malloc (*qfilas  * sizeof(int *));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
            for (k =0; k < *qhorarios; k ++) 
                for (l = 0; l < *qfilas; l++)
                        v[i][j][k][l] = (int *) malloc (*qpoltronas  * sizeof(int));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
            for (k =0; k < *qhorarios; k ++) 
                for (l = 0; l < *qfilas; l++)
                    for (m = 0; m < *qpoltronas; m++)
                            fscanf(fr, "%d", &v[i][j][k][l][m]);        
      fclose(fr);
    return(v);
  
}

void EscreveVetorArquivo(int *****v, int qdestinos, int qdias, int qhorarios, int qfilas, int qpoltronas) {
      FILE *fw;
      int i, j, k , l, m;

      fw = fopen ("reserva1.txt", "w");

      if (fw == NULL) {
            perror("reserva1.txt");
            exit(-1);  /* Abandona o programa */  
      }
      fprintf(fw, "%d %d %d %d %d\n\n", qdestinos, qdias, qhorarios, qfilas, qpoltronas); 
  
      for (i = 0; i < qdestinos; i++) {
        for (j =0; j < qdias; j++)  {
            for (k =0; k < qhorarios; k ++) {
                for (l = 0; l < qfilas; l++){
                    for (m = 0; m < qpoltronas; m++) {
                            fprintf(fw, "%d ", v[i][j][k][l][m]);
                    }
                    fprintf(fw, "\n");
                }
                fprintf(fw, "\n\n");
            }
        }
    }
      fclose(fw);  
}

int main() {
      int *****v;
      int i, qdestinos, qdias, qhorarios, qfilas, qpoltronas;
  
      v = LeVetorArquivo(&qdestinos, &qdias, &qhorarios, &qfilas, &qpoltronas);
      EscreveVetorArquivo(v, qdestinos, qdias, qhorarios, qfilas, qpoltronas);

      for (i = 0; i < qfilas; i++)
        free(v[i]);
      free(v);
  
      printf("\n\n");
      
      system("pause");
      
      return 0;
}

 

"serão somente 2 destinos, 2 dias e 2 horários"

Seguem os arquivos, reserva.txt e reserva1.txt :

 

2 2 2 6 8

1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 


1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
1 0 0 1 0 0 0 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 


1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
1 0 0 1 0 0 0 1 


1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 1 0 0 0 0 0 1 
0 0 0 0 0 0 0 0 
1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 


1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 


1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 


1 1 1 1 1 1 1 1 
1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 


1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
1 1 1 1 1 1 1 1 


 

O que acham, estou indo em um caminho correto?

Link para o post
Compartilhar em outros sites
35 minutos atrás, Valdeir Medeiros disse:

O arquivo de entrada será o mesmo de saída, para o usuário! 

 

Não faça isso. 

 

Se vai gravar no mesmo arquivo apenas grave em outro e ao final se deu tudo certo você muda o nome para o original. 

Não pode se arriscar a perder o arquivo original. Não seria esperto.

Link para o post
Compartilhar em outros sites

Essa parte com a alocação das 5 dimensões que vão ser usadas. A leitura dos dados para impressão na tela, o que acham de errado? 

 

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

#define MAX_DESTINOS     8
#define MAX_DIAS         7
#define MAX_HORARIOS     4
#define MAX_FILAS        20
#define MAX_POLTRONAS     8

int ***** LeVetorArquivo(int *qdestinos, int *qdias, int *qhorarios, int *qfilas, int *qpoltronas, char Arq[]) {
      FILE *fr;
      int *****v;
      int i, j, k, l, m;

      fr = fopen (Arq, "r");

      if (fr == NULL) {
            perror(Arq);
            exit(-1);  /* Abandona o programa */  
      }
  
      fscanf(fr, "%d %d %d %d %d", qdestinos, qdias, qhorarios, qfilas, qpoltronas);

    if ((*qdestinos < 1 || *qdestinos > MAX_DESTINOS)|| (*qdias < 1 || *qdias > MAX_DIAS) || (*qhorarios < 1 || *qhorarios > MAX_HORARIOS) ||
          (*qfilas < 1 || *qfilas > MAX_FILAS) || (*qpoltronas < 1 || *qpoltronas > MAX_POLTRONAS)) {
        printf("Arquivo invalido\n");
        exit(-2);
    }
    
      v = (int *****) malloc (*qdestinos * sizeof(int ****));
        for (i = 0; i < *qdestinos; i++)
            v[i] = (int ****) malloc (*qhorarios  * sizeof(int ***));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
                v[i][j] = (int ***) malloc (*qhorarios * sizeof(int **));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
            for (k =0; k < *qhorarios; k ++) 
                    v[i][j][k] = (int **) malloc (*qfilas  * sizeof(int *));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
            for (k =0; k < *qhorarios; k ++) 
                for (l = 0; l < *qfilas; l++)
                        v[i][j][k][l] = (int *) malloc (*qpoltronas  * sizeof(int));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
            for (k =0; k < *qhorarios; k ++) 
                for (l = 0; l < *qfilas; l++)
                    for (m = 0; m < *qpoltronas; m++)
                            fscanf(fr, "%d", &v[i][j][k][l][m]);        
      fclose(fr);
    return(v);
  
}

int **AlocaMatrizInt(int nlin, int ncol){
     int **mat;
     int i;
      mat = (int **) malloc (nlin * sizeof(int*));
  
      for (i = 0; i < nlin; i++)
            mat[i] = (int *) malloc (ncol  * sizeof(int));    
    return(mat);
}

void LeMatrizArquivo(int ***A, int *linA, int *colA, char Arq[]) {
      FILE *fr;
      int **mat;
      int i, j;

      fr = fopen (Arq, "r");
      if (fr == NULL) {
        perror(Arq);
        exit(1);  /* Abandona o programa */  
      }
  
      fscanf(fr, "%d %d", linA, colA);
      
      //Alocando memória para a matriz A
      mat = AlocaMatrizInt(*linA, *colA);

      //Leitura da matriz
      for (i = 0; i < *linA; i++)
        for (j = 0; j < *colA; j++) {
            fscanf(fr, "%d", &mat[i][j]);
        }
      *A = mat;
      fclose(fr);
  
}

void ImprimeMatriz(int **mat, int lin, int col, FILE *f) {
      int i, j;
  
      for (i = 0; i < lin; i++) {
            for (j = 0; j < col; j++) {
              fprintf(f, "%3d ", mat[i][j]);
        }
        fprintf(f, "\n");
    }
}

void LiberaMemoria(int ** mat, int lin) {
    int i;

      for (i = 0; i < lin; i++)
            free(mat[i]);
      free(mat);
}

void EscreveMatrizArquivo(int **A, int lin, int col, char Arq[]) {
      FILE *fw;
      int i, j;

      fw = fopen (Arq, "w");
      if (fw == NULL) {
            perror(Arq);
            exit(2);  /* Abandona o programa */  
      }
 
      fprintf(fw, "#Matriz A\n");   
      fprintf(fw, "%d %d\n", lin, col); /* Dimensao da matriz */
       ImprimeMatriz(A, lin, col, fw);
}

int main(int argc, char *argv[]) {
      int **A;
      int i, nlinA, ncolA;
      
    setlocale(LC_ALL,""); // Alterando para a localidade do sistema (português).
      system("color F1");      // mudando a cor do fundo e a cor da fonte
      if (argc != 3) {
           printf("Uso: %s <arquivo entrada> <arquivo saída> \n", argv[0]); 
            return 1;
      }

      LeMatrizArquivo(&A, &nlinA, &ncolA, argv[1]);    
      
    printf("\n\nImpressão Matriz A\n\n");
    ImprimeMatriz(A, nlinA, ncolA, stdout);
    EscreveMatrizArquivo(A, nlinA, ncolA, argv[2]);
    LiberaMemoria(A, nlinA);
    
    system("pause");
}

Link para o post
Compartilhar em outros sites
Em 14/04/2021 às 19:07, arfneto disse:

Isso é tudo que existe: 8 destinos. Escreva em torno ds dados. É o mais simples. 

 

Um vetor de destinos, com 8 destinos

 

Como eu disse na ocasião, escreva em torno dos dados.

Está incrivelmente complicado do modo que está escrevendo. Vai dar muito mais trabalho e ficar muito mais frágil. É possível no entanto.

 

 v = (int *****) malloc (*qdestinos * sizeof(int ****));
        for (i = 0; i < *qdestinos; i++)
            v[i] = (int ****) malloc (*qhorarios  * sizeof(int ***));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
                v[i][j] = (int ***) malloc (*qhorarios * sizeof(int **));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
            for (k =0; k < *qhorarios; k ++) 
                    v[i][j][k] = (int **) malloc (*qfilas  * sizeof(int *));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
            for (k =0; k < *qhorarios; k ++) 
                for (l = 0; l < *qfilas; l++)
                        v[i][j][k][l] = (int *) malloc (*qpoltronas  * sizeof(int));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
            for (k =0; k < *qhorarios; k ++) 
                for (l = 0; l < *qfilas; l++)
                    for (m = 0; m < *qpoltronas; m++)
                            fscanf(fr, "%d", &v[i][j][k][l][m]);        

 

Nesse trecho acima por exemplo há QUINZE for e vários malloc(0 curiosos.
 

Entenda que 


Se int* é um ponteiro então qualquer coisa que comece por int* é um ponteiro e terá esse mesmo tamanho, 4 ou 8 bytes dependendo da plataforma. int***************** também é um ponteiro... todos os sizeof vão retornar o mesmo tamanho. Escreva em torno dos dados. Escreva um modelo de exemplo, completo. Antes do código escreva os dados.

 

 

Link para o post
Compartilhar em outros sites
Em 14/04/2021 às 18:29, Valdeir Medeiros disse:

No fim, mostraria a matriz final com sua vaga secionada. É estas matrizes que eu não consegui fazer para se adequar ao código, necessitaria ser um vetor multidimensional (*****) para cada dimensão ser ocupada (destinos, dias, horários, filas e poltronas).

 

Entenda que (int******) não significa em absoluto um vetor de int de 6 dimensões. Um asterisco não indica dimensão. Apenas um nível de endereçamento. Sei que até autores tentam criar essa conotação, mas não existe. int******** por exemplo é um ponteiro e ocupa sizeof(int*) bytes. Só isso.

 

C, C++ ou C# sequer tem vetor "multidimensional" como tem em FORTRAN. Apenas vetor.

 

No caso desse programa

 

São duas entidades, os voos e as passagens. Você tem 224 = 7*8*4 voos possíveis. É claro que pode esperar vender algum ticket para "abrir" um voo e não considerar os 224. Mas com um número tão pequeno de voos não parece valer a pena pensar nisso

 

Cada voo pode ter até 160 = 20 * 8 poltronas. 

 

Se quer ter isso em unidades mesmo poderia declarar 
 

    char	poltrona[8][7][4][20][8];

 

E isso é o mais perto que C pode chegar de vetor multidimensional: vetor de vetor de vetor de vetor e tal...

 

Se quer usar alocação dinâmica pode claro ver isso como
 

    char***** poltrona;

 

Mas isso não é multidimensional e sequer garante o que diz o enunciado. Mas funciona e precisaria de 5 variáveis adicionais para alocar tido mundo. Só isso. 

 

Compare com o exemplo mais óbvio e comum disso: main(). 
 

    int main( int argc, char**argv );

 

e acho que vai entender. É preciso montar isso na memória a partir do arquivo de entrada, refletindo a situação em termos de passagens e voos para os próximos dias

 

No entanto acho que ninguem deve escrever assim. Muito complicado e difícil de ler e testar.

 

Se

 

    char	poltrona[8][7][4][20][8];

 

São apenas 35K bytes para tudo. Veja esse trecho por exemplo

 

 #include <string.h>
 int main(void)
 {
    char    poltrona[8][7][4][20][8]; // tudo
    char    terceiro_destino[7][4][20][8];
    memcpy( terceiro_destino, poltrona[2], sizeof(terceiro_destino));

    char	voo_amanha[4][20][8]; // voos de amanha para esse destino
    memcpy( voo_amanha, terceiro_destino[1], sizeof(voo_amanha));

    return 0;
 }

 

E pode usar algo assim. Mas é complicado de conferir...

 

Outro exemplo
 


typedef struct
{
    int     id; // passagem
    int     id_voo; // comparar int eh mais fácil
    char    fila[2];
    char    poltrona[2];
    char*   voo;

}   Ticket; // pra poder fechar a conta dos voos e conferir tudo 


typedef struct
{
    int             id; // pode ser util identificar o voo por numero
    char*           voo; // um nome pode ser FL-destino-Hora-AnoMesDia
    unsigned char   filas; // maximo 20 filas
    unsigned char   poltronas; // maximo 8 poltronas/fila
    Ticket*         mapa[20][8]; // mapa 20x8 com as poltronas

}   Voo;


typedef struct
{
    char*           arquivo; // origem no disco
    unsigned char   destinos; // ate 8 destinos
    unsigned char   dias; // ate 7 dias adiante
    char            hoje[6]; // para controlar o prazo AAMMDD
    unsigned char   horarios; // ate 4 horarios/dia
    int             id; // pode ser util depois
    Voo*            voos[8][7][4];

}   Mapa;

 

Usando algo assim fica mais fácil.

 

Os voos tem tickets associados. e os tickets estão associados a voos. lendo e salvando os dois em disco fica claro se está tudo certo porque na carga os tickets tem que bater com os  voos. E cada ticket aponta para seu voo e cada voo tem os endere;cos dos tickets.

 

Assim pode implementar algo mais perto da realidade e sem levar o dia todo. 

 

O arquivo de entrada podia ser de texto e ter linhas assim

 

8 7 4 20 8 destinos dias horarios filas poltronas
FL[Destino][horario][AnoMesDia][Reserva=PPFFTK][PPFFTK][PPFFTK]...
TK[Ticket id][Voo][Poltrona]

 

E fica fácil de criar os dados na memória e validar tudo.

Link para o post
Compartilhar em outros sites
  • 2 semanas depois...

Eu formatei, agora são 2 destinos, 2 dias e 2 horários, devem formar 8 matrizes de  6x8 (6 filas x 8 poltronas). Ao passo que  o usuário escolhe, deveria ser mostrado a ele o mapa de vagas disponíveis, quando é confirmada a fila e a poltrona, um outro mapa seria mostrado a ele com a sua vaga em OCUP. Na opção de cancelamento, o usuário informa a fila e a poltrona que deseja cancelar a reserva,  se o usuário escolher uma poltrona inválida ou já reservada deve ser dada uma
mensagem de erro adequada; Caso contrário a reserva deve ser cancelada, e uma
mensagem deve ser dada informando que a reserva foi cancelada, juntamente com o mapa e a sua vaga disponivel.

 


Este é o código que consegui desenvolver até agora.

 

 

Código:

 

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

#define MAX_DESTINOS     8
#define MAX_DIAS         7
#define MAX_HORARIOS     4
#define MAX_FILAS        20
#define MAX_POLTRONAS     8

int opdestinos;
int opdias;
int ophorarios;
int opfilas;
int oppoltronas;

int *****LeVetorArquivo(int *qdestinos, int *qdias, int *qhorarios, int *qfilas, int *qpoltronas) {
      FILE *fr;
      int *****v;
      int i, j, k, l, m;

      fr = fopen ("reserva.txt", "r");

      if (fr == NULL) {
            perror("reserva.txt");
            exit(-1);  /* Abandona o programa */  
      }
  
      fscanf(fr, "%d %d %d %d %d", qdestinos, qdias, qhorarios, qfilas, qpoltronas);

    if ((*qdestinos < 1 || *qdestinos > MAX_DESTINOS)|| (*qdias < 1 || *qdias > MAX_DIAS) || (*qhorarios < 1 || *qhorarios > MAX_HORARIOS) ||
          (*qfilas < 1 || *qfilas > MAX_FILAS) || (*qpoltronas < 1 || *qpoltronas > MAX_POLTRONAS)) {
        printf("Arquivo invalido\n");
        exit(-2);
    }
    
      v = (int *****) malloc (*qdestinos * sizeof(int****));
        for (i = 0; i < *qdestinos; i++)
            v[i] = (int ****) malloc (*qhorarios  * sizeof(int***));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
                v[i][j] = (int ***) malloc (*qhorarios  * sizeof(int**));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
            for (k =0; k < *qhorarios; k ++) 
                    v[i][j][k] = (int **) malloc (*qfilas  * sizeof(int*));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
            for (k =0; k < *qhorarios; k ++) 
                for (l = 0; l < *qfilas; l++)
                        v[i][j][k][l] = (int *) malloc (*qpoltronas  * sizeof(int));

      for (i = 0; i < *qdestinos; i++)
        for (j =0; j < *qdias; j++) 
            for (k =0; k < *qhorarios; k ++) 
                for (l = 0; l < *qfilas; l++)
                    for (m = 0; m < *qpoltronas; m++)
                            fscanf(fr, "%d", &v[i][j][k][l][m]);        
      fclose(fr);
    return(v);
  
}

void EscreveVetorArquivo(int *****v, int qdestinos, int qdias, int qhorarios, int qfilas, int qpoltronas) {
      FILE *fw;
      int i, j, k , l, m;

      fw = fopen ("reserva.txt", "w");

      if (fw == NULL) {
            perror("reserva.txt");
            exit(-1);  /* Abandona o programa */  
      }
      fprintf(fw, "%d %d %d %d %d\n\n", qdestinos, qdias, qhorarios, qfilas, qpoltronas); 
  
      for (i = 0; i < qdestinos; i++) {
        for (j =0; j < qdias; j++)  {
            for (k =0; k < qhorarios; k ++) {
                for (l = 0; l < qfilas; l++){
                    for (m = 0; m < qpoltronas; m++) {
                            fprintf(fw, "%d ", v[i][j][k][l][m]);
                    }
                    fprintf(fw, "\n");
                }
                fprintf(fw, "\n\n");
            }
        }
    }
      fclose(fw);  
}

void LiberaMemoria(int ***** v, int qdestinos, int qdias, int qhorarios, int qfilas){
    int i, j, k, l;

      for (i = 0; i < qdestinos; i++)
        for (j = 0; j < qdias; j ++)
            for (k = 0; k < qhorarios; k++)
                for (l = 0; l < qfilas; l++)
                    free(v[i][j][k][l]);

      for (i = 0; i < qdestinos; i++)
        for (j = 0; j < qdias; j ++)
            for (k = 0; k < qhorarios; k++)
                    free(v[i][j][k]);

      for (i = 0; i < qdestinos; i++)
        for (j = 0; j < qdias; j ++)
                free(v[i][j]);

      for (i = 0; i < qdestinos; i++)
            free(v[i]);

      free(v);
}

/* Leitura do menu inicial */
int LeOpcaoMenu(void) {
    int op;

    system("cls");
    printf("\n\nBem vindo ao sistema de venda de passagens aereas\n\n\n");
    printf("\n\nOpcoes Disponiveis\n\n");
    printf("1 - Fazer Reserva\n");
    printf("2 - Cancelar Reserva\n");
    printf("3 - Sair\n");
    printf("\n\nOpcao desejada: ");

    scanf("%d", &op);
    return(op);
}
/* Leitura dos destinos */
int LeDestino(int qdestino, char destinos[2][20]) {
    int op, i;

    do { 
        system("cls");
        printf("\n\nDestinos Disponiveis\n\n");
        for (i = 0; i < qdestino; i ++ ) {
            printf("%d - %s\n", i+1, destinos[i]);
         }
        printf("%d - Volta ao Menu Inicial\n", i+1);
        printf("\n\nOpcao desejada: ");

        scanf("%d", &op);
        if (op <1 || op > qdestino +1) {
            printf("\nOpcao invalida !! \n");
            system("pause");
        }
    }while (op <1 || op > qdestino+1);
    return(op);
}
/* Leitura dos dias */
int LeDia(int destino, char destinos[2][20], int qdias, char dias_semana[2][8]) {
    int op, i;

    do { 
        system("cls");
        printf("\n\nDias Disponiveis para o destino %s\n\n", destinos[destino-1]);
        for (i = 0; i < qdias; i ++ ) {
            printf("%d - %s\n", i+1, dias_semana[i]);
         }
        printf("%d - Volta ao Menu Inicial\n", i+1);
        printf("\n\nOpcao desejada: ");

        scanf("%d", &op);
        if (op <1 || op > qdias +1) {
            printf("\nOpcao invalida !! \n");
            system("pause");
        }
    }while (op <1 || op > qdias+1);
    return(op);
}

/* Leitura dos horários */
int LeHorario(int destino, char destinos[2][20], int dia, char dias_semana[2][8], int qhorario, char horarios[2][8]) {
    int op, i;

    do { 
        system("cls");
        printf("\nHorarios Disponiveis para o destino %s na %s:\n\n", destinos[destino-1], dias_semana[dia-1]);
        for (i = 0; i < qhorario; i ++ ) {
            printf("%d - %s\n", i+1, horarios[i]);
         }
        printf("%d - Volta ao Menu Inicial\n", i+1);

        printf("\n\nOpcao desejada: ");

        scanf("%d", &op);
        if (op <1 || op > qhorario+1) {
            printf("\nOpcao Invalida !! \n");
            system("pause");
        }
    }while (op <1 || op > qhorario+1);
    return(op);
}

/* Leitura das filas */
int LeFila(int destino, char destinos[2][20], int dia, char dias_semana[2][8], int horario, char horarios[2][8], int qfila, char filas[20][8], int qpoltrona, char poltronas[8][20]) {
    int op, i, j;

    do { 
        system("cls");
        printf("\nEscolha uma dentre as seguintes filas e poltronas:\n\n");
        printf("          Painel de Ocupacoes\n");
        for (i = 0; i < qfila; i ++ ) {
            printf("\n");
            for (j = 0; j < qpoltrona; j ++ ) 
            if(filas[20][8] == 1 && poltronas[8][20] == 1){
                printf("OCUP", filas[i], poltronas[j]);
            }
            else
            printf("%s%s ", filas[i], poltronas[j]);
         }
        printf("\n\n%d - Volta ao Menu Inicial\n", i+1);

        printf("\n\nOpcao da fila desejada: ");

        scanf("%d", &op);
        if (op <1 || op > qfila+1) {
            printf("\nOpcao Invalida !! \n");
            system("pause");
        }
    }while (op <1 || op > qfila+1);
    return(op);
}

/* Leitura das poltronas */
int LePoltrona(int destino, char destinos[2][20], int dia, char dias_semana[2][8], int horario, char horarios[2][8],
 int fila, char filas[20][8], int qpoltrona, char poltronas[8][20]) {
    int op, i;

    do { 
        printf("\nEscolha uma dentre as seguintes poltronas disponiveis:\n\n");
        for (i = 0; i < qpoltrona; i ++ ) {
         }
        printf("%d - Volta ao Menu Inicial\n", i+1);

        printf("\n\nOpcao da poltrona desejada: ");

        scanf("%d", &op);
        if (op <1 || op > qpoltrona+1) {
            printf("\nOpcao Invalida !! \n");
            system("pause");
        }
    }while (op <1 || op > qpoltrona+1);
    return(op);
}

/* Impressão das opcões escolhidas pelo usuário */
void ReservaVagas(int qdestino, int qdias, int qhorarios, int qfila, int qpoltrona, char destinos[2][20], char dias_semana[2][8], char horarios[2][8],
 char filas[20][8], char poltronas[8][20]) {
    int p, d, h, f, a;
    p = LeDestino(qdestino, destinos);
    if (p <= qdestino) {
        d = LeDia(p, destinos, qdias, dias_semana);
        if (d <= qdias) {
            h = LeHorario(p, destinos, d, dias_semana, qhorarios, horarios);
            if (h <= qhorarios){
                f = LeFila(p, destinos, d, dias_semana, h, horarios, qfila, filas, qpoltrona, poltronas);
                if (f <= qfila){
                    a = LePoltrona(p, destinos, d, dias_semana, h, horarios, f, filas, qpoltrona, poltronas);
                    if (a <= qpoltrona){
                        
                    printf("\n\nVaga reservada com sucesso!\nVoce fez reserva para viagem com destino a %s, %s, as %s, voce escolheu a poltrona %s na fila %s\n\n", destinos[p-1],dias_semana[d-1], horarios[h-1], poltronas[a-1], filas[f-1]);
                    printf("Obrigado e tenha uma boa viagem!\n\n");
                    system("pause");
                    }
                
                }
                
            }
        }
    }

}

/* Impressão do cancelamento feito pelo usuário */
void CancelaReserva(int qdestino, int qdias, int qhorarios, int qfila, int qpoltrona, char destinos[2][20], char dias_semana[2][8], char horarios[2][8],
 char filas[20][8], char poltronas[8][20]) {
    
        int p, d, h, f, a;
    p = LeDestino(qdestino, destinos);
    if (p <= qdestino) {
        d = LeDia(p, destinos, qdias, dias_semana);
        if (d <= qdias) {
            h = LeHorario(p, destinos, d, dias_semana, qhorarios, horarios);
            if (h <= qhorarios){
                f = LeFila(p, destinos, d, dias_semana, h, horarios, qfila, filas, qpoltrona, poltronas);
                if (f <= qfila){
                    a = LePoltrona(p, destinos, d, dias_semana, h, horarios, f, filas, qpoltrona, poltronas);
                    if (a <= qpoltrona){
                        
                    printf("\n\nCancelamento feito com sucesso!\nVoce cancelou sua viagem que seria para %s, %s, as %s, a sua poltrona %s, na fila %s esta livre agora.\n\n", destinos[p-1],dias_semana[d-1], horarios[h-1], poltronas[a-1], filas[f-1]);
                    printf("Obrigado e volte sempre!\n\n");
                    system("pause");
                    }
                
                }
                
            }
        }
    }
}
    


int main() {
      int *****mat;
      int i, qdestinos, qdias, qhorarios, qfilas, qpoltronas, op;
      char destinos[2][20]={"Fortaleza CE", "Salvador BA"};
    char dias_semana[2][8]={"Quarta", "Domingo"};
    char horarios[2][8]={"09:00 h", "17:00 h"};
    char filas[20][8]={"01", "02", "03", "04", "05", "06"};
    char poltronas[8][20]={"01", "02", "03", "04", "05", "06", "07", "08"};
      

    
      do {
          mat = LeVetorArquivo(&qdestinos, &qdias, &qhorarios, &qfilas, &qpoltronas);
        printf("\n\nArquivo Carregado.\n\n");
        EscreveVetorArquivo(mat, qdestinos, qdias, qhorarios, qfilas, qpoltronas); 
        op = LeOpcaoMenu();
        switch (op) {
            case 1:
                system("cls");
                ReservaVagas(2, 2, 2, 6, 8, destinos,  dias_semana, horarios, filas, poltronas);    
                break;
               case 2:
                system("cls");
                CancelaReserva(2, 2, 2, 6, 8, destinos, dias_semana, horarios, filas, poltronas);
                break;
               case 3:
                system("cls");
                printf("\n\nPROGRAMA FINALIZADO !!!\n\n");
                system("pause");
                break;
            default:
                 printf("\nOpcao invalida.\n");
                system("pause");
           }
    } while (op != 3);
    
    
    LiberaMemoria(mat, qdestinos, qdias, qhorarios, qfilas);
}

 

Não, tenho certeza se ele não está lendo o arquivo "reserva.txt", ou se não está gravando na memoria as opções do usuário.

 

arquivo reserva, com as matrizes:

2 2 2 6 8

1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 


1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
1 0 0 1 0 0 0 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 


1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
1 0 0 1 0 0 0 1 


1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 1 0 0 0 0 0 1 
0 0 0 0 0 0 0 0 
1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 


1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 


1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 


1 1 1 1 1 1 1 1 
1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 


1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
1 1 1 1 1 1 1 1 

 

Obs:
1 - OCULPADA

0 - LIVRE

Link para o post
Compartilhar em outros sites

Olá!

Você entendeu o que eu escrevi no tópico #4 (14/04) e no tópico #9 (21/04)?

 

Parece não ter evoluído muito e você continua no mesmo caminho super complexo :( 

 

 

Link para o post
Compartilhar em outros sites

Eu postei um exemplo de um caminho em 20/04 para escrever em torno dos dados e tentei explicar porque seria muito mais fácil. Acho que não tive sucesso em convencer porque seguiu pelo mesmo caminho de antes. ;) 

 

Também expliquei que por exemplo
 

	int******	int;

 

É apenas um ponteiro para int e não algo "multidimensional" e que isso nem existe em C, onde temos apenas vetores, e vetores de vetores e tal. Mais ainda, avisei que seguir escrevendo assim vai dar um trabalho do inferno e vai levar a um trem difícil de testar e quase impossível de manter. Também não tive sucesso.

 

Em 20/21 de abril, pelas datas dos arquivos, até escrevi um protótipo de como fazer algo mais assim data centric, focado NOS DADOS e dentro do contexto de seu enunciado.

 

Vou mostrar uns detalhes porque acho que pode ajudar outros (e você) a ver a diferença entre escrever a partir do modelo e escrever código e código e tentar enxergar depois os dados lá dentro.

 

O sistema

 

Seu sistema vende passagens para voos. Esse é o objetivo. Passagens e Voos. São até 8 destinos, com 4 horários nos 7 dias seguintes, e os aviões podem ter até 20 filas de 8 poltronas.

 

Isso quer dizer vender até 35840 passagens na semana. Nada mais. A passagem corresponde a uma poltrona num voo. Um voo corresponde a passagens vendidas. Se imaginar um voo simples, tipo um jatinho fretado nesse modelo, para ida e volta num certo dia, com 4 filas de 2 poltronas, vai poder vender 8 passagens de ida e 8 passagens de volta. A realidade. Em C ou COBOL ou javascript ou um bloco de papel.

 

Um arquivo em disco inicia o sistema, contendo o óbvio status em termos de passagens já vendidas.

 

Um modelo

 

typedef struct
{
    unsigned    destinos;
    unsigned    dias;
    unsigned    horarios;
    unsigned    filas;
    unsigned    poltronas;
    unsigned    total;

    const char* arquivo;

}   Config;

 

Nem tem o que comentar: Config mostra a configuração de um sistema desses. Ajuda a manter as coisas organizadas.

 

Direto do enunciado, um voo

 


typedef struct
{
    int             id; // pode ser util identificar o voo por numero
    char*           voo; // um nome pode ser FL-destino-Hora-AnoMesDia
    unsigned char   filas; // maximo 20 filas
    unsigned        n_tickets; // para ajudar a navegar
    unsigned char   poltronas; // maximo 8 poltronas/fila
    Ticket*         mapa[20][8]; // mapa 20x8 com as poltronas

}   Voo;

 

Um voo tem um nome, esse char* voo, e claro corresponde a um avião com um certo número de filas e poltronas. Claro que o avião vai para algum lugar, em algum dia, em algum horário. Mas isso não importa para o voo em si. Não é preciso resolver todos os problemas de uma vez. E isso nem é um problema

 

Claro, Ticket é "multidimensional" claramente. um ponteiro pra um mapa de tickets. Claro de não precisaria dos 160 e ele podia ser Ticket**. Mas só seria mais trabalho. São muito poucas passagens, como eu expliquei antes, 35K ou algo assim. Se seu micro tiver 16GB de RAM faça as contas de quanto cabe... 

 

Contabilidade

 

Para manter o sistema num modo equilibrado e testável sem perder a cabeça com vários níveis de ponteiros,

é bem conveniente criar a noção de passagem, de ticket, porque assim se confere o sistema em tempo real. Todos os voos tem poltronas vendidas e a soma delas correspondente à quantidade de tickets...

 

A noção de ticket
 


typedef struct
{
    int     id; // passagem
    int     id_voo; // comparar int eh mais fácil
    char    fila[2];
    char    poltrona[2];
    char*   voo;

}   Ticket; // pra poder fechar a conta dos voos e conferir tudo 

 

Pois é: pra fechar o sistema o ticket aponta para uma poltrona no voo. E o voo tem o numero do ticket no mapa. Todos os sistemas fazem isso. Ao abrir o caixa do mercado o cara conta o dinheiro. Ao fechar soma os tickets e a grana, you got the idea...

 

A noção do mapa de vendas
 

typedef struct
{
    char* arquivo; // origem no disco
    unsigned char   destinos; // ate 8 destinos
    unsigned char   dias; // ate 7 dias adiante
    char            hoje[6]; // para controlar o prazo AAMMDD
    unsigned char   horarios; // ate 4 horarios/dia
    int             id; // pode ser util depois
    unsigned        n_voos; // para ajudar a navegar
    Voo* voos[8][7][4];

}   Mapa;

 

Claramente multidimensional, os voos estão em um vetor de vetores de vetores. E aí estão as variáveis do sistema, dias, destinos e horários. E cada voo remete a um ponteiro para.... o voo. E lá dentro estão os tickets para as poltronas.

 

Preparando o  programa 

 

A partir disso dá pra pensar em C. O simples é criar uma convenção para associar os tickets e os voos e não precisa ser original: basta pensar em um bilhete de avião, afinal é isso que estamos simulando numa escala super simples.

 

Vamos usar o prefixo FL para um voo e o prefixo TK para ticket. Claro que não faz diferença o número de voos ou dias ou nada.  É um computador afinal. Mas não vamos querer testar com um arquivo de 20.000 linhas, certo?

 

Considere um voo fretado, um turbo-hélice com 4 filas de 2 poltronas, só de ida. O programa é seu. Pode escrever como quiser.

 

O arquivo podia ser esse:
 

1 1 1 4 2
FL111A1 AD8S
FL111A2 AD8P
FL111B1 AD8T
FL111B2 AD8R
FL111C1 AD8N
FL111C2 AD8O
FL111D1 AD8Q
FL111D2 AD8M


Um destino, um dia, um horario, 4 filas de 2 poltronas, e lotado: seguem os tickets. As poltronas aqui estão marcadas A1 A2 B1 B2 C1 C2 D1 D2 porque é bem mais fácil de raciocinar assim. Claro que depois pode colocar 0101 e OCUP e tal. Isso não importa. No entanto AGORA é melhor que seja fácil de entender, porque a gente quer concluir o programa no mesmo dia e não no mesmo ano ou no próximo.

 

E que p0rr@ é essa que vem depois? O código do ticket, claro, Porque assim qualquer um que saiba contar até dois pode "bater" o sistema. Eu tenho 8 lugares. Oito tickets? Oh... o voo está lotado. Quer testar com 90% de ocupação nos voos? apenas faça as contas: 9x8 = 72, vamos supor então 7 poltronas vendidas e apagamos um dos bilhetes... Uma ocupação aleatória? use rand() no total de tickets possíveis para cada caso... Para isso servem os computadores afinal.

 

E onde arrumar esse código de ticket? Não faz diferença. No arquivo de entrada pra disparar o sistema tem uma linha para cada ticket, e isso deixa tudo mais simples porque GARANTE que está tudo equilibrado. Algo assim serviria:

 

TKAD8M 111D2
TKAD8N 111C1
TKAD8O 111C2
TKAD8P 111A2
TKAD8Q 111D1
TKAD8R 111B2
TKAD8S 111A1
TKAD8T 111B1

 

É até bonitinho mas é coisa de criança: TK identifica um ticket. O ADS8S tem lá 
 

    TKAD8S 111A1

 

E que seria isso? primeiro destino, primeiro dia, primeiro horário, poltrona A1. E o que tem para o voo nessa poltrona?
 

	FL111A1 AD8S

 

Claro: a poltrona tem um dono, o dono tem uma poltrona.

 

Na prática

 

É preciso criar um arquivo de teste com o estado inicial do sistema. Pode estar tudo vazio? Claro

 

Só que seria uma m3rd@ porque para testar teria que ficar em frente a tela dois dias digitando voos e tal. Usando essas coisas e criando um arquivo inicial se pode até testar com o sistema lotado ou meio lotado apenas mudando o arquivo de entrada, e começar a testar no mesmo dia, que é o que importa.

 

Um arquivo para o voo do fictício CESSNA Caravan com 8 poltronas
 

1 1 1 4 2
FL111A1 AD8S
FL111A2 AD8P
FL111B1 AD8T
FL111B2 AD8R
FL111C1 AD8N
FL111C2 AD8O
FL111D1 AD8Q
FL111D2 AD8M
TKAD8M 111D2
TKAD8N 111C1
TKAD8O 111C2
TKAD8P 111A2
TKAD8Q 111D1
TKAD8R 111B2
TKAD8S 111A1
TKAD8T 111B1

 

Lotado. Quer vagas? Fácil: apague uns tickets.

 

E usando o mesmo paradigma pode criar "instruções" para o sistema, como DEnDestino por exemplo. Que seria isso?
 

DE1Atlanta
DE2Miami
DE3Nashville
DE4Orlando

 

Acrescentando novos códigos pode cadastrar destinos, como nesse exemplo, direto na entrada. Pode informar a data do primeiro dia para gerar telas mais bonitinhas, e por aí vai.... Nesse caso o destino 3 seria Nashville por exemplo.

 

Escrevendo assim você tem muito mais segurança e com alguma probabilidade de dar certo na primeira vez... proque foi construído em torno dos dados.

 

Fazendo o computador trabalhar por você, criando um arquivo de entrada com um universo de dados consistidos, mesmo que sejam 70.000 linhas, afinal não é você que escreve.

 

Pense nisso. Levei mais tempo para escrever isso aqui do que para escrever um modelo que gera os arquivos com tickets e voos para qualquer tamanho de mapa...

 

Um arquivo para 2 destinos 2 dias 2 horarios 4 filas de 2 poltronas teria 64 poltronas no maximo. Eis um aqui que já pode usar:
 

Spoiler


2 2 2 4 2
FL111A1 AD8Z
FL111A2 AD9R
FL111B1 AD9U
FL111B2 AE0T
FL111C1 AE0V
FL111C2 AD9X
FL111D1 AD9Q
FL111D2 AE0D
FL112A1 AD9V
FL112A2 AD9D
FL112B1 AE0K
FL112B2 AD9K
FL112C1 AD8X
FL112C2 AD8S
FL112D1 AD8M
FL112D2 AE0I
FL121A1 AD9I
FL121A2 AD9S
FL121B1 AE0X
FL121B2 AD8O
FL121C1 AD9L
FL121C2 AD9O
FL121D1 AE0P
FL121D2 AE0S
FL122A1 AE0H
FL122A2 AD9F
FL122B1 AE0M
FL122B2 AE0F
FL122C1 AE0W
FL122C2 AD8Y
FL122D1 AE0Q
FL122D2 AD8W
FL211A1 AE0R
FL211A2 AD9C
FL211B1 AD8R
FL211B2 AD8V
FL211C1 AE0U
FL211C2 AE0G
FL211D1 AD9Z
FL211D2 AD9B
FL212A1 AD8U
FL212A2 AD9A
FL212B1 AD9E
FL212B2 AE0B
FL212C1 AD9T
FL212C2 AD9G
FL212D1 AD8Q
FL212D2 AD9W
FL221A1 AE0N
FL221A2 AD9P
FL221B1 AD9H
FL221B2 AD9N
FL221C1 AD8P
FL221C2 AE0J
FL221D1 AE0C
FL221D2 AD9M
FL222A1 AD8N
FL222A2 AD8T
FL222B1 AE0L
FL222B2 AD9J
FL222C1 AE0A
FL222C2 AE0O
FL222D1 AE0E
FL222D2 AD9Y
TKAD8M 112D1
TKAD8N 222A1
TKAD8O 121B2
TKAD8P 221C1
TKAD8Q 212D1
TKAD8R 211B1
TKAD8S 112C2
TKAD8T 222A2
TKAD8U 212A1
TKAD8V 211B2
TKAD8W 122D2
TKAD8X 112C1
TKAD8Y 122C2
TKAD8Z 111A1
TKAD9A 212A2
TKAD9B 211D2
TKAD9C 211A2
TKAD9D 112A2
TKAD9E 212B1
TKAD9F 122A2
TKAD9G 212C2
TKAD9H 221B1
TKAD9I 121A1
TKAD9J 222B2
TKAD9K 112B2
TKAD9L 121C1
TKAD9M 221D2
TKAD9N 221B2
TKAD9O 121C2
TKAD9P 221A2
TKAD9Q 111D1
TKAD9R 111A2
TKAD9S 121A2
TKAD9T 212C1
TKAD9U 111B1
TKAD9V 112A1
TKAD9W 212D2
TKAD9X 111C2
TKAD9Y 222D2
TKAD9Z 211D1
TKAE0A 222C1
TKAE0B 212B2
TKAE0C 221D1
TKAE0D 111D2
TKAE0E 222D1
TKAE0F 122B2
TKAE0G 211C2
TKAE0H 122A1
TKAE0I 112D2
TKAE0J 221C2
TKAE0K 112B1
TKAE0L 222B1
TKAE0M 122B1
TKAE0N 221A1
TKAE0O 222C2
TKAE0P 121D1
TKAE0Q 122D1
TKAE0R 211A1
TKAE0S 121D2
TKAE0T 111B2
TKAE0U 211C1
TKAE0V 111C1
TKAE0W 122C1
TKAE0X 121B1

 

 

 

Não usar string.h

 

Isso não deve ser sequer considerado incialmente: escreva do modo como achar melhor. DEPOIS de pronto retire o #include para string.h e vai ver fácil as que usou: o compilador vai rejeitar furiosamente todas as chamadas. Aí veja quais são e troque por outras. Nada mais. Muitas podem ser trocadas por sprintf() (não diga pro seu professor :D )

 

 

 

Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisa ser um usuário para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...

Aprenda a ler resistores e capacitores

EBOOK GRÁTIS!

CLIQUE AQUI E BAIXE AGORA MESMO!