C++ Academy · Lección

Patrones de gestión de errores

Combine optional y expected

Patrones de gestión de errores es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

Dos herramientas, un objetivo

std::optional y std::expected sustituyen a los sentinelas propensos a errores. En esta lección se muestran patrones para combinarlos y componerlos de forma clara.

Retorno anticipado si está vacío

Un patrón sencillo y fácil de leer: compruebe el optional y salga pronto si está vacío antes de continuar.

#include <iostream>
#include <optional>
std::optional<int> parse(bool ok) { return ok ? std::optional<int>(5) : std::nullopt; }
int main() {
    auto v = parse(true);
    if (!v) { std::cout << "no value\n"; return 0; }
    std::cout << *v + 1 << "\n";
}

De optional a expected

Convierta un optional ausente en un error descrito cuando quien llama necesite conocer el motivo.

#include <expected>
#include <optional>
#include <string>
std::expected<int, std::string> require(std::optional<int> o) {
    if (o) return *o;
    return std::unexpected("value missing");
}
int main() {}

Encadenamiento con value_or

Cuando varias búsquedas contribuyen a un único resultado, value_or permite proporcionar valores predeterminados en línea sin usar if anidados.

#include <iostream>
#include <optional>
int setting(std::optional<int> user, int fallback) {
    return user.value_or(fallback);
}
int main() {
    std::cout << setting(std::nullopt, 42) << "\n";
}

Propagar errores hacia arriba

Con std::expected, una función puede inspeccionar una subllamada y reenviar su error sin modificarlo, creando una cadena de propagación de errores.

#include <expected>
#include <string>
using R = std::expected<int, std::string>;
R step1(bool ok) { return ok ? R(2) : R(std::unexpected("step1 failed")); }
R run(bool ok) {
    auto r = step1(ok);
    if (!r) return std::unexpected(r.error());
    return *r * 10;
}
int main() {}

and_then monádico

El and_then de C++23 encadena operaciones que devuelven un optional o expected, y se detiene ante el primer fallo, sin una cascada manual de if.

transform para mapear

transform aplica una función normal al valor correcto y deja intactos los errores o la ausencia de valor; solo transforma el camino exitoso.

or_else para recuperarse

or_else ejecuta una alternativa que puede proporcionar un valor de reemplazo o un error alternativo cuando el valor original está ausente o la operación ha fallado.

Elegir entre ambos

Use optional cuando la ausencia no necesite explicación (un fallo de caché). Use expected cuando quien llama deba distinguir los motivos del fallo (errores de análisis frente a errores de permisos).

Evite mezclar sentinelas

No mezcle códigos de error antiguos con optional/expected en una misma API. Elija una estrategia coherente para que quienes llamen gestionen los fallos de manera uniforme.

Errores tipados

Prefiera una enumeración o una estructura pequeña para el tipo de error en lugar de cadenas sin estructura cuando los fallos se comprueben mediante código; las cadenas son mejores para los mensajes dirigidos a las personas.

Comprobación rápida

Compruebe su comprensión de los patrones de manejo de errores.

Resumen

Ha aprendido patrones de manejo de errores:

El retorno anticipado ante la ausencia o un error mantiene el código plano.
Convierta optional en expected cuando se necesite un motivo.
Componga con and_then, transform y or_else (C++23).
Mantenga la coherencia; evite mezclar sentinelas con optional/expected.

Preguntas frecuentes

¿La lección «Patrones de gestión de errores» es gratis?

Sí — el texto completo de «Patrones de gestión de errores» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Patrones de gestión de errores»?

Combine optional y expected Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Patrones de gestión de errores»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C++ Academy