Início / coding / Perguntas / 79262104
Accepted
Blabba
Asked: 2024-12-08 16:40:22 +0800 CST

se constexpr para inicializar uma referência const

  • 772

Tenho uma operação cara que quero chamar condicionalmente dependendo do tipo de template. A função ingênua se parece basicamente com isso.

template <typename T>
void FooNaive( const std::vector<ExpensiveStruct<T>>& vec )
{
    std::vector<ExpensiveStruct<float>> vecAsFloat;
    if constexpr ( std::is_same_v<T, float> )
        vecAsFloat = vec;   // expensive copy I want to avoid
    else
    {
        vecAsFloat.reserve( vec.size() );
        for ( const auto& s : vec )
            vecAsFloat.push_back( ConvertExpensiveStruct( s ) );   // <-- does not compile for floats
    }

    // ...use vecAsFloat...
}

Para evitar a cópia cara do primeiro branch, tentei fazer vecAsFloatuma referência const. No entanto, devido a ConvertExpensiveStructnão compilar para floattipos (segundo branch), ainda preciso de um if constexprin ali.

Esta é minha tentativa atual:

template <typename T>
void FooAttempt( const std::vector<ExpensiveStruct<T>>& vec )
{
    std::vector<ExpensiveStruct<float>> dummyVecAsFloat;
    if constexpr ( !std::is_same_v<T, float> )
    {
        dummyVecAsFloat.reserve( vec.size() );
        for ( const auto& s : vec )
            dummyVecAsFloat.push_back( ConvertExpensiveStruct( s ) );
    }
    const std::vector<ExpensiveStruct<float>>& vecAsFloat = std::is_same_v<T, float> ? vec : dummyVecAsFloat;

    // use vecAsFloat...
}

Também pensei em colocar o loop de conversão em um lambda para ser chamado no local dentro do operador ternário, mas isso significaria que ele teria que retornar uma referência const para sua variável local (estende o tempo de vida, mas ainda é feio) ou, na pior das hipóteses, retornar uma cópia por valor (lambdas têm NRVO?).

Mas parece muito complicado. Existe uma maneira de escrever isso de forma mais simples, ou pelo menos com intenção mais clara?

c++

2 respostas

  1. Best Answer

    Você pode extrair tudo o que fizer // use vecAsFloat...em uma função separada e usá-la if constexprpara criar um temporário std::vector<ExpensiveStruct<float>>somente se necessário:

    void FooAsFloat(const std::vector<ExpensiveStruct<float>>& vecAsFloat) {
    // use vecAsFloat...
}

template <typename T>
void Foo(const std::vector<ExpensiveStruct<T>>& vec)
{
    if constexpr (std::is_same_v<T, float>) {
        FooAsFloat(vec);  // no copy needed
    }
    else {
        std::vector<ExpensiveStruct<float>> vecAsFloat;
        vecAsFloat.reserve(vec.size());
        for (const auto& s : vec) {
            vecAsFloat.push_back(ConvertExpensiveStruct(s));
        }
        FooAsFloat(vecAsFloat); // call with copy
    }
}

    Como @Jarod42 comentou abaixo , você pode até evitar a extração para outra função:
    faça o processamento principal na ifparte e use uma chamada recursiva para a elseparte depois de criar o necessário std::vector<ExpensiveStruct<float>>:

    template <typename T>
void Foo(const std::vector<ExpensiveStruct<T>>& vec)
{
    if constexpr (std::is_same_v<T, float>) {
        // use vec (it contains `ExpensiveStruct<float>` elements as needed) 
        // ...
    }
    else {
        std::vector<ExpensiveStruct<float>> vecAsFloat;
        vecAsFloat.reserve(vec.size());
        for (const auto& s : vec) {
            vecAsFloat.push_back(ConvertExpensiveStruct(s));
        }
        // Recursive call with `vecAsFloat`
        // (when executed it will get into the main `if constexpr` part to be used):
        Foo(vecAsFloat);
    }
}
    • 1

  2. Mais simples do que você pensa:

    template <typename T>
void FooAttempt( const std::vector<ExpensiveStruct<T>>& vec ) {
    auto const& vecAsFloat = [&vec]()
    ->decltype(auto)/*relax reference qualifications*/{
        if constexpr ( !std::is_same_v<T, float> ) /* return reference */
            return std::forward<decltype(vec)>(vec);
        else /* return value with direct  initialization. */
            return vec 
                 | std::views::transform 
                      ( [](auto&& s){return ConvertExpensiveStruct(s);} )
                 | std::ranges::to<std::vector>();
    }(/*vecAsFloat = IILE*/);

    /* use(data(vecAsFloat), size(vecAsFloat));
    ** use essentially an 'extern "C"' API, 
    ** OR a 3rd party binary library.*/
};

    Mas se vecAsFloatnão precisa ser armazenado como um vetor e só é usado (irreportado) uma vez, é ainda mais eficiente descartar a conversão de vetor e manter apenas uma visualização:

    template <typename T>
void FooAttempt( std::span<const ExpensiveStruct<T>> vec ) {
    auto const vecAsFloat = [vec]{
        if constexpr ( !std::is_same_v<T, float> )
            return vec;
        else
            return vec 
                 | std::views::transform 
                      ( [](auto&& s){return ConvertExpensiveStruct(s);} );
    }(/*vecAsFloat = IILE*/);

    /* Iterate over vecAsFloat, only once.
    ** 'use' is a user defined algorithm,
    ** expecting a range of `float` values */ 
};

    Observe o uso de std::spanno segundo snippet. É mais genérico caso você decida usar a std::arrayem vez de std::vectorat call sight. Ele também reflete sua intenção de não inserir ou remover nenhum elemento.

    • 1

relate perguntas