Menu
CoddyTech

Repaso: sistema de registros de estudiantes

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 39 de 104.

¡Es hora de poner en práctica tus conocimientos sobre encapsulación! En este desafío, crearás un sistema de registros de estudiantes que demuestra el uso adecuado de especificadores de acceso, ocultación de información y clases anidadas.

Tu sistema gestionará los datos de los estudiantes con estos principios de encapsulación:

  • Miembros de datos privados para proteger información confidencial, como las calificaciones y los identificadores de estudiantes
  • Interfaz pública con getters y setters controlados
  • Una clase anidada para representar las calificaciones individuales de los cursos, manteniendo este detalle de implementación dentro de la clase del estudiante

Esta es la estructura que implementarás:

class Student {
public:
    class Grade {    // Clase anidada para las calificaciones del curso
        // ...
    };
    
    // Interfaz pública para interactuar con los datos del estudiante
    
private:
    std::string name;
    int studentId;
    // Colección de calificaciones
};

Este desafío combina todo lo aprendido en este capítulo: elegir los niveles de acceso adecuados, ocultar los detalles de implementación tras una interfaz clara y usar clases anidadas para organizar tipos relacionados. Piensa detenidamente qué debería ser accesible y qué debería permanecer oculto.

challenge icon

Desafío

Fácil

Construyamos un sistema de expedientes de estudiantes que reúna todo lo que has aprendido sobre encapsulación. Crearás un sistema en el que los datos de los estudiantes estén debidamente protegidos, las calificaciones se administren mediante una clase anidada y todas las interacciones se realicen a través de una interfaz pública clara.

Crearás dos archivos para organizar tu código:

  • Student.h: Define una clase Student que demuestra una encapsulación adecuada con una clase Grade anidada.

    Tu clase Grade anidada (declarada en la sección pública de Student) debe almacenar el nombre de un curso (string) y una calificación (double). Asígnale un constructor que reciba ambos valores y proporciona los métodos getCourseName() y getScore() para acceder a los datos. La clase Grade mantiene sus datos privados; aunque esté anidada dentro de Student, conserva su propia encapsulación.

    La clase Student debe tener miembros privados para el nombre del estudiante (string), el ID del estudiante (int) y una colección de punteros a Grade. Proporciona:

    • Un constructor que reciba el nombre y el ID del estudiante
    • Los getters getName() y getStudentId() (ambos const)
    • Un método addGrade(const std::string& course, double score) que cree una nueva instancia de Grade y la añada al expediente del estudiante (añade la calificación solo si está entre 0 y 100, inclusive)
    • Un método getAverageGrade() (const) que calcule y devuelva el promedio de todas las calificaciones, o 0.0 si no hay ninguna
    • Un método displayRecord() (const) que muestre el expediente completo del estudiante

    No olvides liberar las calificaciones asignadas dinámicamente en el destructor e incluir las protecciones adecuadas para el encabezado.

  • main.cpp: Lee un nombre de estudiante, un ID de estudiante y las calificaciones de tres cursos desde la entrada. El formato de entrada será de cinco líneas: nombre, ID y luego tres líneas, cada una con el nombre de un curso y una calificación separados por un espacio (por ejemplo, Math 95.5).

    Crea un objeto Student con el nombre y el ID, añade las tres calificaciones y luego muestra el expediente completo.

    El formato de salida de displayRecord() debe ser:

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

Da formato a todas las calificaciones y al promedio con un decimal usando std::fixed y std::setprecision(1) de <iomanip>. Convierte el ID usando std::stoi() y las calificaciones usando std::stod().

Este desafío combina miembros de datos privados, getters públicos, setters controlados con validación y una clase anidada: todo trabajando en conjunto para crear un sistema de expedientes de estudiantes bien encapsulado.

Pruébalo tú mismo

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

int main() {
    // Lee el nombre del estudiante
    std::string name;
    std::getline(std::cin, name);
    
    // Lee el ID del estudiante
    std::string idStr;
    std::getline(std::cin, idStr);
    int studentId = std::stoi(idStr);
    
    // Lee las calificaciones de tres cursos (formato: "CourseName Score")
    std::string line1, line2, line3;
    std::getline(std::cin, line1);
    std::getline(std::cin, line2);
    std::getline(std::cin, line3);
    
    // TODO: Analiza cada línea para extraer el nombre del curso y la calificación
    // Usa std::stod() para convertir las cadenas de calificaciones a valores de tipo double
    
    // TODO: Crea un objeto Student con el nombre y el ID
    
    // TODO: Añade las tres calificaciones al estudiante
    
    // TODO: Muestra el expediente completo del estudiante
    
    return 0;
}
quiz iconPonte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Todas las lecciones de Programación Orientada a Objetos

Practica por tu cuenta: Compilador de C++ online