Início / coding / Perguntas / 77053859
Accepted
Slava
Asked: 2023-09-07 00:40:40 +0800 CST

Por que preciso de um const lambda ao chamar std::partition

  • 772

Eu tenho esta função que usa std::partition para dividir um contêiner em dois com base em um predicado.

template<class Container, class Predicate>
void split_partition(Container& src, Container& dest, Predicate p)
{

    auto ends = std::partition_copy(
        std::make_move_iterator( src.begin() ), std::make_move_iterator( src.end() ),
        src.begin(), std::back_inserter(dest), p
    ); 

    src.erase(ends.first, src.end());

}

Eu tentei ligar com

split_partition(a, b, [](auto& t) {return t.i > 4; });

mas nem compilou, agora se usar const funciona.

split_partition(a, b, [](const auto& t) {return t.i > 4; });

Por que é que?

Editar:

std::vector<Thing> a = { {0, "foo"}, {1, "bar"}, {5, "what"}, {8, "yo"}, {2, ""} };
std::vector<Thing> b;
c++

1 respostas

  1. Best Answer

    Você está pagando std::partitioncom um range movido:

    std::make_move_iterator( src.begin() ), std::make_move_iterator( src.end() )

    Isso significa que o lambda que você possui será invocado com algum Object&&ou const Object&&. const auto&pode vincular-se a ele em ambos os casos. const auto&é universal no sentido de que pode ser vinculado a qualquer categoria de valor (lvalue, xvalue, prvalue).

    Por exemplo:

    #include <utility>

// Calls to opaque copy constructor should be visible in ASM.
// This would let us spot accidental copies/moves, if they took place.
struct S { S(const S&); };

void test(const S x, S y) {
    const auto& r0 = x;            // bind to lvalue const S
    const auto& r1 = std::move(x); // bind to xvalue const S
    const auto& r2 = y;            // bind to lvalue S
    const auto& r3 = std::move(y); // bind to xvalue S
}

    Este código é compilado para

    test(S, S):
        ret

    Isso significa que nenhum construtor Sfoi chamado, const&simplesmente se liga a qualquer coisa. Como você está usando std::move_iterator(o que é inútil para fins de comparação), seu caso é r1or r3.

    auto&não é tão poderoso: uma referência não-const lvalue não pode ser vinculada a um const xvalue. Isso seria r3, e esse é o caso que você está enfrentando.

    Caso contrário [se a referência não estiver vinculada a um lvalue do mesmo/a um tipo compatível], se a referência for uma referência lvalue a um tipo que não seja const-qualificado ou volátil-qualificado , o programa estará mal formado .

    - [dcl.init.ref] p5.2

    Solução

    Basta aceitar const auto&em seu lambda. É mais correto, pois você está apenas comparando elementos sem modificá-los.

    • 2

relate perguntas