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

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

[editar] 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.

[editar] Ejemplo

#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);
}

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

[editar] Véase también