Início / coding / Perguntas / 79076059
Accepted
kc9jud
Asked: 2024-10-11 04:23:27 +0800 CST

std::integer_sequence em um lambda antes de C++20

  • 772

Comecei a usar esse tipo de construção, que depende dos parâmetros de modelo explícitos do C++20 para lambdas:

template<typename... Ts>
struct Foo
{
  std::tuple<Ts...> bars;

  auto get_labels(const std::array<std::size_t,sizeof...(Ts)>& indices) const
  {
    // construct tuple from bar labels
    return [&]<std::size_t... Is>(std::index_sequence<Is...>) {
        return std::make_tuple(std::get<Is>(bars).get_label(indices[Is])...);
      }(std::index_sequence_for<Ts...>{});
  }
};

Exemplo do Compiler Explorer

Existe uma maneira relativamente elegante de fazer isso em C++17 ou C++14? Ou devo apenas tornar C++20 um requisito agora?

c++

4 respostas

  1. Best Answer

    Então é importante reconhecer qual parte você realmente precisa. Quando você escreve isto:

    // construct tuple from bar labels
return [&]<std::size_t... Is>(std::index_sequence<Is...>) {
    return std::make_tuple(std::get<Is>(bars).get_label(indices[Is])...);
}(std::index_sequence_for<Ts...>{});

    O que você realmente precisa é Is.... Ou, mais genericamente, o que você realmente precisa é de um pacote de valores constantes. No exemplo acima, você está aceitando um parâmetro de index_sequence<Is...>- que é um parâmetro, cujo tipo tem o pacote de valores constantes nele.

    Mas uma maneira diferente de fazer isso seria aceitar Nparâmetros diferentes, onde o primeiro parâmetro é do tipo integral_constant<size_t, 0>e o segundo parâmetro é do tipo integral_constant<size_t, 1>, e assim por diante. Se você pudesse produzir esses argumentos, então a parte lambda se tornaria

    [&](auto... Is){
    return std::make_tuple(std::get<Is>(bars).get_label(indices[Is])...);
}

    Note que o corpo é idêntico, eu apenas alterei a aparência do(s) parâmetro(s). E agora este é um lambda C++14 válido.

    Então o resto do problema é produzir o modelo de função with<N>(f), que chama f(integral_constant<size_t, 0>{}, integral_constant<size_t, 1>{},..., integral_constant<size_t, N-1>{})o que permite que você chame:

    return with<sizeof...(Ts)>([&](auto... Is){
    return std::make_tuple(std::get<Is>(bars).get_label(indices[Is])...);
})

    E escrever withem C++14 é direto. É realmente o mesmo index_sequencetruque, com uma indireção extra (porque você precisa então mudar o um index_sequencepara o N integral_constants). Indiscutivelmente, o resultado parece melhor também - é menos movimentado. Eu prefiro isso em C++20 de qualquer maneira.

    • 7

  2. Uma maneira possível é "colocar" a sequência diretamente no modelo de classe:

    template <typename Seq, typename... Ts> struct FooImpl;

template <std::size_t... Is, typename... Ts>
struct FooImpl<std::index_sequence<Is...>, Ts...>
{
  static_assert(sizeof...(Is) == sizeof...(Ts));
  std::tuple<Ts...> bars;

  auto get_labels(const std::array<std::size_t, sizeof...(Ts)>& indices) const
  {
    // construct tuple from bar labels
    return std::make_tuple(std::get<Is>(bars).get_label(indices[Is])...);
  }
};

template <typename... Ts>
using Foo = FooImpl<std::make_index_sequence<sizeof...(Ts)>, Ts...>;
    • 1

  3. Uma abordagem direta é tornar o lambda uma função membro:

    template<typename... Ts>
struct Foo
{
  std::tuple<Ts...> bars;

  template <std::size_t... Is>
  auto get_labels_(
    const std::array<std::size_t, sizeof...(Ts)>& indices,
    std::index_sequence<Is...>
  ) const
  {
    return std::make_tuple(std::get<Is>(bars).get_label(indices[Is])...);
  }

  auto get_labels(const std::array<std::size_t,sizeof...(Ts)>& indices) const
  {
    // construct tuple from bar labels
    return get_labels_(indices, std::index_sequence_for<Ts...>{});
  }
};

    Mas não tenho certeza se ele se qualifica como relativamente elegante.

    • 0

  4. Uma maneira de ignorar a falta de lambda de modelo é ter um método de modelo que retorna o lambda:

    template<typename... Ts>
struct Foo
{
    std::tuple<Ts...> bars;

    template <std::size_t... Is> 
    auto make_lambda (std::index_sequence<Is...>, const std::array<std::size_t,sizeof...(Ts)>& indices) const
    {
        return [&] (std::index_sequence<Is...>) 
        {
            return std::make_tuple(std::get<Is>(bars).get_label(indices[Is])...);
        };
    }
 
    auto get_labels (const std::array<std::size_t,sizeof...(Ts)>& indices) const
    {
        auto seq = std::index_sequence_for<Ts...>{};
        return make_lambda (seq, indices) (seq);
    }
};

    Demonstração

    Isso deve funcionar a partir do c++14.

    Nota: isso é de alguma forma similar à resposta anterior que eu não tinha visto antes de postar. Talvez ela sublinhe um pouco mais a intenção subjacente, ou seja, fazer um modelo lambda, mas é ainda menos amigável.

    Então, c++20 é uma boa ideia se você puder usá-lo em seu contexto.

    • 0

relate perguntas