Menu
CoddyTech

Descomposición estructurada

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

Los enlaces estructurados, introducidos en C++17, te permiten desempaquetar varios valores de arreglos, pares, tuplas o estructuras en variables individuales con nombre en una sola declaración. Esto hace que el código sea más limpio y legible al trabajar con datos compuestos.

La sintaxis usa auto con corchetes que contienen los nuevos nombres de variables:

#include <iostream>
#include <map>
#include <tuple>

int main() {
    // Desempaquetar un par
    std::pair<std::string, int> person{"Alice", 25};
    auto [name, age] = person;
    std::cout << name << " is " << age << "\n";
    
    // Desempaquetar una tupla
    std::tuple<int, double, char> data{42, 3.14, 'X'};
    auto [num, pi, letter] = data;
    
    // Desempaquetar en bucles for basados en rangos
    std::map<std::string, int> scores{{"Bob", 90}, {"Carol", 85}};
    for (const auto& [student, score] : scores) {
        std::cout << student << ": " << score << "\n";
    }
}

Las vinculaciones estructuradas también funcionan con matrices y estructuras personalizadas que tienen miembros públicos:

struct Point {
    double x;
    double y;
};

Point getOrigin() { return {0.0, 0.0}; }

int main() {
    auto [x, y] = getOrigin();
    
    int arr[3] = {1, 2, 3};
    auto [a, b, c] = arr;
}

Puedes usar auto& o const auto& para enlazar por referencia, evitar copias y permitir modificar los valores originales cuando sea necesario. Esta característica es especialmente útil al iterar sobre contenedores de STL o al manejar funciones que devuelven varios valores.

challenge icon

Desafío

Fácil

Vamos a crear un analizador de calificaciones de estudiantes que muestre el poder de las vinculaciones estructuradas. Crearás un sistema que procese registros de estudiantes y datos de cursos, usando vinculaciones estructuradas para desempaquetar elegantemente pares, tuplas y estructuras a lo largo del código.

Organizarás el código en tres archivos:

  • Student.h: Define una estructura Student con miembros públicos para el nombre del estudiante (std::string), el ID (int) y el GPA (double). También crea una función llamada createStudent que reciba un nombre, un ID y un GPA, y devuelva una estructura Student.
  • GradeUtils.h: Crea funciones de utilidad para procesar calificaciones.

    Define una función getGradeInfo que reciba una puntuación numérica (entero) y devuelva un std::tuple que contenga tres valores: la calificación en letra (std::string), los puntos de la calificación (double) y si se aprueba (bool). Usa esta escala de calificaciones:

    • 90+ : "A", 4.0, true
    • 80-89: "B", 3.0, true
    • 70-79: "C", 2.0, true
    • 60-69: "D", 1.0, true
    • Menos de 60: "F", 0.0, false

    Define también una función makeScorePair que reciba el nombre de un curso (std::string) y la puntuación (int), y devuelva un std::pair con esos valores.

  • main.cpp: Lee cuatro entradas:
    1. Nombre del estudiante (cadena)
    2. ID del estudiante (entero)
    3. Nombre del curso (cadena)
    4. Puntuación (entero)

    Usa vinculaciones estructuradas a lo largo de la función principal:

    1. Llama a createStudent con el nombre, el ID y un GPA provisional de 0.0. Usa vinculaciones estructuradas para desempaquetar la estructura devuelta en variables individuales y luego imprime: Student: [name] (ID: [id])
    2. Llama a makeScorePair con el nombre del curso y la puntuación. Usa vinculaciones estructuradas para desempaquetar el par y luego imprime: Course: [course], Score: [score]
    3. Llama a getGradeInfo con la puntuación. Usa vinculaciones estructuradas para desempaquetar los tres elementos de la tupla y luego imprime:
      Grade: [letter]
      Points: [points]
      Passing: [yes/no]
      (Imprime "yes" si se aprueba es true, "no" si es false)

Por ejemplo, con las entradas Alice, 1001, Math y 85:

Student: Alice (ID: 1001)
Course: Math, Score: 85
Grade: B
Points: 3
Passing: yes

Con las entradas Bob, 2002, Physics y 55:

Student: Bob (ID: 2002)
Course: Physics, Score: 55
Grade: F
Points: 0
Passing: no

Recuerda incluir <tuple> y <utility> donde sea necesario. La idea clave es cómo las vinculaciones estructuradas te permiten desempaquetar tipos compuestos, pares, tuplas y estructuras en variables con nombre mediante una única declaración legible.

Pruébalo tú mismo

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

int main() {
    // Lee las entradas
    std::string studentName;
    int studentId;
    std::string courseName;
    int score;
    
    std::cin >> studentName;
    std::cin >> studentId;
    std::cin >> courseName;
    std::cin >> score;
    
    // TODO: Llama a createStudent con el nombre, el id y un GPA provisional de 0.0
    // Usa enlaces estructurados para desempaquetar la estructura: auto [name, id, gpa] = ...
    // Imprime: Student: [name] (ID: [id])
    
    
    // TODO: Llama a makeScorePair con el nombre del curso y la puntuación
    // Usa enlaces estructurados para desempaquetar el par: auto [course, sc] = ...
    // Imprime: Course: [course], Score: [score]
    
    
    // TODO: Llama a getGradeInfo con la puntuación
    // Usa enlaces estructurados para desempaquetar la tupla: auto [letter, points, passing] = ...
    // Imprime:
    // Grade: [letter]
    // Points: [points]
    // Aprobado: [yes/no] (imprime "yes" si passing es true, "no" si es false)
    
    
    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