constexpr di untuk-Pernyataan

Apakah ada cara untuk menggunakan ini dalam pernyataan for juga? Untuk membuka gulungan loop pada waktu kompilasi? Saya ingin bisa melakukan hal seperti ini

Saya tidak berpikir dengan cara yang sederhana.

Tetapi jika Anda mampu membeli fungsi pembantu, dengan std::integer_sequence dan inisialisasi array bilangan bulat gaya C yang tidak terpakai, mulai dari C++14 Anda dapat melakukan sesuatu sebagai berikut

#include <utility>
#include <iostream>

template <int ... Is>
void foo_helper (std::integer_sequence<int, Is...> const &)
 {
   using unused = int[];

   (void)unused { 0, (std::cout << Is << std::endl, 0)... };
 }

template <int T>
void foo ()
 { foo_helper(std::make_integer_sequence<int, T>{}); }

int main ()
 {
   foo<42>();
 }

Jika Anda dapat menggunakan C++17, Anda dapat menghindari array unused dan, dengan menggunakan pelipatan, foo_helper() dapat ditulis sebagai berikut

template <int ... Is>
void foo_helper (std::integer_sequence<int, Is...> const &)
 { ((std::cout << Is << std::endl), ...); }

Jika batas perulangan diketahui oleh kompiler, kompiler akan membuka gulungan perulangan, jika dirasa bermanfaat. Tidak semua pembukaan gulungan bermanfaat! Dan sepertinya Anda tidak akan membuat keputusan yang lebih baik daripada kompiler mengenai manfaat pembukaan loop.

Tidak diperlukan constexpr for (seperti yang Anda katakan), karena constexpr if mengaktifkan fitur - Anda dapat memasukkan kode yang akan membuat program salah bentuk di dalam constexpr if cabang palsu - ini bukan optimasi murni.

Constexpr for, di sisi lain, akan menjadi optimasi murni (setidaknya seperti yang Anda gambarkan, tidak termasuk kasus pinggiran loop yang dieksekusi 0 kali) dan oleh karena itu lebih baik diserahkan pada aturan optimasi 'seolah-olah'.

Bukan tanpa kode pembantu.

#define RETURNS(...) \
  noexcept(noexcept(__VA_ARGS__)) \
  -> decltype(__VA_ARGS__) \
  { return __VA_ARGS__; }

template<std::size_t I>
using index_t = std::integral_constant<std::size_t, I>;

template<std::size_t...Is>
constexpr auto index_over( std::index_sequence<Is...> ) noexcept(true) {
  return [](auto&& f)
    RETURNS( decltype(f)(f)( index_t<Is>{}... ) );
}
template<std::size_t N>
constexpr auto index_upto( index_t<N> ={} ) noexcept(true) {
  return index_over( std::make_index_sequence<N>{} );
}

template<class F>
constexpr auto foreacher( F&& f ) {
  return [&f](auto&&...args) noexcept( noexcept(f(args))&&... ) {
    ((void)(f(args)),...);
  };
}

itu pipa ledeng kami.

template<int T>
void foo() {
  index_upto<T>()(
    foreacher([](auto I){
      std::cout << I << "\n";
    })
  );
}

loop waktu kompilasi dengan nilai pada setiap langkah.

Atau kita dapat menyembunyikan detailnya:

template<std::size_t start, std::size_t length, std::size_t step=1, class F>
constexpr void for_each( F&& f, index_t<start> ={}, index_t<length> ={}, index_t<step> ={} ) {
  index_upto<length/step>()(
    foreacher([&](auto I){
      f( index_t<(I*step)+start>{} );
    })
  );
}

maka kita akan mendapatkan:

for_each<0, T>([](auto I) {
  std::cout << I << "\n";
});

or

for_each([](auto I) {
  std::cout << I << "\n";
}, index_t<0>{}, index_t<T>{});

ini dapat ditingkatkan lebih lanjut dengan literal yang ditentukan pengguna dan variabel templat:

template<std::size_t I>
constexpr index_t<I> index{};

template<char...cs>
constexpr auto operator""_idx() {
  return index< parse_value(cs...) >;
}

di mana parse_value adalah fungsi constexpr yang mengambil urutan char... dan menghasilkan representasi bilangan bulat tak bertanda tangan.