Início / coding / Perguntas / 79470956
Accepted
Gashmob
Asked: 2025-02-27 04:25:01 +0800 CST

Como posso retornar diretamente o resultado de uma chamada de função retornando std::expected?

  • 772

vamos pegar este pequeno exemplo:

std::expected<std::any, Fault> doN(int n) 
{
    switch (n) 
    {
        case 1: return do1();
        case 2: return do2();
        // ...
    }
}

std::expected<int, Fault> do1()
{
    if (error)
    {
        return std::unexpected<Fault>({/* ... */});
    }
    return 23;
}

Se eu fizer dessa forma e chamar auto result = doN(1)sem erros, então result.value()o tipo é std::expected<int, Fault>e não int(sem mencionar o any_cast).

A maneira que encontrei para resolver isso é destruir o resultado da chamada interna:

std::expected<std::any, Fault> doN(int n)
{
    switch (n) 
    {
        case 1: 
            auto value = do1();
            if (value.has_value()) {
                return value.value();
            }
            return std::unexpected(value.error());
        // ...
    }
}

O tipo doN(1).value()é int.

Então minha pergunta é: Como posso simplificar isso? Existe uma maneira de retornar o resultado da chamada de função?

c++

1 respostas

  1. Best Answer

    Como posso simplificar isso? Existe uma maneira de retornar o resultado da chamada de função?

    Para simplificar sua abordagem, você pode usar std::expected::transform. Algo como:

    return do1().transform([](int value) { return std::any(value); });

    O método transform faz o seguinte:

    • Ele verifica se o std::expectedcontém um valor ( do1().has_value())
    • Se tiver um valor, ele aplica a função lambda para transformar esse valor ( std::any(value)) e retorna um novo std::expectedcom o valor transformado
    • Se houver um erro, ele simplesmente propaga esse erro sem chamar o lambda.

    Isso significa que pode ser capaz de escrever:

    // Helper function to convert any std::expected<T, Fault> to std::expected<std::any, Fault>
template<typename T>
std::expected<std::any, Fault> to_any(std::expected<T, Fault> exp) 
{
    return exp.transform([](auto value) { return std::any(value); });
}

// Function that calls the appropriate function based on input
std::expected<std::any, Fault> doN(int n) 
{
    switch (n) {
        case 1: return to_any(do1());
        case 2: return to_any(do2());
        // ...
        default: return std::unexpected<Fault>({/* some error */});
    }
}

    (( Veja o exemplo de demonstração ao vivo ))

    • 9

relate perguntas