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.
Desafío
FácilVamos 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 estructuraStudentcon miembros públicos para el nombre del estudiante (std::string), el ID (int) y el GPA (double). También crea una función llamadacreateStudentque reciba un nombre, un ID y un GPA, y devuelva una estructuraStudent.GradeUtils.h: Crea funciones de utilidad para procesar calificaciones.Define una función
getGradeInfoque reciba una puntuación numérica (entero) y devuelva unstd::tupleque 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
makeScorePairque reciba el nombre de un curso (std::string) y la puntuación (int), y devuelva unstd::paircon esos valores.main.cpp: Lee cuatro entradas:- Nombre del estudiante (cadena)
- ID del estudiante (entero)
- Nombre del curso (cadena)
- Puntuación (entero)
Usa vinculaciones estructuradas a lo largo de la función principal:
- Llama a
createStudentcon 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]) - Llama a
makeScorePaircon el nombre del curso y la puntuación. Usa vinculaciones estructuradas para desempaquetar el par y luego imprime:Course: [course], Score: [score] - Llama a
getGradeInfocon la puntuación. Usa vinculaciones estructuradas para desempaquetar los tres elementos de la tupla y luego imprime:(Imprime "yes" si se aprueba es true, "no" si es false)Grade: [letter] Points: [points] Passing: [yes/no]
Por ejemplo, con las entradas Alice, 1001, Math y 85:
Student: Alice (ID: 1001)
Course: Math, Score: 85
Grade: B
Points: 3
Passing: yesCon las entradas Bob, 2002, Physics y 55:
Student: Bob (ID: 2002)
Course: Physics, Score: 55
Grade: F
Points: 0
Passing: noRecuerda 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;
}
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
1Fundamentos de la POO
Archivos externosCompilación y construcción en C++Archivos de cabecera y archivos fuenteEspacios de nombres y ámbitoIntroducción a la POO en C++Clases y objetosEl puntero 'this'Métodos (funciones miembro)Atributos (miembros de datos)Fundamentos de constructores y destructoresRepaso: calculadora sencilla4Propiedades de clase
Miembros de instancia vs. estáticosGetters y settersFunciones miembro constPalabra clave mutableMétodos y variables estáticosFunciones y clases friendRepaso: gestor de cuentas bancarias7Herencia
Herencia básicaNiveles de acceso en la herenciaOrden de llamada de constructores y destructoresSobrescritura de métodosFunciones virtuales y VTableHerencia múltipleHerencia virtualRepaso: jerarquía de empleados2Gestión de memoria
Memoria de pila vs. heapPunteros y referenciasMemoria dinámica (new/delete)Punteros inteligentes en C++RAII en C++Repaso: gestor de arreglos dinámicos5Encapsulación
Especificadores de acceso en C++Especificadores de acceso en profundidadOcultación de informaciónStruct vs. classClases anidadas e internasRepaso: sistema de registros de estudiantes8Polimorfismo
Polimorfismo en compilación y en tiempo de ejecuciónSobrecarga de funcionesRepaso de las funciones virtualesFunciones virtuales purasClases abstractasDiseño de interfaces en C++Conversión dinámica y RTTIRepaso: calculadora de formas11Conceptos avanzados de POO
Composición frente a herenciaMixins mediante CRTPIdiom PimplBorrado de tiposClases enum y tipado fuerteManejo de excepciones en POOJerarquías de excepciones personalizadas14Patrones de diseño, parte 2
Patrón CommandPatrón AdapterPatrón DecoratorPatrón Template MethodPatrón StatePatrón CompositeRAII como patrón3Constructores y destructores
Constructor predeterminadoConstructor con parámetrosConstructor de copiaConstructor de movimientoListas de inicialización del constructorConstructores delegadosAnálisis detallado del destructorRegla de tres / cinco / ceroRepaso: clase String6Sobrecarga de operadores
Introducción a la sobrecarga de operadoresSobrecarga de operadores aritméticosSobrecarga de operadores de comparaciónOperadores de flujoSobrecarga del operador de asignaciónSobrecarga de los operadores [] y ()Operadores de conversión de tipoRepaso: clase Matrix9Plantillas
Plantillas de funcionesPlantillas de clasesEspecialización de plantillasPlantillas variádicasFundamentos de SFINAE y rasgos de tiposRepaso: contenedor genérico12Características modernas de C++
Semántica de movimiento y rvaluesReenvío perfectoExpresiones lambda en profundidadstd::function y std::bindconstexpr y constevalDescomposición estructuradaoptional, variant, anyPractica por tu cuenta: Compilador de C++ online