Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::optional::operator bool — verificar se existe um valor

`if (opt)` verifica se um `std::optional` contém um valor, não se esse valor é verdadeiro. Tanto o índice `0` como o valor booleano `false` contam como presentes.

Versão: ISO C++23; implementation support may vary

Sintaxe

#include <optional>

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

std::optional::operator bool é uma função-membro de conversão explícita de std::optional<T>, do cabeçalho <optional>. Tal como opt.has_value(), devolve true se e só se opt contiver um valor. Ambas as funções estão disponíveis desde C++17, podem ser chamadas em objetos const, não lançam exceções (noexcept) e podem ser usadas em expressões constantes (constexpr) quando o contexto o permite.

explicit não impede a conversão contextual para bool, pelo que if (opt) e !opt são válidos. Já a inicialização por cópia bool present = opt; é inválida. Para guardar o resultado, usa bool present = opt.has_value(); ou bool present = static_cast<bool>(opt);.

Distingue a presença do conteúdo. std::optional<int>{0} pode conter um índice válido numa numeração que começa em zero, e std::optional<bool>{false} contém false. Em ambos os casos, o teste de presença devolve true. Para verificar se um indicador está presente e é verdadeiro, usa if (flag && *flag). O operador incorporado && só avalia o operando da direita se o da esquerda for verdadeiro.

Usa *opt ou opt->member apenas enquanto opt contiver um valor. Em C++23, aceder desta forma a um optional vazio tem comportamento indefinido; já opt.value() verifica se existe um valor e, se não existir, lança a exceção std::bad_optional_access. O teste de presença não prolonga o tempo de vida do valor contido: por exemplo, reset() destrói-o e invalida as referências a esse valor.

Exemplos

#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

A saída distingue o índice `0` de um índice ausente. O ramo de `if (flag)` é executado apesar de o valor lido através de `*flag` ser `false`.

Lições relacionadas

  • C++ · Lição 48 · Avançado · Versão: 3
  • C++ · Lição 51 · Avançado · Versão: 3

Fontes