C++ Vetor multidimensional: programa em C++

Valdeir Medeiros · 14 de abril de 2021

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.

devair1010 · 14 de abril de 2021

@Valdeir Medeiros creio que não vais precisar de string não , então poste o código que você já tenha feito sobre esse exercício e ajudaremos caso precise de alguma correção .

Valdeir Medeiros · 14 de abril de 2021

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).

arfneto · 14 de abril de 2021

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

Valdeir Medeiros · 16 de abril de 2021

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?

arfneto · 16 de abril de 2021

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.

Valdeir Medeiros · 20 de abril de 2021

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");
}

arfneto · 20 de abril de 2021

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.

arfneto · 21 de abril de 2021

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.

Valdeir Medeiros · 29 de abril de 2021

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: