Início / coding / Perguntas / 79551683
Accepted
gimbup
Asked: 2025-04-03 06:21:29 +0800 CST

Converter um std::variant<std::monostate, T...> para std::variant<T...>

  • 772

Tenho um objeto do tipo std::variant<std::monostate, T...>, mas preciso chamar uma função que aceita somente std::variant<T...>.

Existe alguma maneira de converter a std::variant<std::monostate, T...>para std::variant<T...>se eu tiver certeza de que não é um std::monostate?

c++

1 respostas

  1. Best Answer

    Você pode usar std::visit(), você só precisa lidar com o caso em que é std::monostate, você pode lançar uma exceção por enquanto, ou em C++23 usar std::unreachable:

    std::variant<std::monostate, std::string, int> monostate_variant = 2;

std::variant<std::string, int> variant2 = std::visit(
    overloads{
        [](std::monostate) ->std::variant<std::string, int> 
        { throw std::runtime_error("actually a monostate"); },
        [](auto&& obj) -> std::variant<std::string, int> 
        { return std::move(obj);}
    },
    std::move(monostate_variant)
);

    A implementação overloadsé da std::visit()página cppreference .

    Para o caso simples que std::monostateé o primeiro parâmetro, você pode usar este modelo:

    template <typename...Ts>
auto remove_monostate(std::variant<std::monostate, Ts...> var)
{
    return std::visit(
    overloads{
        [](std::monostate) ->std::variant<Ts...>
        { throw std::runtime_error("actually a monostate"); },
        [](auto&& obj) -> std::variant<Ts...>
        { return std::move(obj);}
    },
    std::move(var)
    );
}

auto variant_without_monostate = remove_monostate(std::move(monostate_variant));

    Demonstração on-line

    E, se os tipos não estiverem na mesma ordem, você pode modificar o modelo e passar o tipo de variante necessário como um parâmetro de modelo e usá-lo como um tipo de retorno para as lambdas.

    Versão de encaminhamento perfeito do C++20 (1 movimento a menos)

    template <typename...Ts>
auto remove_monostate_helper(std::variant<std::monostate, Ts...>) -> std::variant<Ts...>;

template <typename T>
auto remove_monostate(T&& var)
{
    using return_type = decltype(remove_monostate_helper(var));
    return std::visit(
    overloads{
        [](std::monostate) -> return_type
        { throw std::runtime_error("actually a monostate"); },
        []<typename U>(U&& obj) -> return_type
        { return std::forward<U>(obj);}
    },
    std::forward<T>(var)
    );
}
    • 5

relate perguntas