Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::optional::operator bool — comprobar si hay un valor

`if (opt)` comprueba si un `std::optional` contiene un valor, no si ese valor es verdadero. Tanto el índice `0` como el indicador `false` cuentan como valores presentes.

Versión: ISO C++23; implementation support may vary

Sintaxis

#include <optional>

// Members of std::optional<T>:
constexpr explicit operator bool() const noexcept;
constexpr bool has_value() const noexcept;

std::optional::operator bool es una función miembro de conversión explícita de std::optional<T>, en la cabecera <optional>. Al igual que opt.has_value(), devuelve true si y solo si opt contiene un valor. Ambas funciones están disponibles desde C++17, se pueden llamar sobre objetos const, no lanzan excepciones (noexcept) y se pueden usar en expresiones constantes (constexpr) cuando el contexto lo permite.

explicit no impide la conversión contextual a bool, de modo que if (opt) y !opt son válidos. En cambio, la inicialización por copia bool present = opt; no es válida. Para guardar el resultado, usa bool present = opt.has_value(); o bool present = static_cast<bool>(opt);.

Distingue la presencia del contenido. std::optional<int>{0} puede contener un índice válido en una numeración que empieza en cero, y std::optional<bool>{false} contiene false. En ambos casos, la comprobación de presencia da true. Para comprobar que un indicador está presente y es verdadero, usa if (flag && *flag). El operador incorporado && solo evalúa el operando derecho si el izquierdo es verdadero.

Usa *opt u opt->member solo mientras opt siga conteniendo un valor. En C++23, acceder así a un optional vacío tiene comportamiento indefinido; en cambio, opt.value() lanza std::bad_optional_access. Comprobar la presencia no prolonga el tiempo de vida del valor contenido: por ejemplo, reset() lo destruye e invalida las referencias a él.

Ejemplos

#include <iostream>
#include <optional>

int main() {
    const std::optional<int> index{0};
    const std::optional<int> missing;
    const std::optional<bool> flag{false};

    if (index) {
        std::cout << "index: " << *index << '\n';
    }
    if (!missing) {
        std::cout << "index missing\n";
    }
    if (flag) {
        std::cout << "stored flag: " << std::boolalpha << *flag << '\n';
    }
}

Resultado

index: 0
index missing
stored flag: false

La salida distingue el índice `0` de un índice ausente. Se ejecuta la rama de `if (flag)` aunque el valor leído mediante `*flag` sea `false`.

Lecciones relacionadas

  • C++ · Lección 48 · Avanzado · Versión: 3
  • C++ · Lección 51 · Avanzado · Versión: 3

Fuentes