Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0613· openaiHugging Face Suzhen/CodeChat

Criar um TDA em C que representa um ALUNO com os seguintes dados: código do aluno como…

  1. User

    Criar um TDA em C que representa um ALUNO com os seguintes dados: código do aluno como um valor inteiro, nome do aluno uma string, idade do aluno valor inteiro e o coeficiente do aluno com um valor float.

    Criar um segundo TDA em C que representa a TURMA que vai ter como valor uma lista de alunos e a quantidade de alunos na turma. Implemente para o TDA TURMA as seguintes operações:

    • Criar uma nova TURMA com uma quantidade de alunos definida.

    • Inserir alunos na TURMA.

    • Liberar o espaço na memória de uma TURMA.

    • Buscar um aluno pelo código do aluno usando uma busca sequencial. Imprimir os dados do aluno.

    • Imprimir o código e o nome dos alunos de uma TURMA;

    Para ambos os TDA implemente um arquivo .h e um arquivo .c

  2. Assistant

    Segue a implementação dos TDAs em C:

    1. aluno.h
    #ifndef ALUNO_H
    #define ALUNO_H
    
    typedef struct {
        int codigo;
        char nome[100];
        int idade;
        float coeficiente;
    } Aluno;
    
    #endif
    
    1. aluno.c
    #include <stdio.h>
    #include <string.h>
    #include "aluno.h"
    
    void imprimirAluno(Aluno aluno) {
        printf("Código: %d\n", aluno.codigo);
        printf("Nome: %s\n", aluno.nome);
        printf("Idade: %d\n", aluno.idade);
        printf("Coeficiente: %.2f\n", aluno.coeficiente);
    }
    
    1. turma.h
    #ifndef TURMA_H
    #define TURMA_H
    #include "aluno.h"
    
    typedef struct {
        Aluno *alunos;
        int quantidade;
    } Turma;
    
    Turma criarTurma(int quantidade);
    void inserirAluno(Turma *turma, Aluno aluno);
    void liberarTurma(Turma *turma);
    void buscarAluno(Turma turma, int codigo);
    void imprimirTurma(Turma turma);
    
    #endif
    
    1. turma.c
    #include <stdio.h>
    #include <stdlib.h>
    #include "turma.h"
    
    Turma criarTurma(int quantidade) {
        Turma turma;
        turma.alunos = (Aluno *) malloc(quantidade * sizeof(Aluno));
        turma.quantidade = quantidade;
        return turma;
    }
    
    void inserirAluno(Turma *turma, Aluno aluno) {
        if (turma->alunos == NULL) {
            printf("Turma não criada. Impossível inserir aluno.\n");
            return;
        }
        for (int i = 0; i < turma->quantidade; i++) {
            if (turma->alunos[i].codigo == 0) {
                turma->alunos[i] = aluno;
                printf("Aluno inserido com sucesso!\n");
                return;
            }
        }
        printf("Turma cheia. Impossível inserir aluno.\n");
    }
    
    void liberarTurma(Turma *turma) {
        if (turma->alunos != NULL) {
            free(turma->alunos);
            turma->alunos = NULL;
            turma->quantidade = 0;
            printf("Turma liberada da memória.\n");
        }
    }
    
    void buscarAluno(Turma turma, int codigo) {
        if (turma.alunos == NULL) {
            printf("Turma não criada.\n");
            return;
        }
        for (int i = 0; i < turma.quantidade; i++) {
            if (turma.alunos[i].codigo == codigo) {
                printf("Aluno encontrado:\n");
                imprimirAluno(turma.alunos[i]);
                return;
            }
        }
        printf("Aluno não encontrado.\n");
    }
    
    void imprimirTurma(Turma turma) {
        if (turma.alunos == NULL) {
            printf("Turma não criada.\n");
            return;
        }
        printf("Código e nome dos alunos:\n");
        for (int i = 0; i < turma.quantidade; i++) {
            if (turma.alunos[i].codigo != 0) {
                printf("Código: %d, Nome: %s\n", turma.alunos[i].codigo, turma.alunos[i].nome);
            }
        }
    }
    

    Assim, para utilização desses TDAs, você pode criar um arquivo main.c para testes:

    #include <stdio.h>
    #include "turma.h"
    
    int main() {
        Turma turma = criarTurma(5);
        
        Aluno aluno1 = {1, "João", 20, 8.5};
        Aluno aluno2 = {2, "Maria", 19, 9.0};
        Aluno aluno3 = {3, "Pedro", 21, 7.8};
        
        inserirAluno(&turma, aluno1);
        inserirAluno(&turma, aluno2);
        inserirAluno(&turma, aluno3);
        
        buscarAluno(turma, 2);
        
        imprimirTurma(turma);
        
        liberarTurma(&turma);
        
        return 0;
    }
    

    Espero ter ajudado!

  3. User

    Reescreva os códigos adicionando um linha "typedef struct Aluno aluno;" em aluno.h e uma linha "typedef struct Turma turma;" em turma.h, faça as respectivas alterações no restante do código.

  4. Assistant

    Segue a implementação dos TDAs atualizados:

    1. aluno.h
    #ifndef ALUNO_H
    #define ALUNO_H
    
    typedef struct Aluno {
        int codigo;
        char nome[100];
        int idade;
        float coeficiente;
    } Aluno;
    
    #endif
    
    1. aluno.c
    #include <stdio.h>
    #include <string.h>
    #include "aluno.h"
    
    void imprimirAluno(Aluno aluno) {
        printf("Código: %d\n", aluno.codigo);
        printf("Nome: %s\n", aluno.nome);
        printf("Idade: %d\n", aluno.idade);
        printf("Coeficiente: %.2f\n", aluno.coeficiente);
    }
    
    1. turma.h
    #ifndef TURMA_H
    #define TURMA_H
    #include "aluno.h"
    
    typedef struct Turma {
        Aluno *alunos;
        int quantidade;
    } Turma;
    
    Turma criarTurma(int quantidade);
    void inserirAluno(Turma *turma, Aluno aluno);
    void liberarTurma(Turma *turma);
    void buscarAluno(Turma turma, int codigo);
    void imprimirTurma(Turma turma);
    
    #endif
    
    1. turma.c
    #include <stdio.h>
    #include <stdlib.h>
    #include "turma.h"
    
    Turma criarTurma(int quantidade) {
        Turma turma;
        turma.alunos = (Aluno *) malloc(quantidade * sizeof(Aluno));
        turma.quantidade = quantidade;
        return turma;
    }
    
    void inserirAluno(Turma *turma, Aluno aluno) {
        if (turma->alunos == NULL) {
            printf("Turma não criada. Impossível inserir aluno.\n");
            return;
        }
        for (int i = 0; i < turma->quantidade; i++) {
            if (turma->alunos[i].codigo == 0) {
                turma->alunos[i] = aluno;
                printf("Aluno inserido com sucesso!\n");
                return;
            }
        }
        printf("Turma cheia. Impossível inserir aluno.\n");
    }
    
    void liberarTurma(Turma *turma) {
        if (turma->alunos != NULL) {
            free(turma->alunos);
            turma->alunos = NULL;
            turma->quantidade = 0;
            printf("Turma liberada da memória.\n");
        }
    }
    
    void buscarAluno(Turma turma, int codigo) {
        if (turma.alunos == NULL) {
            printf("Turma não criada.\n");
            return;
        }
        for (int i = 0; i < turma.quantidade; i++) {
            if (turma.alunos[i].codigo == codigo) {
                printf("Aluno encontrado:\n");
                imprimirAluno(turma.alunos[i]);
                return;
            }
        }
        printf("Aluno não encontrado.\n");
    }
    
    void imprimirTurma(Turma turma) {
        if (turma.alunos == NULL) {
            printf("Turma não criada.\n");
            return;
        }
        printf("Código e nome dos alunos:\n");
        for (int i = 0; i < turma.quantidade; i++) {
            if (turma.alunos[i].codigo != 0) {
                printf("Código: %d, Nome: %s\n", turma.alunos[i].codigo, turma.alunos[i].nome);
            }
        }
    }
    

    Assim, a utilização dos TDAs continua a mesma do exemplo anterior, apenas com as alterações realizadas nos arquivos .h.

    #include <stdio.h>
    #include "turma.h"
    
    int main() {
        Turma turma = criarTurma(5);
        
        Aluno aluno1 = {1, "João", 20, 8.5};
        Aluno aluno2 = {2, "Maria", 19, 9.0};
        Aluno aluno3 = {3, "Pedro", 21, 7.8};
        
        inserirAluno(&turma, aluno1);
        inserirAluno(&turma, aluno2);
        inserirAluno(&turma, aluno3);
        
        buscarAluno(turma, 2);
        
        imprimirTurma(turma);
        
        liberarTurma(&turma);
        
        return 0;
    }
    

    Espero que isso ajude!

  5. User

    Você não fez o que eu pedi.

  6. Assistant

    Peço desculpas pela confusão. Aqui estão os códigos atualizados com as linhas "typedef struct" adicionadas:

    1. aluno.h
    #ifndef ALUNO_H
    #define ALUNO_H
    
    typedef struct Aluno {
        int codigo;
        char nome[100];
        int idade;
        float coeficiente;
    } Aluno;
    
    typedef struct Aluno aluno; // Adicionado typedef struct
    
    #endif
    
    1. aluno.c
    #include <stdio.h>
    #include <string.h>
    #include "aluno.h"
    
    void imprimirAluno(aluno aluno) { // Modificado para usar o typedef struct
        printf("Código: %d\n", aluno.codigo);
        printf("Nome: %s\n", aluno.nome);
        printf("Idade: %d\n", aluno.idade);
        printf("Coeficiente: %.2f\n", aluno.coeficiente);
    }
    
    1. turma.h
    #ifndef TURMA_H
    #define TURMA_H
    #include "aluno.h"
    
    typedef struct Turma {
        aluno *alunos; // Modificado para usar o typedef struct
        int quantidade;
    } Turma;
    
    typedef struct Turma turma; // Adicionado typedef struct
    
    turma criarTurma(int quantidade); // Modificado para usar o typedef struct
    void inserirAluno(turma *turma, aluno aluno); // Modificado para usar o typedef struct
    void liberarTurma(turma *turma); // Modificado para usar o typedef struct
    void buscarAluno(turma turma, int codigo); // Modificado para usar o typedef struct
    void imprimirTurma(turma turma); // Modificado para usar o typedef struct
    
    #endif
    
    1. turma.c
    #include <stdio.h>
    #include <stdlib.h>
    #include "turma.h"
    
    turma criarTurma(int quantidade) { // Modificado para usar o typedef struct
        turma turma;
        turma.alunos = (aluno *) malloc(quantidade * sizeof(aluno)); // Modificado para usar o typedef struct
        turma.quantidade = quantidade;
        return turma;
    }
    
    void inserirAluno(turma *turma, aluno aluno) { // Modificado para usar o typedef struct
        if (turma->alunos == NULL) {
            printf("Turma não criada. Impossível inserir aluno.\n");
            return;
        }
        for (int i = 0; i < turma->quantidade; i++) {
            if (turma->alunos[i].codigo == 0) {
                turma->alunos[i] = aluno;
                printf("Aluno inserido com sucesso!\n");
                return;
            }
        }
        printf("Turma cheia. Impossível inserir aluno.\n");
    }
    
    void liberarTurma(turma *turma) { // Modificado para usar o typedef struct
        if (turma->alunos != NULL) {
            free(turma->alunos);
            turma->alunos = NULL;
            turma->quantidade = 0;
            printf("Turma liberada da memória.\n");
        }
    }
    
    void buscarAluno(turma turma, int codigo) { // Modificado para usar o typedef struct
        if (turma.alunos == NULL) {
            printf("Turma não criada.\n");
            return;
        }
        for (int i = 0; i < turma.quantidade; i++) {
            if (turma.alunos[i].codigo == codigo) {
                printf("Aluno encontrado:\n");
                imprimirAluno(turma.alunos[i]);
                return;
            }
        }
        printf("Aluno não encontrado.\n");
    }
    
    void imprimirTurma(turma turma) { // Modificado para usar o typedef struct
        if (turma.alunos == NULL) {
            printf("Turma não criada.\n");
            return;
        }
        printf("Código e nome dos alunos:\n");
        for (int i = 0; i < turma.quantidade; i++) {
            if (turma.alunos[i].codigo != 0) {
                printf("Código: %d, Nome: %s\n", turma.alunos[i].codigo, turma.alunos[i].nome);
            }
        }
    }
    

    A utilização dos TDAs continua a mesma do exemplo anterior.

    #include <stdio.h>
    #include "turma.h"
    
    int main() {
        turma turma = criarTurma(5); // Modificado para usar o typedef struct
        
        aluno aluno1 = {1, "João", 20, 8.5}; // Modificado para usar o typedef struct
        aluno aluno2 = {2, "Maria", 19, 9.0}; // Modificado para usar o typedef struct
        aluno aluno3 = {3, "Pedro", 21, 7.8}; // Modificado para usar o typedef struct
        
        inserirAluno(&turma, aluno1); // Modificado para usar o typedef struct
        inserirAluno(&turma, aluno2); // Modificado para usar o typedef struct
        inserirAluno(&turma, aluno3); // Modificado para usar o typedef struct
        
        buscarAluno(turma, 2); // Modificado para usar o typedef struct
        
        imprimirTurma(turma); // Modificado para usar o typedef struct
        
        liberarTurma(&turma); // Modificado para usar o typedef struct
        
        return 0;
    }
    

    Novamente, peço desculpas pela confusão na resposta anterior. Espero que isso seja o que você está procurando!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.