std::variant<Types...>::valueless_by_exception

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Macros de prueba de característica de la biblioteca (C++20) Servicios de programa Funciones variádicas initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Apoyo de corrutinas (C++20) Apoyo de contratos (C++26) Comparación de tres vías (C++20) three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits (C++20) bitset hash (C++11) Operadores relacionales (en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::variant

Funciones miembro

variant::variant

variant::~variant

variant::operator=

Observadores

variant::index

variant::valueless_by_exception

Modificadores

variant::emplace

variant::swap

Funciones no miembro

visit

holds_alternative

get

get_if

operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)

swap

Clases auxiliares

monostate

bad_variant_access

variant_size

variant_alternative

hash

Objetos auxiliares

variant_npos

 

constexpr bool valueless_by_exception() const noexcept;		(desde C++17)

Devuelve false si y solo si el variante mantiene un valor.

Notas

Un variante puede quedarse sin valor en las siguientes situaciones:

• (garantizado) se lanza una excepción durante la inicialización por movimiento del valor contenido a partir del temporal en la asignación de copia;
• (garantizado) se lanza una excepción durante la inicialización por movimiento del valor contenido durante la asignación de movimiento;
• (opcionalmente) se lanza una excepción al inicializar el valor contenido durante una asignación que puede cambiar el tipo;
• (opcionalmente) se lanza una excepción al inicializar el valor contenido durante un emplazamiento (emplace) que puede cambiar el tipo.

Ya que nunca se permite que un variante asigne memoria dinámica, el valor previo no puede retenerse en estas situaciones.

Esto se aplica incluso a variantes de tipos no-clase:

struct S {
    operator int() { throw 42; }
};
std::variant<float, int> v{12.f}; // de acuerdo
v.emplace<1>(S()); // puede ser que v no tenga un valor

Un variante que se encuentra sin valor debido a una excepción se trata como si estuviera en un estado inválido: index devuelve variant_npos, get y visit lanzan bad_variant_access.

Ejemplo

Ejecuta este código

#include <cassert>
#include <iostream>
#include <stdexcept>
#include <string>
#include <variant>

struct Demo {
    Demo(int) {}
    Demo(const Demo&) { throw std::domain_error("ctor de copia"); }
    Demo& operator= (const Demo&) = default;
};

int main()
{
    std::variant<std::string, Demo> var{"cadena"};
    assert(var.index() == 0);
    assert(std::get<0>(var) == "cadena");
    assert(var.valueless_by_exception() == false);

    try {
        var = Demo{123};
    } catch (const std::domain_error& ex) {
        std::cout << "1) Excepción: " << ex.what() << '\n';
    }
    assert(var.index() == std::variant_npos);
    assert(var.valueless_by_exception() == true);

    // Ahora var se encuentra "sin valor", que es un estado inválido causado
    // por una excepción que se generó en el proceso de la inicialización de var

    try {
        std::get<1>(var);
    } catch (const std::bad_variant_access& ex) {
        std::cout << "2) Excepción: " << ex.what() << '\n';
    }

    var = "cadena2";
    assert(var.index() == 0);
    assert(std::get<0>(var) == "cadena2");
    assert(var.valueless_by_exception() == false);
}

Posible salida:

1) Excepción: ctor de copia
2) Excepción: std::get: variante no tiene valor

Véase también

std::get(std::variant) (C++17)	Lee el valor del variante dado el subíndice o el tipo (si el tipo es único), lanza una excepción si existe un error. (plantilla de función)
index	Devuelve el subíndice de base cero de la alternativa mantenida por el variante. (función miembro pública)
bad_variant_access (C++17)	Excepción lanzada durante accesos inválidos al valor de un variante. (clase)