mp-units v2 - Biblioteca de magnitudes y unidades físicas

Sobre este artículo

     Tiempo estimado de lectura: 20 minutos
     Nivel: Intermedio
     Última actualización: 05 de mayo, 2026

1. Introducción y terminología

Imagen generada con inteligencia artificial. Uso con fines divulgativos

En entornos científicos y tecnológicos, el manejo implícito de unidades físicas es una fuente constante de errores que puede derivar en fallos críticos y grandes costes operativos. En C++, adoptar un sistema de tipado fuerte para magnitudes puede permitir que el compilador actúe como un motor de verificación, detectando inconsistencias dimensionales y resolviendo la lógica de conversión de unidades antes de que tenga lugar la ejecución. Este enfoque logra la seguridad sin penalización en el rendimiento (zero-overhead abstraction [1]), generando un código binario tan eficiente como si se hubiesen empleado tipos numéricos fundamentales desprotegidos (típicamente double), pero eliminando peligrosos errores de magnitudes en tiempo de ejecución.

Reflexión en C++26 (Parte 1)

Lecturas de la serie

• Parte 1: Operador de reflexión ^^ y splicers [:...:]. Sentencias de expansión (template for).
• Parte 2: Anotaciones para reflexión. [Por publicar]
• Parte 3: Generación de agregados (define_aggregate). Bloques consteval.  [Por publicar]
• Parte 4: Sustitución (substitute) y extracción (extract). [Por publicar]

Sobre este artículo

     Tiempo estimado de lectura: 30 minutos
     Nivel: Intermedio-avanzado (metaprogramación, constexpr/consteval, std::expected)
     Última actualización: 28 de abril, 2026

1. Introducción: operador de reflexión ^^ y splicers [:…:]

Esta serie de artículos busca introducir al lector en las nuevas capacidades de reflexión estática que formarán parte del próximo estándar ISO C++26, tal y como fueron introducidas en la propuesta P2996 [1] y que ya han sido incorporadas (con algunas modificaciones y extensiones [2-7]) al draft del estándar [8]. Por reflexión estática entendemos aquí la capacidad de un programa de analizar su propia estructura durante la compilación —a diferencia de la reflexión en tiempo de ejecución de lenguajes como Java o Python— y de generar código derivado de dicha información.

Esta nueva funcionalidad constituye uno de los avances más significativos en la evolución reciente del lenguaje, al ampliar de manera sustancial las capacidades de meta-programación disponibles para el desarrollador. Se fundamenta en los siguientes principios:

1. La representación de elementos del programa mediante expresiones constantes (constant‑expressions) que producen valores de reflexión —reflexiones— del tipo opaco std::meta::info.
2. El operador unario de reflexión (prefijo ^^), capaz de proyectar múltiples construcciones gramaticales del lenguaje a sus correspondientes reflexiones. Se contemplan aquí namespace-names, type-ids, id-expressions (variables, funciones, datos miembro estáticos y no estáticos, plantillas y miembros de plantillas, enumeradores) y el espacio de nombres global ::. El operador ^^ produce prvalues de tipo std::meta::info.
3. Un amplio conjunto de operaciones consteval en la cabecera <meta> para trabajar con dichas reflexiones (incluyendo la derivación de otras reflexiones).
4. Los denominados splicers [: refl :], que permiten generar elementos gramaticales a partir de reflexiones (donde refl debe ser una expresión constante de tipo std::meta::info).

Podemos entender este sistema como una interacción entre dos dominios: el dominio del programa (tipos, miembros, expresiones, etc.) y el meta-dominio formado por los valores std::meta::info. El operador ^^ proyecta elementos del programa al meta‑dominio, donde pueden inspeccionarse y manipularse (por ejemplo, consultando sus tipos, sus identificadores, sus miembros o sus argumentos de plantilla). Los splicers realizan el movimiento inverso, reintroduciendo (reificando) en el código construcciones derivadas de esas reflexiones. Por supuesto, un splicer no puede expandirse a código arbitrario: siempre deberá producir una construcción bien formada, válida en el contexto gramatical donde aparezca. Esta bidireccionalidad constituye la base de la reflexión estática en C++26.

Biblioteca chrono - Ejemplo de uso: contando los días laborables en un período

En este post analizaremos el empleo de la biblioteca estándar <chrono> [1] para la codificación de un algoritmo sencillo que permita determinar el número de días laborables en un período temporal dado. En nuestros ejemplos haremos uso, entre otras, de la función std::chrono::parse [2] incluida en C++20 y que cuenta con una implementación experimental en el compilador GCC 14.

A modo de caso concreto de estudio, nos centraremos en el ámbito educativo a fin de computar los días lectivos dentro de cualquier intervalo cerrado [sd_0, sd_1], siendo sd_0 y sd_1 dos fechas enmarcadas en un curso académico que cumplan sd_0 ≤ sd_1. Como días lectivos asumiremos todos aquéllos de la semana exceptuando sábados, domingos y festivos.

tl-ranges - Instalación bajo mingw-w64

La biblioteca tl-ranges de Sy Brand [1], distribuida bajo una licencia de dominio público, proporciona una excelente implementación de adaptadores de rangos que no llegaron a ser incluidos en C++20. Entre ellos destacaríamos (los elementos estandarizados en C++23 se indican con un asterisco):

C++23 - Generador síncrono std::generator

El futuro estándar del lenguaje C++23 incorporará la plantilla de clase std::generator (cabecera <generator>) como modo de obtener generadores síncronos basados en corrutinas que modelen el concepto std::ranges::input_range (recordemos que los algoritmos que operan con este tipo de rangos no deben intentar atravesar un mismo iterador input_range más de una vez). Dichos generadores constituyen vistas que sólo pueden moverse (move-only views), con iteradores de igual naturaleza [1].

Como primer ejemplo, consideremos el siguiente generador de números enteros pertenecientes a la sucesión de Fibonacci, es decir, aquélla que comienza con los números 0 y 1 y para la que cada valor subsiguiente se calcula como suma de los dos elementos que lo preceden. Por sencillez, ignoraremos el inevitable desbordamiento de enteros para valores elevados de la sucesión [1]:

   auto fibonacci_gen() -> std::generator<int>    {       auto a = 0,            b = 1;       while (true) {          co_yield std::exchange(a, std::exchange(b, a + b));       }    }

"Hello, world!" en C++23

C++ ha conocido dos estándares en su etapa moderna que, por su alcance y extensión, han revolucionado la manera de programar en el lenguaje. Nos referimos, por supuesto, a C++11 y C++20. El próximo estándar del lenguaje, C++23, puede considerarse una actualización relativamente menor de C++20, de forma análoga a como C++14 y C++17 constituyeron extensiones naturales de C++11. Aun cuando la pandemia por COVID-19 de los últimos años haya afectado al proceso de trabajo habitual del comité ISO WG21, C++23 logrará publicarse en plazo presentando numerosas novedades, entre las que cabe señalar:

• A nivel del núcleo del lenguaje: if consteval [1], deducción de this [2], atributos en expresiones lambda [3], atributo [[assume]] [4], auto(x) y auto{x} [5], directiva #warning [6].
• A nivel de la biblioteca estándar: nuevas vistas std::views [7], <expected> [8], operaciones monádicas para std::optional [9], vistas para arrays multidimensionales <mdspan> [10], adaptadores de contenedores asociativos <flat_map> y <flat_set> [11, 12], generadores síncronos std::generator como soporte para corrutinas [13], funciones de impresión std::print y std::println en <print> [14].