C++ Academy · Lección

Conceptos básicos de std::expected

Devuelva valores o errores

Conceptos básicos de std::expected es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 3 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.

Valores o errores

std::expected<T, E> (C++23) contiene un valor correcto de tipo T o un error de tipo E. A diferencia de optional, incluye el motivo del fallo. Incluya <expected>.

Devolver un resultado correcto

Si la operación tiene éxito, devuelva directamente el valor; se almacena como el tipo «expected» T.

#include <expected>
#include <iostream>
std::expected<int, std::string> parse(bool ok) {
    if (ok) return 100;
    return std::unexpected("bad input");
}
int main() {
    auto r = parse(true);
    if (r) std::cout << *r << "\n";
}

Devolver un error

Envuelva el error en std::unexpected(...) para indicar el fallo sin dejar de devolver el mismo tipo.

#include <expected>
#include <iostream>
#include <string>
std::expected<int, std::string> div(int a, int b) {
    if (b == 0) return std::unexpected("divide by zero");
    return a / b;
}
int main() {
    auto r = div(8, 0);
    if (!r) std::cout << r.error() << "\n";
}

Comprobar el éxito

Compruebe el resultado en un contexto booleano o con has_value(). True significa que contiene el valor y false, que contiene el error.

#include <expected>
#include <iostream>
int main() {
    std::expected<int, int> r = 5;
    std::cout << r.has_value() << "\n"; // 1
}

Leer el valor

Use *r o r.value() para leer el valor correcto. value() lanza std::bad_expected_access si en realidad contiene un error.

#include <expected>
#include <iostream>
int main() {
    std::expected<int, std::string> r = 7;
    if (r) std::cout << r.value() << "\n";
}

Leer el error

Cuando el resultado está en estado de error, r.error() le proporciona el objeto de error.

#include <expected>
#include <iostream>
#include <string>
std::expected<int, std::string> f() { return std::unexpected("nope"); }
int main() {
    auto r = f();
    if (!r) std::cout << "error: " << r.error() << "\n";
}

value_or como alternativa

Al igual que en optional, value_or(fallback) devuelve el valor correcto o un valor predeterminado sin inspeccionar el error.

#include <expected>
#include <iostream>
std::expected<int, std::string> f() { return std::unexpected("x"); }
int main() {
    std::cout << f().value_or(0) << "\n"; // 0
}

optional frente a expected

std::optional indica «un valor o nada»; std::expected indica «un valor o un error descrito». Elija expected cuando quienes llaman necesiten conocer el motivo del fallo.

Tipos de error detallados

El tipo de error E puede ser una enumeración, una estructura o una cadena de texto: lo que mejor describa los fallos de su dominio.

#include <expected>
#include <iostream>
enum class Err { NotFound, Denied };
std::expected<int, Err> get(bool ok) {
    if (ok) return 1;
    return std::unexpected(Err::Denied);
}
int main() {
    auto r = get(false);
    if (!r) std::cout << (int)r.error() << "\n";
}

No se necesitan excepciones

std::expected permite propagar los fallos como valores de retorno normales, lo que resulta útil cuando las excepciones están deshabilitadas o son costosas.

Nota sobre disponibilidad

std::expected es una característica de C++23; asegúrese de que su compilador y la opción del estándar (por ejemplo, -std=c++23) la admitan antes de usarla.

Comprobación rápida

Compruebe su comprensión de std::expected.

Resumen

Ha aprendido sobre std::expected:

Contiene un valor (T) o un error (E).
Devuelva el éxito directamente y los errores mediante std::unexpected.
Lea el valor con */value() y el error con error().
Incluye el motivo del fallo, a diferencia de optional.

Preguntas frecuentes

¿La lección «Conceptos básicos de std::expected» es gratis?

Sí — el texto completo de «Conceptos básicos de std::expected» 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 «Conceptos básicos de std::expected»?

Devuelva valores o errores 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 3 de 4.

¿Cuánto tiempo toma la lección «Conceptos básicos de std::expected»?

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