C++ en 2025: nuevas características y ejemplos de código en la práctica

C++ en 2025: ¿qué hay de nuevo en la práctica?

2025 es un año emblemático para la comunidad de C++. El estándar C++26 se está finalizando activamente, y muchas características que ayer parecían experimentales ya están disponibles en los compiladores. En este artículo no solo enumeraremos las novedades, sino que mostraremos cómo cambian el desarrollo diario en la práctica. No nos adentraremos en los borradores del comité, sino que nos centraremos en lo que ya se puede (o casi se puede) usar en proyectos reales.

1. Pattern Matching: la era del «switch» de nueva generación

Una de las características más esperadas es el pattern matching. Aunque la sintaxis aún se está estabilizando, en 2025 vemos cómo simplifica el trabajo con estructuras de datos complejas. En lugar de largas cadenas de if-else o std::visit, aparece una sintaxis concisa.

Ejemplo: Supongamos que tenemos un std::variant para representar el estado de un pedido.

#include <variant>#include <iostream>#include <string>

enum class Status { Pending, Shipped, Delivered };struct Order {    int id;    std::variant<Status, std::string> state; // Ya sea un estado o un mensaje de error};

void process_order(const Order& o) {    // En C++26 (sintaxis hipotética)    inspect (o.state) {        as Status::Pending => std::cout << "Pedido " << o.id << " pendiente de procesamiento";        as Status::Shipped => std::cout << "Pedido " << o.id << " enviado";        as Status::Delivered => std::cout << "Pedido " << o.id << " entregado";        as std::string err => std::cerr << "Error: " << err << " para el pedido " << o.id << "";    }}

En la práctica, esto significa que el código se vuelve más legible y seguro. El compilador puede verificar si se han manejado todas las opciones posibles, lo que reduce la cantidad de errores.

2. Reflexión (Reflection): el compilador como su asistente

La reflexión estática no es magia, sino la capacidad de obtener información sobre tipos y miembros de clases en tiempo de compilación. En 2025, esto deja de ser una rareza. Las bibliotecas y frameworks comienzan a usarla para serialización automática, generación de código y registro de eventos (logging).

Ejemplo: Serialización automática a JSON sin macros ni herramientas externas.

#include <reflection> // Archivo de encabezado hipotético para C++26#include <iostream>#include <string>

struct User {    std::string name;    int age;    std::string email;};

// Función que usa reflexión para recorrer los campostemplate<typename T>void to_json(const T& obj) {    std::cout << "{ ";    // constexpr for — bucle en tiempo de compilación    for constexpr (auto& member : members_of<T>()) {        std::cout << "\\"" << member.name << "\\": \\"" << member.get(obj) << "\\", ";    }    std::cout << "}";}

int main() {    User u{"Alice", 30, "alice@example.com"};    to_json(u); // Salida: { "name": "Alice", "age": "30", "email": "alice@example.com", }    return 0;}

En la práctica, la reflexión elimina la necesidad de escribir código repetitivo (boilerplate). El desarrollador no tiene que actualizar manualmente las funciones de serialización al agregar un nuevo campo; el compilador lo hará por él.

3. Corrutinas (Coroutines) mejoradas y std::execution

Las corrutinas en C++20 fueron una herramienta potente pero compleja. Para 2025, la situación cambia: aparecen envoltorios y bibliotecas de más alto nivel, como std::execution. Ahora el código asíncrono no solo es eficiente, sino también legible.

Ejemplo: Carga asíncrona de datos desde múltiples fuentes usando std::execution::async_scope (API hipotética).