Início / coding / Perguntas / 79040286
Accepted
intelfx
Asked: 2024-10-01 00:44:31 +0800 CST

Como reutilizo uma instância `std::generator` do C++23 como um intervalo em múltiplas expressões de intervalo?

  • 772

Estou tentando aprender intervalos em C++. Até onde posso ver, a maneira mais simples (e a única, além de implementar uma classe de visualização de intervalo personalizada) de criar um objeto de visualização de intervalo que gere uma sequência personalizada é usar C++23' std::generator<>:

std::generator<char> letters_gen(char start)
{
    for (;;) co_yield start++;
}

Como eu uso um std::generatorobjeto (como criado ao invocar letters_gen()) em múltiplas expressões envolvendo operações de intervalo? Por exemplo, se eu quiser coletar 10 letras em um vetor e, então, mais 15 letras em outro vetor:

int main()
{
    auto letters = letters_gen('a');
    auto x = letters | std::views::take(10) | std::ranges::to<std::vector>();
    auto y = letters | std::views::take(15) | std::ranges::to<std::vector>();
}

Isto não compila:

main.cc:150:26: error: no match for ‘operator|’ (operand types are ‘std::generator<char>’ and ‘std::ranges::views::__adaptor::_Partial<std::ranges::views::_Take, int>’)

Qual é a maneira correta, se houver, de obter o efeito desejado?

c++

2 respostas

  1. Best Answer

    Você não.

    A generatoré um intervalo de entrada, você só pode usá-lo uma vez. Uma das maneiras que a biblioteca busca evitar o uso indevido é torná-lo somente para movimentação em vez de copiável - daí a reclamação sobre tentar copiá-lo (erros de compilação de intervalos são notoriamente inúteis). É um comportamento indefinido até mesmo chamar begin()duas vezes no intervalo.

    Não há realmente uma boa maneira de fazer isso dentro da biblioteca, eu acho. Você pode tentar contornar o problema de cópia fazendo algo assim (o que adicionalmente garante que ambos os algoritmos usem o mesmo gerador):

    auto x = ranges::ref_view(letters) | views::take(10) | ranges::to<vector>();
auto y = ranges::ref_view(letters) | views::take(15) | ranges::to<vector>();

    Esse é um comportamento indefinido, mas mesmo deixando isso de lado, você obterá um resultado surpreendente que xcontém as letras de athru jconforme desejado, mas ycontém lthru zem vez de kthru ydevido à maneira como takeinterage com os intervalos de entrada (veja minha palestra sobre CppNow ).

    Você teria que escrever algo mais à mão:

    // we have to use iterators and preserve them
auto it = letters.begin();

std::vector<char> x;
for (size_t count = 0; count < 10 && it != letters.end(); ++it, ++count) {
    x.push_back(*it);
}

std::vector<char> y;
for (size_t count = 0; count < 15 && it != letters.end(); ++it, ++count) {
    y.push_back(*it);
}
    • 9

  2. À excelente resposta de Barry, gostaria de acrescentar o seguinte. Nem tudo é tão pessimista. Sim, não poderemos usar views neste caso, mas podemos usar algoritmos – std::copy_n e std::ranges::copy_n:

        std::vector<char> x, y;
    auto              letters = letters_gen('a');
    std::copy_n(letters.begin(), 10, std::back_inserter(x));
    std::copy(x.begin(), x.end(), std::ostream_iterator<char>(std::cout, ", "));
    std::cout << '\n';
    std::copy_n(letters.begin(), 15, std::back_inserter(y));
    std::copy(y.begin(), y.end(), std::ostream_iterator<char>(std::cout, ", "));

    ou:

        std::vector<char> x, y;
    auto              letters = letters_gen('a');
    auto              res     = std::ranges::copy_n(letters.begin(), 10, std::back_inserter(x));
    std::ranges::copy(x, std::ostream_iterator<char>(std::cout, ", "));
    std::cout << '\n';
    std::ranges::copy_n(res.in, 15, std::back_inserter(y));
    std::ranges::copy(y, std::ostream_iterator<char>(std::cout, ", "));
    • 1

relate perguntas