std::variant proporciona las siguientes funciones de acceso:

std::get_if: tomarpuntero avariant, regresopuntero a la alternativa

template <std::size_t I, typename... Ts> 
auto* std::get_if(std::variant<Ts...>* pv) noexcept;

Sipv no es un puntero nulo ypv->index() == I, devuelve un puntero al valor almacenado en la variante apuntada porpv. De lo contrario, devuelve un valor de puntero nulo.

Esto significa queget_ifLa implementación de más o menos se ve así:

template <std::size_t I, typename... Ts> 
auto* std::get_if(std::variant<Ts...>* pv) noexcept
{
    if(pv == nullptr) return nullptr;
    if(pv->index() != I) return nullptr;
    return &(pv->real_get<I>());
}

std::get: tomarreferencia avariant, regresoreferencia a la alternativa,throw en acceso inválido.

template <std::size_t I, typename... Ts>
auto& std::get(std::variant<Ts...>& v);

Siv.index() == I, devuelve una referencia al valor almacenado env. De lo contrario, lanzastd::bad_variant_access.

Esto significa quegetLa implementación de más o menos se ve así:

template <std::size_t I, typename... Ts> 
auto& std::get(std::variant<Ts...>& v)
{
    if(v.index() != I) throw std::bad_variant_access{};
    return v.real_get<I>();
}

Quiero una función de acceso inseguro que:

Esnoexcept.

Toma unareferencia a unvariant, evitando cualquierpv == nullptr cheque.

Tienecomportamiento indefinido Siv.index() != I.

¿Por qué? Porque puede haber algunas situaciones en las que estoy 100% seguro de que un particularvariant La instancia contiene un tipo específico en una ruta de código. Además, sería útil al escribir código genérico que ya se verificó por separadov.index() != I (por ejemplo, escribir el míovisit).

Implementación de ejemplo:

template <std::size_t I, typename... Ts> 
auto& unsafe_get(std::variant<Ts...>& v)
{
    return v.real_get<I>();
}

¿Hay algo como esto en el estándar? No pude encontrarlo. Si no,¿Es esto posible implementar parastd::varianto necesito implementar mi propiovariant ¿implementación?