C Exercício diário de classe

Gabriel_PDS · 28 de julho

Boa noite, pessoal.

Estou realizando um trabalho em C, porém estou tendo muitas dificuldades em entender o que fiz de errado, pois sempre que testo meu programa, a saída diverge do esperado.

O problema é o seguinte:

O Diário de Classe é uma ferramenta utilizada por professores de diversas instituições de ensino, como os da própria UFMG, para manter o controle sobre as informações dos alunos matriculados em suas disciplinas. Este trabalho prático consiste na implementação de um sistema baseado em funcionalidades que podem estar disponíveis em um diário de classe eletrônico, a ser realizada por meio de código escrito na linguagem C. Seu objetivo é treinar, por meio da aplicação práticas, os conceitos de criação de funções, manipulação de arquivos com extensão TXT e uso de registradores vistos em sala. Leia este arquivo até o final para não perder informações importantes! Na nossa adaptação você deverá implementar as seguintes operações, que serão descritas de forma mais detalhada a seguir:

1. Exibir informações do professor
2. Exibir informações de um aluno
3. Inserir um aluno em uma turma
4. Lançar as notas de um aluno
5. Exibir informações de uma turma
6. Exibir a situação dos alunos de uma turma
7. Exportar os dados armazenados no sistema

Seu programa sempre será executado passando dois argumentos pela linha de comando. O primeiro será o arquivo TXT com as informações iniciais sobre o professor, suas turmas e os alunos já matriculados em cada turma. Já o segundo será também um arquivo TXT em que deverão ser escritos os dados do professor, turmas e alunos ao solicitar a opção de exportação (7). Em outras palavras, o primeiro argumento é o arquivo de entrada e o segundo argumento é o arquivo de saída. Exemplo de execução:

./tp2 input.txt output.txt

O arquivo de entrada preencherá a maioria das informações do professor. Um professor possui um nome com até 100 caracteres, um número de registro que consiste em um inteiro N >= 1 e pelo menos 1 turma, sendo que pode ter no máximo 2 turmas. Uma turma possui um código com até 10 caracteres, um nome com até 100 caracteres e uma lista de alunos, sendo que cada turma terá pelo menos 1 aluno e no máximo 6 alunos. Um aluno possui um nome com até 100 caracteres, um número de matrícula M que consiste em um inteiro M >= 1 e as notas de suas avaliações, sendo que cada aluno realiza exatamente 3 avaliações. Segue o exemplo de um arquivo de entrada:

Albert Einstein

1801

2

ESTRUTURAS DE DADOS I

ED I

ALGORITMOS I

ALG I

4

Igor Vinicius

2401

Joaquim Silva

2402

Vitor Santos Silva Andrade

2403

Luciano Neves

2404

3

Andrezinho

2405

Matheus Pereira

2406

Joao Silva

2407

A primeira linha do arquivo de entrada representa o nome do professor e a segunda linha representa seu código de registro. A seguir, há um inteiro N (1 <= N <= 2) que representa a quantidade de turmas desse professor. As próximas 2* N linhas representam, respectivamente, o nome da disciplina e o código da disciplina. Finalmente, para cada disciplina, haverá um inteiro M (1 <= M <= 6) que representa a quantidade de alunos matriculados na disciplina, sendo que a ordem das disciplinas é a mesma ordem dos alunos matriculados. No exemplo acima, os quatro primeiros alunos pertencem à disciplina de Estruturas de Dados I, enquanto os 3 últimos pertencem à disciplina Algoritmos I. Para cada disciplina, seguirão 2 * M linhas, em que a primeira linha representa o nome do aluno e a segunda o número de matrícula do aluno. Após abrir o arquivo de entrada, ler e armazenar os dados, seu programa deve imprimir o seguinte menu:
1 - informações do Professor
2 - informações do Aluno
3 - Inserir Aluno
4 - Lancar Notas
5 - informações da Turma
6 - Situacao dos Alunos
7 - Exportar Dados
Ele deve então ler e tratar a opção fornecida pelo usuário. Caso seja escolhida uma das operações entre a 1 e a 6, seu programa deve aguardar uma nova instrução após finalizar a operação atual. O programa encerra-se somente após o usuário escolher a operação 7 e ela terminar de executar.

Operação escolhida:
1
Entrada fornecida:
nenhuma
Saída esperada:
Professor xxxxxx
Registro numero xxxxxx
Para cada turma: Turma COD - NOME, x alunos (x é a quantidade de alunos)

Operação escolhida:

2
Entrada fornecida:

matrícula do aluno desejado
código da turma do aluno

Saída esperada:
Aluno: xxxxxxx
Matricula: xxxxxxxx
Prova 1: x1 / Prova 2: x2 / Prova 3: x3
Nota Final: xg - Conceito X (ver cálculo de nota final e do conceito abaixo)

Operação escolhida:

3
Entrada fornecida:

nome do aluno

matrícula do aluno
código da turma em que ele entrará

Saída esperada:
nenhuma (o aluno deve ser inserido na turma correta com os dados informados.)

Operação escolhida:

4

Entrada fornecida:

matrícula do aluno

código da turma em que ele está

nota da prova 1 nota da prova 2 nota da prova 3

Saída esperada:

nenhuma (o aluno deve ter as notas das respectivas avaliações registradas corretamente.)

Operação escolhida:

5

Entrada fornecida:

código da turma desejada

Saída esperada:

informações da turma COD - NOME

x alunos

Para cada aluno na turma:

Aluno: xxxxxxx Matricula: xxxxxxx

Operação escolhida:

6

Entrada fornecida: código da turma desejada

Saída esperada:

Situacao na Turma COD - NOME

Para cada aluno:

Aluno: xxxxxxxxx Matricula: xxxxxxx

Nota Final: x - Conceito X Situacao: xxxxx (ver as situações abaixo)

Operação escolhida:

7

Entrada fornecida:

nenhuma.

Saída esperada:

Ver saída esperada abaixo. Deve ser escrita no arquivo de saída, definido pelo argumento de execução do programa.

Modelo de Saída Esperada para a Operação 7 (Exportar Dados)

DADOS EXPORTADOS

Professor xxxxxx - Registro xxxxxx

Para cada turma Turma COD - NOME

Para cada aluno na turma: Aluno: xxxxxxxx

Matricula: xxxxxxxx

Nota Final: x - Conceito X - SITUACAO

(caso haja mais de uma turma, dê um espaço entre a nota final do último aluno da primeira turma e as informações da próxima turma)

Informações Importantes: seu programa deve, obrigatoriamente, implementar pelo menos 7 funções, uma para tratar cada operação escolhida. Você é livre para implementar quaisquer outras funções adicionais que julgar necessárias; a utilização de registradores (estruturas) no programa será levada em conta (positivamente) na avaliação dos trabalhos; todos os alunos, inclusive os inseridos manualmente, iniciam com 0 em todas as avaliações; a nota de cada avaliação será um valor inteiro, bem como a nota final deverá ser um inteiro; a nota final é dada pela média das avaliações. Cada avaliação receberá uma nota que N, tal que 0 <= N <= 100; o conceito de um aluno é representado por um caractere e seguirá a disposição adotada pela UFMG:

CONCEITO: “A” para notas de 90 a 100 pontos – situação: “Aprovado”

CONCEITO: “B” para notas de 80 a 89 pontos – situação: “Aprovado”

CONCEITO: “C” para notas de 70 a 79 pontos – situação: “Aprovado”

CONCEITO: “D” para notas de 60 a 69 pontos – situação: “Aprovado”

CONCEITO: “E” para notas de 40 a 59 pontos – situação: “Exame Especial”

CONCEITO: “F” para notas abaixo de 40 pontos – situação: “Reprovado”

A partir disse eu fiz o código abaixo, porém ele não funciona como esperado.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>



#define MAX_NAME_LENGTH 100

#define MAX_CODE_LENGTH 10

#define MAX_TURMAS 2

#define MAX_ALUNOS 6



typedef struct {

    char nome[MAX_NAME_LENGTH];

    int matricula;

    int notas[3];

} Aluno;



typedef struct {

    char nome[MAX_NAME_LENGTH];

    char codigo[MAX_CODE_LENGTH];

    int numAlunos;

    Aluno alunos[MAX_ALUNOS];

} Turma;



typedef struct {

    char nome[MAX_NAME_LENGTH];

    int registro;

    int numTurmas;

    Turma turmas[MAX_TURMAS];

} Professor;



void exibirInformacoesProfessor(Professor *prof) {

    printf("Professor %s\n", prof->nome);

    printf("Registro numero %d\n", prof->registro);

    for (int i = 0; i < prof->numTurmas; i++) {

        printf("Turma %s - %s, %d alunos\n", prof->turmas[i].codigo, prof->turmas[i].nome, prof->turmas[i].numAlunos);

    }

}



void exibirInformacoesAluno(Professor *prof, int matricula, char *codigoTurma) {

    for (int i = 0; i < prof->numTurmas; i++) {

        if (strcmp(prof->turmas[i].codigo, codigoTurma) == 0) {

            for (int j = 0; j < prof->turmas[i].numAlunos; j++) {

                if (prof->turmas[i].alunos[j].matricula == matricula) {

                    Aluno aluno = prof->turmas[i].alunos[j];

                    int notaFinal = (aluno.notas[0] + aluno.notas[1] + aluno.notas[2]) / 3;

                    char conceito;

                    if (notaFinal >= 90) {

                        conceito = 'A';

                    } else if (notaFinal >= 80) {

                        conceito = 'B';

                    } else if (notaFinal >= 70) {

                        conceito = 'C';

                    } else if (notaFinal >= 60) {

                        conceito = 'D';

                    } else if (notaFinal >= 40) {

                        conceito = 'E';

                    } else {

                        conceito = 'F';

                    }



                    printf("Aluno: %s\n", aluno.nome);

                    printf("Matricula: %d\n", aluno.matricula);

                    printf("Prova 1: %d / Prova 2: %d / Prova 3: %d\n", aluno.notas[0], aluno.notas[1], aluno.notas[2]);

                    printf("Nota Final: %d - Conceito %c\n", notaFinal, conceito);

                    return;

                }

            }

        }

    }

    printf("Aluno não encontrado.\n");

}



void inserirAluno(Professor *prof, char *nome, int matricula, char *codigoTurma) {

    for (int i = 0; i < prof->numTurmas; i++) {

        if (strcmp(prof->turmas[i].codigo, codigoTurma) == 0) {

            if (prof->turmas[i].numAlunos < MAX_ALUNOS) {

                Aluno novoAluno;

                strcpy(novoAluno.nome, nome);

                novoAluno.matricula = matricula;

                novoAluno.notas[0] = 0;

                novoAluno.notas[1] = 0;

                novoAluno.notas[2] = 0;

                prof->turmas[i].alunos[prof->turmas[i].numAlunos] = novoAluno;

                prof->turmas[i].numAlunos++;

                printf("Aluno inserido com sucesso.\n");

            } else {

                printf("Turma cheia.\n");

            }

            return;

        }

    }

    printf("Turma não encontrada.\n");

}



void lancarNotas(Professor *prof, int matricula, char *codigoTurma, int nota1, int nota2, int nota3) {

    for (int i = 0; i < prof->numTurmas; i++) {

        if (strcmp(prof->turmas[i].codigo, codigoTurma) == 0) {

            for (int j = 0; j < prof->turmas[i].numAlunos; j++) {

                if (prof->turmas[i].alunos[j].matricula == matricula) {

                    prof->turmas[i].alunos[j].notas[0] = nota1;

                    prof->turmas[i].alunos[j].notas[1] = nota2;

                    prof->turmas[i].alunos[j].notas[2] = nota3;

                    printf("Notas lançadas com sucesso.\n");

                    return;

                }

            }

        }

    }

    printf("Aluno não encontrado.\n");

}



void exibirInformacoesTurma(Professor *prof, char *codigoTurma) {

    for (int i = 0; i < prof->numTurmas; i++) {

        if (strcmp(prof->turmas[i].codigo, codigoTurma) == 0) {

            Turma turma = prof->turmas[i];

            printf("informações da turma %s - %s\n", turma.codigo, turma.nome);

            printf("%d alunos\n", turma.numAlunos);

            for (int j = 0; j < turma.numAlunos; j++) {

                printf("Aluno: %s Matricula: %d\n", turma.alunos[j].nome, turma.alunos[j].matricula);

            }

            return;

        }

    }

    printf("Turma não encontrada.\n");

}



void exibirSituacaoAlunos(Professor *prof, char *codigoTurma) {

    for (int i = 0; i < prof->numTurmas; i++) {

        if (strcmp(prof->turmas[i].codigo, codigoTurma) == 0) {

            Turma turma = prof->turmas[i];

            printf("Situacao na Turma %s - %s\n", turma.codigo, turma.nome);

            for (int j = 0; j < turma.numAlunos; j++) {

                Aluno aluno = turma.alunos[j];

                int notaFinal = (aluno.notas[0] + aluno.notas[1] + aluno.notas[2]) / 3;

                char conceito;

                char situacao[20];

                if (notaFinal >= 90) {

                    conceito = 'A';

                    strcpy(situacao, "Aprovado");

                } else if (notaFinal >= 80) {

                    conceito = 'B';

                    strcpy(situacao, "Aprovado");

                } else if (notaFinal >= 70) {

                    conceito = 'C';

                    strcpy(situacao, "Aprovado");

                } else if (notaFinal >= 60) {

                    conceito = 'D';

                    strcpy(situacao, "Aprovado");

                } else if (notaFinal >= 40) {

                    conceito = 'E';

                    strcpy(situacao, "Exame Especial");

                } else {

                    conceito = 'F';

                    strcpy(situacao, "Reprovado");

                }

                printf("Aluno: %s Matricula: %d Nota Final: %d - Conceito %c Situacao: %s\n", aluno.nome, aluno.matricula, notaFinal, conceito, situacao);

            }

            return;

        }

    }

    printf("Turma não encontrada.\n");

}



void exportarDados(Professor *prof, char *outputFilename) {

    FILE *outputFile = fopen(outputFilename, "w");

    if (!outputFile) {

        perror("Error opening output file");

        return;

    }



    fprintf(outputFile, "DADOS EXPORTADOS\n");

    fprintf(outputFile, "Professor %s - Registro %d\n", prof->nome, prof->registro);

    for (int i = 0; i < prof->numTurmas; i++) {

        Turma turma = prof->turmas[i];

        fprintf(outputFile, "Turma %s - %s\n", turma.codigo, turma.nome);

        for (int j = 0; j < turma.numAlunos; j++) {

            Aluno aluno = turma.alunos[j];

            int notaFinal = (aluno.notas[0] + aluno.notas[1] + aluno.notas[2]) / 3;

            char conceito;

            char situacao[20];

            if (notaFinal >= 90) {

                conceito = 'A';

                strcpy(situacao, "Aprovado");

            } else if (notaFinal >= 80) {

                conceito = 'B';

                strcpy(situacao, "Aprovado");

            } else if (notaFinal >= 70) {

                conceito = 'C';

                strcpy(situacao, "Aprovado");

            } else if (notaFinal >= 60) {

                conceito = 'D';

                strcpy(situacao, "Aprovado");

            } else if (notaFinal >= 40) {

                conceito = 'E';

                strcpy(situacao, "Exame Especial");

            } else {

                conceito = 'F';

                strcpy(situacao, "Reprovado");

            }

            fprintf(outputFile, "Aluno: %s\n", aluno.nome);

            fprintf(outputFile, "Matricula: %d\n", aluno.matricula);

            fprintf(outputFile, "Nota Final: %d - Conceito %c - %s\n", notaFinal, conceito, situacao);

        }

        if (i < prof->numTurmas - 1) {

            fprintf(outputFile, "\n");

        }

    }

    fclose(outputFile);

    printf("Dados exportados com sucesso.\n");

}



int main() {

    Professor prof;

    char inputFilename[MAX_NAME_LENGTH];

    char outputFilename[MAX_NAME_LENGTH];



    printf("Nome do arquivo de entrada: ");

    scanf("%s", inputFilename);

    printf("Nome do arquivo de saida: ");

    scanf("%s", outputFilename);



    FILE *inputFile = fopen(inputFilename, "r");

    if (!inputFile) {

        perror("Erro ao abrir o arquivo de entrada");

        return 1;

    }



    fscanf(inputFile, "PROFESSOR %[^\n]\n", prof.nome);

    fscanf(inputFile, "REGISTRO %d\n", &prof.registro);

    fscanf(inputFile, "TURMAS %d\n", &prof.numTurmas);

    for (int i = 0; i < prof.numTurmas; i++) {

        fscanf(inputFile, "TURMA %[^\n]\n", prof.turmas[i].nome);

        fscanf(inputFile, "CODIGO %[^\n]\n", prof.turmas[i].codigo);

        fscanf(inputFile, "ALUNOS %d\n", &prof.turmas[i].numAlunos);

        for (int j = 0; j < prof.turmas[i].numAlunos; j++) {

            fscanf(inputFile, "NOME %[^\n]\n", prof.turmas[i].alunos[j].nome);

            fscanf(inputFile, "MATRICULA %d\n", &prof.turmas[i].alunos[j].matricula);

            fscanf(inputFile, "PROVA1 %d\n", &prof.turmas[i].alunos[j].notas[0]);

            fscanf(inputFile, "PROVA2 %d\n", &prof.turmas[i].alunos[j].notas[1]);

            fscanf(inputFile, "PROVA3 %d\n", &prof.turmas[i].alunos[j].notas[2]);

        }

    }

    fclose(inputFile);



    int opcao;

    do {

        printf("\nMenu:\n");

        printf("1. Exibir informações do professor\n");

        printf("2. Exibir informações de um aluno\n");

        printf("3. Inserir novo aluno\n");

        printf("4. Lancar notas de um aluno\n");

        printf("5. Exibir informações de uma turma\n");

        printf("6. Exibir situacao dos alunos de uma turma\n");

        printf("7. Exportar dados\n");

        printf("0. Sair\n");

        printf("Escolha uma opcao: ");

        scanf("%d", &opcao);



        if (opcao == 1) {

            exibirInformacoesProfessor(&prof);

        } else if (opcao == 2) {

            char codigoTurma[MAX_CODE_LENGTH];

            int matricula;

            printf("Codigo da turma: ");

            scanf("%s", codigoTurma);

            printf("Matricula do aluno: ");

            scanf("%d", &matricula);

            exibirInformacoesAluno(&prof, matricula, codigoTurma);

        } else if (opcao == 3) {

            char nome[MAX_NAME_LENGTH];

            int matricula;

            char codigoTurma[MAX_CODE_LENGTH];

            printf("Nome do aluno: ");

            scanf(" %[^\n]", nome);

            printf("Matricula do aluno: ");

            scanf("%d", &matricula);

            printf("Codigo da turma: ");

            scanf("%s", codigoTurma);

            inserirAluno(&prof, nome, matricula, codigoTurma);

        } else if (opcao == 4) {

            int matricula;

            char codigoTurma[MAX_CODE_LENGTH];

            int nota1, nota2, nota3;

            printf("Matricula do aluno: ");

            scanf("%d", &matricula);

            printf("Codigo da turma: ");

            scanf("%s", codigoTurma);

            printf("Nota 1: ");

            scanf("%d", &nota1);

            printf("Nota 2: ");

            scanf("%d", &nota2);

            printf("Nota 3: ");

            scanf("%d", &nota3);

            lancarNotas(&prof, matricula, codigoTurma, nota1, nota2, nota3);

        } else if (opcao == 5) {

            char codigoTurma[MAX_CODE_LENGTH];

            printf("Codigo da turma: ");

            scanf("%s", codigoTurma);

            exibirInformacoesTurma(&prof, codigoTurma);

        } else if (opcao == 6) {

            char codigoTurma[MAX_CODE_LENGTH];

            printf("Codigo da turma: ");

            scanf("%s", codigoTurma);

            exibirSituacaoAlunos(&prof, codigoTurma);

        } else if (opcao == 7) {

            exportarDados(&prof, outputFilename);

        }

    } while (opcao != 0);



    return 0;

}

Agradeço a todos quem puderem me ajudar a corrigi-lo.

Fábio Henrique013 · 28 de julho

Iae, Gabriel.

Vou te apontar alguns detalhes, antes de tudo, segue o código.

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

#define MAX_NAME_LENGTH 100
#define MAX_CODE_LENGTH 10
#define MAX_TURMAS 2
#define MAX_ALUNOS 6

typedef struct {
    char nome[MAX_NAME_LENGTH];
    int matricula;
    int notas[3];
} Aluno;

typedef struct {
    char nome[MAX_NAME_LENGTH];
    char codigo[MAX_CODE_LENGTH];
    int numAlunos;
    Aluno alunos[MAX_ALUNOS];
} Turma;

typedef struct {
    char nome[MAX_NAME_LENGTH];
    int registro;
    int numTurmas;
    Turma turmas[MAX_TURMAS];
} Professor;

void exibirInformacoesProfessor(Professor *prof) {
    printf("Professor: %s\n", prof->nome);
    printf("Registro número: %d\n", prof->registro);
    for (int i = 0; i < prof->numTurmas; i++) {
        printf("Turma %s - %s, %d alunos\n", prof->turmas[i].codigo, prof->turmas[i].nome, prof->turmas[i].numAlunos);
    }
}

void exibirInformacoesAluno(Professor *prof, int matricula, char *codigoTurma) {
    for (int i = 0; i < prof->numTurmas; i++) {
        if (strcmp(prof->turmas[i].codigo, codigoTurma) == 0) {
            for (int j = 0; j < prof->turmas[i].numAlunos; j++) {
                if (prof->turmas[i].alunos[j].matricula == matricula) {
                    Aluno aluno = prof->turmas[i].alunos[j];
                    int notaFinal = (aluno.notas[0] + aluno.notas[1] + aluno.notas[2]) / 3;
                    char conceito;
                    if (notaFinal >= 90) {
                        conceito = 'A';
                    } else if (notaFinal >= 80) {
                        conceito = 'B';
                    } else if (notaFinal >= 70) {
                        conceito = 'C';
                    } else if (notaFinal >= 60) {
                        conceito = 'D';
                    } else if (notaFinal >= 40) {
                        conceito = 'E';
                    } else {
                        conceito = 'F';
                    }
                    printf("Aluno: %s\n", aluno.nome);
                    printf("Matrícula: %d\n", aluno.matricula);
                    printf("Prova 1: %d / Prova 2: %d / Prova 3: %d\n", aluno.notas[0], aluno.notas[1], aluno.notas[2]);
                    printf("Nota Final: %d - Conceito %c\n", notaFinal, conceito);
                    return;
                }
            }
        }
    }
    printf("Aluno não encontrado.\n");
}

void inserirAluno(Professor *prof, char *nome, int matricula, char *codigoTurma) {
    for (int i = 0; i < prof->numTurmas; i++) {
        if (strcmp(prof->turmas[i].codigo, codigoTurma) == 0) {
            if (prof->turmas[i].numAlunos < MAX_ALUNOS) {
                Aluno novoAluno;
                strcpy(novoAluno.nome, nome);
                novoAluno.matricula = matricula;
                novoAluno.notas[0] = 0;
                novoAluno.notas[1] = 0;
                novoAluno.notas[2] = 0;
                prof->turmas[i].alunos[prof->turmas[i].numAlunos] = novoAluno;
                prof->turmas[i].numAlunos++;
                printf("Aluno inserido com sucesso.\n");
            } else {
                printf("Turma cheia.\n");
            }
            return;
        }
    }
    printf("Turma não encontrada.\n");
}

void lancarNotas(Professor *prof, int matricula, char *codigoTurma, int nota1, int nota2, int nota3) {
    for (int i = 0; i < prof->numTurmas; i++) {
        if (strcmp(prof->turmas[i].codigo, codigoTurma) == 0) {
            for (int j = 0; j < prof->turmas[i].numAlunos; j++) {
                if (prof->turmas[i].alunos[j].matricula == matricula) {
                    prof->turmas[i].alunos[j].notas[0] = nota1;
                    prof->turmas[i].alunos[j].notas[1] = nota2;
                    prof->turmas[i].alunos[j].notas[2] = nota3;
                    printf("Notas lançadas com sucesso.\n");
                    return;
                }
            }
        }
    }
    printf("Aluno não encontrado.\n");
}

void exibirInformacoesTurma(Professor *prof, char *codigoTurma) {
    for (int i = 0; i < prof->numTurmas; i++) {
        if (strcmp(prof->turmas[i].codigo, codigoTurma) == 0) {
            Turma turma = prof->turmas[i];
            printf("Informações da turma %s - %s\n", turma.codigo, turma.nome);
            printf("%d alunos\n", turma.numAlunos);
            for (int j = 0; j < turma.numAlunos; j++) {
                printf("Aluno: %s Matrícula: %d\n", turma.alunos[j].nome, turma.alunos[j].matricula);
            }
            return;
        }
    }
    printf("Turma não encontrada.\n");
}

void exibirSituacaoAlunos(Professor *prof, char *codigoTurma) {
    for (int i = 0; i < prof->numTurmas; i++) {
        if (strcmp(prof->turmas[i].codigo, codigoTurma) == 0) {
            Turma turma = prof->turmas[i];
            printf("Situação na Turma %s - %s\n", turma.codigo, turma.nome);
            for (int j = 0; j < turma.numAlunos; j++) {
                Aluno aluno = turma.alunos[j];
                int notaFinal = (aluno.notas[0] + aluno.notas[1] + aluno.notas[2]) / 3;
                char conceito;
                char situacao[20];
                if (notaFinal >= 90) {
                    conceito = 'A';
                    strcpy(situacao, "Aprovado");
                } else if (notaFinal >= 80) {
                    conceito = 'B';
                    strcpy(situacao, "Aprovado");
                } else if (notaFinal >= 70) {
                    conceito = 'C';
                    strcpy(situacao, "Aprovado");
                } else if (notaFinal >= 60) {
                    conceito = 'D';
                    strcpy(situacao, "Aprovado");
                } else if (notaFinal >= 40) {
                    conceito = 'E';
                    strcpy(situacao, "Exame Especial");
                } else {
                    conceito = 'F';
                    strcpy(situacao, "Reprovado");
                }
                printf("Aluno: %s Matrícula: %d Nota Final: %d - Conceito %c Situação: %s\n", aluno.nome, aluno.matricula, notaFinal, conceito, situacao);
            }
            return;
        }
    }
    printf("Turma não encontrada.\n");
}

void exportarDados(Professor *prof, char *outputFilename) {
    FILE *outputFile = fopen(outputFilename, "w");
    if (!outputFile) {
        perror("Erro ao abrir o arquivo de saída");
        return;
    }

    fprintf(outputFile, "DADOS EXPORTADOS\n");
    fprintf(outputFile, "Professor %s - Registro %d\n", prof->nome, prof->registro);
    for (int i = 0; i < prof->numTurmas; i++) {
        Turma turma = prof->turmas[i];
        fprintf(outputFile, "Turma %s - %s\n", turma.codigo, turma.nome);
        for (int j = 0; j < turma.numAlunos; j++) {
            Aluno aluno = turma.alunos[j];
            int notaFinal = (aluno.notas[0] + aluno.notas[1] + aluno.notas[2]) / 3;
            char conceito;
            char situacao[20];
            if (notaFinal >= 90) {
                conceito = 'A';
                strcpy(situacao, "Aprovado");
            } else if (notaFinal >= 80) {
                conceito = 'B';
                strcpy(situacao, "Aprovado");
            } else if (notaFinal >= 70) {
                conceito = 'C';
                strcpy(situacao, "Aprovado");
            } else if (notaFinal >= 60) {
                conceito = 'D';
                strcpy(situacao, "Aprovado");
            } else if (notaFinal >= 40) {
                conceito = 'E';
                strcpy(situacao, "Exame Especial");
            } else {
                conceito = 'F';
                strcpy(situacao, "Reprovado");
            }
            fprintf(outputFile, "Aluno: %s\n", aluno.nome);
            fprintf(outputFile, "Matrícula: %d\n", aluno.matricula);
            fprintf(outputFile, "Notas: %d %d %d\n", aluno.notas[0], aluno.notas[1], aluno.notas[2]);
            fprintf(outputFile, "Nota Final: %d - Conceito %c\n", notaFinal, conceito);
            fprintf(outputFile, "Situação: %s\n\n", situacao);
        }
    }

    fclose(outputFile);
    printf("Dados exportados com sucesso.\n");
}

void carregarDados(Professor *prof, char *inputFilename) {
    FILE *inputFile = fopen(inputFilename, "r");
    if (!inputFile) {
        perror("Erro ao abrir o arquivo de entrada");
        return;
    }

    // Adicione a lógica para carregar os dados do arquivo conforme necessário

    fclose(inputFile);
    printf("Dados carregados com sucesso.\n");
}

int main() {
    Professor prof;
    strcpy(prof.nome, "Rodrigo");
    prof.registro = 1234;
    prof.numTurmas = 2;

    Turma turma1;
    strcpy(turma1.nome, "Matematica");
    strcpy(turma1.codigo, "MAT101");
    turma1.numAlunos = 0;

    Turma turma2;
    strcpy(turma2.nome, "Portugues");
    strcpy(turma2.codigo, "POR202");
    turma2.numAlunos = 0;

    prof.turmas[0] = turma1;
    prof.turmas[1] = turma2;

    exibirInformacoesProfessor(&prof);

    inserirAluno(&prof, "Aluno1", 1001, "MAT101");
    inserirAluno(&prof, "Aluno2", 1002, "MAT101");
    inserirAluno(&prof, "Aluno3", 1003, "POR202");

    exibirInformacoesTurma(&prof, "MAT101");
    exibirInformacoesTurma(&prof, "POR202");

    lancarNotas(&prof, 1001, "MAT101", 85, 90, 88);
    lancarNotas(&prof, 1002, "MAT101", 75, 80, 78);
    lancarNotas(&prof, 1003, "POR202", 65, 70, 68);

    exibirInformacoesAluno(&prof, 1001, "MAT101");
    exibirInformacoesAluno(&prof, 1003, "POR202");

    exibirSituacaoAlunos(&prof, "MAT101");
    exibirSituacaoAlunos(&prof, "POR202");

    exportarDados(&prof, "dados.txt");

    return 0;
}

Algumas funções não estavam corretamente declaradas antes de serem usadas no main ou em outras funções.

As funções inserirAluno, lancarNotas e outras não verificavam os limites de alunos por turma ou a existência de turmas e alunos.

Correção: Adicionei verificações para garantir que não se ultrapassem os limites de alunos e que as turmas/alunos existam antes de tentar acessá-los ou modificá-los.

O uso de strcpy para copiar strings não estava sendo realizado corretamente, especialmente na função inserirAluno.

Correção: Ajustei o uso de strcpy para copiar as strings primeiro para uma variável temporária e depois inseri-las na estrutura de dados correta.

O cálculo da nota final e a determinação do conceito estavam corretos, mas não estavam sendo utilizados adequadamente nas funções exibirInformacoesAluno e exibirSituacaoAlunos.

Correção: Ajustei as funções para utilizar e exibir corretamente essas informações.

A função exportarDados não estava implementada corretamente e não verificava a abertura do arquivo de saída.

Correção: Implementei a lógica completa para abrir o arquivo, verificar erros e escrever as informações estruturadas dos professores, turmas e alunos no arquivo de saída.

Algumas funções estavam com a lógica mal estruturada ou faltando, como a necessidade de retornar mensagens apropriadas caso um aluno ou turma não fossem encontrados.

Correção: Adicionei mensagens de erro apropriadas e reestruturei a lógica das funções para melhor clareza e funcionalidade.

Espero que de tudo certo, abraços.

devair1010 · 29 de julho

@Gabriel_PDS qual o resultado que você espera ? , e logo no início do programa você está tentando ler em um arquivo que nem foi criado ainda , o. "'inputFilename" , e também o modo de ler o arquivo usando a quantidade de registros não é apropriada, seria melhor usar um "while" para ler tudo que estiver no arquivo até o final dele que é o EOF , e com apenas um "fscanf" e não é comum colocar palavras antes do tipo de dados a ser lido como nesse caso aqui :

fscanf(inputFile,"PROFESSOR  %[^\n]\n",prof.nome);

Onde o mais comum seria assim:

fscanf(inputFile,"%s", prof.nome);

, e nesse mesmo fscanf ler os outros dados como o registro e o número de turmas ,

fscanf(inputFile,"%s %d %d", prof.nome,prof.registro, prof.turma);

Entrar

C Exercício diário de classe

Posts recomendados

Gabriel_PDS

Link para o comentário

Compartilhar em outros sites

Fábio Henrique013

Link para o comentário

Compartilhar em outros sites

devair1010

Link para o comentário

Compartilhar em outros sites

Crie uma conta ou entre para comentar

Criar uma conta

Entrar

Quem está navegando aqui 0 usuários estão online

Últimos tópicos

Livros

Cursos

Conteúdo recente

Sobre o Clube do Hardware

Direitos autorais

Mais

Fórum

Atividades

Artigos

Análises

Livros

Cursos