Menu
CoddyTech

Recapitulação - Sistema de registros de alunos

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 39 de 104.

Hora de colocar em prática o que você aprendeu sobre encapsulamento! Neste desafio, você vai criar um Sistema de Registros de Alunos que demonstra o uso adequado de especificadores de acesso, ocultação de informações e classes aninhadas.

Seu sistema gerenciará dados dos alunos com estes princípios de encapsulamento:

  • Membros de dados privados para proteger informações confidenciais, como notas e IDs dos alunos
  • Interface pública com getters e setters controlados
  • Uma classe aninhada para representar as notas individuais de cada curso, mantendo esse detalhe de implementação contido na classe do aluno

Esta é a estrutura que você vai implementar:

class Student {
public:
    class Grade {    // Classe aninhada para as notas das disciplinas
        // ...
    };
    
    // Interface pública para interagir com os dados do aluno
    
private:
    std::string name;
    int studentId;
    // Coleção de notas
};

Este desafio reúne tudo o que você viu neste capítulo: escolher os níveis de acesso adequados, ocultar detalhes de implementação por trás de uma interface clara e usar classes aninhadas para organizar tipos relacionados. Pense com cuidado no que deve ser acessível e no que deve permanecer oculto.

challenge icon

Desafio

Fácil

Vamos criar um sistema de registros de alunos que reúne tudo o que você aprendeu sobre encapsulamento. Você criará um sistema em que os dados dos alunos são devidamente protegidos, as notas são gerenciadas por meio de uma classe aninhada e todas as interações acontecem por meio de uma interface pública organizada.

Você criará dois arquivos para organizar seu código:

  • Student.h: defina uma classe Student que demonstra o encapsulamento adequado com uma classe Grade aninhada.

    Sua classe aninhada Grade (declarada na seção pública de Student) deve armazenar o nome de uma disciplina (string) e uma nota (double). Crie um construtor que receba os dois valores e forneça os métodos getCourseName() e getScore() para acessar os dados. A classe Grade mantém seus dados privados; mesmo estando aninhada em Student, ela preserva seu próprio encapsulamento.

    A classe Student deve ter membros privados para o nome do aluno (string), o ID do aluno (int) e uma coleção de ponteiros para Grade. Forneça:

    • Um construtor que receba o nome e o ID do aluno
    • Os getters getName() e getStudentId() (ambos const)
    • Um método addGrade(const std::string& course, double score) que crie uma nova Grade e a adicione ao registro do aluno (adicione somente se a nota estiver entre 0 e 100, inclusive)
    • Um método getAverageGrade() (const) que calcule e retorne a média de todas as notas, ou 0.0 se não houver notas
    • Um método displayRecord() (const) que exiba o registro completo do aluno

    Não se esqueça de liberar as notas alocadas dinamicamente no destrutor e de incluir proteções de cabeçalho adequadas.

  • main.cpp: leia o nome do aluno, o ID do aluno e três notas de disciplinas a partir da entrada. O formato da entrada será composto por cinco linhas: nome, ID e, em seguida, três linhas, cada uma contendo o nome de uma disciplina e uma nota separados por um espaço (por exemplo, Math 95.5).

    Crie um Student com o nome e o ID, adicione as três notas e, em seguida, exiba o registro completo.

    O formato de saída de displayRecord() deve ser:

    Student: <name> (ID: <id>)
    Grades:
      <course1>: <score1>
      <course2>: <score2>
      <course3>: <score3>
    Average: <average>

Formate todas as notas e a média com uma casa decimal usando std::fixed e std::setprecision(1) de <iomanip>. Converta o ID usando std::stoi() e as notas usando std::stod().

Este desafio combina membros de dados privados, getters públicos, métodos de configuração controlados com validação e uma classe aninhada: tudo trabalhando em conjunto para criar um sistema de registros de alunos bem encapsulado.

Experimente você mesmo

#include <iostream>
#include <string>
#include <sstream>
#include "Student.h"

int main() {
    // Leia o nome do aluno
    std::string name;
    std::getline(std::cin, name);
    
    // Leia o ID do aluno
    std::string idStr;
    std::getline(std::cin, idStr);
    int studentId = std::stoi(idStr);
    
    // Leia as notas de três disciplinas (formato: "CourseName Score")
    std::string line1, line2, line3;
    std::getline(std::cin, line1);
    std::getline(std::cin, line2);
    std::getline(std::cin, line3);
    
    // TODO: Analise cada linha para extrair o nome da disciplina e a nota
    // Use std::stod() para converter as strings das notas em valores do tipo double
    
    // TODO: Crie um objeto Student com o nome e o ID
    
    // TODO: Adicione as três notas ao aluno
    
    // TODO: Exiba o registro completo do aluno
    
    return 0;
}
quiz iconTeste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Todas as lições de Programação Orientada a Objetos

Pratique por conta própria: Compilador de C++ online