Bagaimana cara membuat variabel loop for const dengan pengecualian pernyataan kenaikan?

Dari c++20, Anda dapat menggunakan ranges::views::iota seperti ini:

for (int const i : std::views::iota(0, 10))
{
   std::cout << i << " ";  // ok
   i = 42;                 // error
}

Berikut demo.

Dari c++11, Anda juga dapat menggunakan teknik berikut, yang menggunakan IIILE (ekspresi lambda inline yang segera dipanggil):

int x = 0;
for (int i = 0; i < 10; ++i) [&,i] {
    std::cout << i << " ";  // ok, i is readable
    i = 42;                 // error, i is captured by non-mutable copy
    x++;                    // ok, x is captured by mutable reference
}();     // IIILE

Berikut demo.

Perhatikan bahwa [&,i] berarti i ditangkap oleh salinan yang tidak dapat diubah, dan segala sesuatu yang lain ditangkap oleh referensi yang dapat diubah. Tanda (); di akhir perulangan berarti lambda segera dipanggil.

Bagi siapa pun yang menyukai jawaban std::views::iota Cigien tetapi tidak bekerja di C++20 atau lebih tinggi, cukup mudah untuk mengimplementasikan versi sederhana dan ringan dari kelas std::views::iota ="post-tag" title="tampilkan pertanyaan yang diberi tag 'c++11'" rel="tag">c++11 atau lebih tinggi.

Yang diperlukan hanyalah:

• Tipe dasar LegacyInputIterator (sesuatu yang mendefinisikan operator++ dan operator*) yang membungkus nilai integral (misalnya int)
• Beberapa kelas seperti rentang yang memiliki begin() dan end() yang mengembalikan iterator di atas. Ini akan memungkinkannya bekerja dalam loop for berbasis rentang

Versi sederhananya bisa berupa:

#include <iterator>

// This is just a class that wraps an 'int' in an iterator abstraction
// Comparisons compare the underlying value, and 'operator++' just
// increments the underlying int
class counting_iterator
{
public:
    // basic iterator boilerplate
    using iterator_category = std::input_iterator_tag;
    using value_type = int;
    using reference  = int;
    using pointer    = int*;
    using difference_type = std::ptrdiff_t;

    // Constructor / assignment
    constexpr explicit counting_iterator(int x) : m_value{x}{}
    constexpr counting_iterator(const counting_iterator&) = default;
    constexpr counting_iterator& operator=(const counting_iterator&) = default;

    // "Dereference" (just returns the underlying value)
    constexpr reference operator*() const { return m_value; }
    constexpr pointer operator->() const { return &m_value; }

    // Advancing iterator (just increments the value)
    constexpr counting_iterator& operator++() {
        m_value++;
        return (*this);
    }
    constexpr counting_iterator operator++(int) {
        const auto copy = (*this);
        ++(*this);
        return copy;
    }

    // Comparison
    constexpr bool operator==(const counting_iterator& other) const noexcept {
        return m_value == other.m_value;
    }
    constexpr bool operator!=(const counting_iterator& other) const noexcept {
        return m_value != other.m_value;
    }
private:
    int m_value;
};

// Just a holder type that defines 'begin' and 'end' for
// range-based iteration. This holds the first and last element
// (start and end of the range)
// The begin iterator is made from the first value, and the
// end iterator is made from the second value.
struct iota_range
{
    int first;
    int last;
    constexpr counting_iterator begin() const { return counting_iterator{first}; }
    constexpr counting_iterator end() const { return counting_iterator{last}; }
};

// A simple helper function to return the range
// This function isn't strictly necessary, you could just construct
// the 'iota_range' directly
constexpr iota_range iota(int first, int last)
{
    return iota_range{first, last};
}

Saya telah mendefinisikan hal di atas dengan constexpr jika didukung, tetapi untuk versi C++ sebelumnya seperti C++11/14, Anda mungkin perlu menghapus constexpr jika versi tersebut tidak sah untuk melakukannya.

Boilerplate di atas memungkinkan kode berikut berfungsi di pra-C++20:

for (int const i : iota(0, 10))
{
   std::cout << i << " ";  // ok
   i = 42;                 // error
}

Yang akan menghasilkan perakitan yang sama dengan solusi C++20 std::views::iota dan solusi for-loop klasik ketika dioptimalkan.

Ini berfungsi dengan semua kompiler yang mendukung C++11 (misalnya kompiler seperti gcc-4.9.4) dan masih menghasilkan perakitan yang hampir identik ke rekanan for-loop dasar.

Catatan: Fungsi pembantu iota hanya untuk paritas fitur dengan solusi C++20 std::views::iota; namun secara realistis, Anda juga dapat langsung membuat iota_range{...} alih-alih memanggil iota(...). Yang pertama hanya menyajikan jalur peningkatan yang mudah jika pengguna ingin beralih ke C++20 di masa mendatang.

Versi CIUMAN...

for (int _i = 0; _i < 10; ++_i) {
    const int i = _i;

    // use i here
}

Jika kasus penggunaan Anda hanya untuk mencegah modifikasi indeks loop yang tidak disengaja, maka ini akan membuat bug tersebut terlihat jelas. (Jika Anda ingin mencegah modifikasi yang disengaja, semoga berhasil...)

Tidak bisakah Anda memindahkan sebagian atau seluruh konten perulangan for Anda ke dalam fungsi yang menerima i sebagai konstanta?

Ini kurang optimal dibandingkan beberapa solusi yang diusulkan, namun jika memungkinkan hal ini cukup mudah dilakukan.

Sunting: Sekadar contoh karena saya cenderung tidak jelas.

for (int i = 0; i < 10; ++i) 
{
   looper( i );
}

void looper ( const int v )
{
    // do your thing here
}

Jika Anda tidak memiliki akses ke c ++20, perubahan tipikal menggunakan suatu fungsi

#include <vector>
#include <numeric> // std::iota

std::vector<int> makeRange(const int start, const int end) noexcept
{
   std::vector<int> vecRange(end - start);
   std::iota(vecRange.begin(), vecRange.end(), start);
   return vecRange;
}

sekarang kamu bisa

for (const int i : makeRange(0, 10))
{
   std::cout << i << " ";  // ok
   //i = 100;              // error
}

(Lihat Demo)

Pembaruan: Terinspirasi dari komentar @Human-Compiler, saya bertanya-tanya apakah jawaban yang diberikan memiliki perbedaan dalam hal kinerja. Ternyata, kecuali pendekatan ini, secara mengejutkan semua pendekatan lainnya memiliki kinerja yang sama (untuk rentang [0, 10)). Pendekatan std::vector adalah yang terburuk.

(Lihat Quick-Bench Online)

Dan ini adalah versi C++11:

for (int const i : {0,1,2,3,4,5,6,7,8,9,10})
{
    std::cout << i << " ";
    // i = 42; // error
}

Berikut adalah demo langsung

#include <cstdio>
  
#define protect(var) \
  auto &var ## _ref = var; \
  const auto &var = var ## _ref

int main()
{
  for (int i = 0; i < 10; ++i) 
  {
    {
      protect(i);
      // do something with i
      //
      printf("%d\n", i);
      i = 42; // error!! remove this and it compiles.
    }
  }
}

Catatan: kita perlu menyarangkan ruang lingkup karena kebodohan yang menakjubkan dalam bahasa ini: variabel yang dideklarasikan di header for(...) dianggap berada pada level bersarang yang sama dengan variabel yang dideklarasikan dalam pernyataan gabungan {...}. Artinya, misalnya:

for (int i = ...)
{
  int i = 42; // error: i redeclared in same scope
}

Apa? Bukankah kita baru saja membuka kurung kurawal? Selain itu, ini tidak konsisten:

void fun(int i)
{
  int i = 42; // OK
}

Salah satu pendekatan sederhana yang belum disebutkan di sini yang berfungsi di versi C++ mana pun adalah membuat pembungkus fungsional di sekitar suatu rentang, mirip dengan apa yang std::for_each lakukan pada iterator. Pengguna kemudian bertanggung jawab untuk meneruskan argumen fungsional sebagai panggilan balik yang akan dipanggil pada setiap iterasi.

Misalnya:

// A struct that holds the start and end value of the range
struct numeric_range
{
    int start;
    int end;

    // A simple function that wraps the 'for loop' and calls the function back
    template <typename Fn>
    void for_each(const Fn& fn) const {
        for (auto i = start; i < end; ++i) {
            const auto& const_i = i;
            fn(const_i);
        }
    }
};

Dimana kegunaannya adalah:

numeric_range{0, 10}.for_each([](const auto& i){
   std::cout << i << " ";  // ok
   //i = 100;              // error
});

Apa pun yang lebih tua dari C++11 akan terjebak meneruskan penunjuk fungsi yang diberi nama kuat ke for_each (mirip dengan std::for_each), tetapi masih berfungsi.

Berikut demo

Meskipun ini mungkin bukan idiomatis untuk for loop di C++, pendekatan ini cukup umum di bahasa lain. Pembungkus fungsional sangat ramping karena komposisinya dalam pernyataan yang kompleks dan bisa sangat ergonomis untuk digunakan.

Kode ini juga mudah untuk ditulis, dipahami, dan dipelihara.

template<class T = int, class F>
void while_less(T n, F f, T start = 0){
    for(; start < n; ++start)
        f(start);
}

int main()
{
    int s = 0;
    
    while_less(10, [&](auto i){
        s += i;
    });
    
    assert(s == 45);
}

mungkin menyebutnya for_i

Tanpa biaya tambahan https://godbolt.org/z/e7asGj