วิธีสร้างตัวแปร for loop const ยกเว้นคำสั่งส่วนเพิ่ม

จาก c++20 คุณสามารถใช้ ranges::views::iota เช่น นี้:

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

นี่คือการสาธิต

จาก c++11 คุณยังสามารถใช้เทคนิคต่อไปนี้ ซึ่งใช้ IIILE (นิพจน์แลมบ์ดาอินไลน์ที่เรียกใช้ทันที):

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

นี่คือการสาธิต

โปรดทราบว่า [&,i] หมายความว่า i ถูกจับโดยสำเนาที่ไม่สามารถเปลี่ยนแปลงได้ และสิ่งอื่นๆ จะถูกบันทึกโดยการอ้างอิงที่ไม่แน่นอน (); ที่ส่วนท้ายของลูปหมายความว่าแลมบ์ดาถูกเรียกใช้ทันที

สำหรับใครก็ตามที่ชอบคำตอบ std::views::iota ของ Cigien แต่ไม่ทำงานใน C++20 หรือสูงกว่า มันค่อนข้างตรงไปตรงมาที่จะใช้คลาส std::views::iota ="post-tag" title="show questions tag 'c++11'" rel="tag">c++11 หรือสูงกว่า

สิ่งที่ต้องการคือ:

• ประเภท LegacyInputIterator พื้นฐาน (สิ่งที่กำหนด operator++ และ operator*) ที่ล้อมค่าอินทิกรัล (เช่น int)
• คลาสที่มีลักษณะคล้ายช่วงบางคลาสที่มี begin() และ end() ที่ส่งคืนตัววนซ้ำข้างต้น สิ่งนี้จะช่วยให้มันทำงานใน for ลูปตามช่วง

เวอร์ชันที่เรียบง่ายของสิ่งนี้อาจเป็น:

#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};
}

ฉันได้กำหนดไว้ข้างต้นด้วย constexpr โดยที่รองรับ แต่สำหรับ C++ เวอร์ชันก่อนหน้า เช่น C++11/14 คุณอาจต้องลบ constexpr โดยที่มันไม่ถูกกฎหมายในเวอร์ชันเหล่านั้นจึงจะทำเช่นนั้นได้

ต้นแบบด้านบนช่วยให้โค้ดต่อไปนี้ทำงานใน pre-C ++ 20:

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

ซึ่งจะสร้างแอสเซมบลีเดียวกันเป็นโซลูชัน C++20 std::views::iota และโซลูชัน for-loop แบบคลาสสิก เมื่อปรับให้เหมาะสม

ซึ่งใช้งานได้กับคอมไพเลอร์ที่สอดคล้องกับ C++11 (เช่น คอมไพเลอร์เช่น gcc-4.9.4) และยังคงสร้าง แอสเซมบลีที่เกือบจะเหมือนกัน เป็นคู่พื้นฐาน for-loop

หมายเหตุ: ฟังก์ชันตัวช่วย iota มีไว้สำหรับความเท่าเทียมกันของคุณลักษณะกับโซลูชัน C++20 std::views::iota เท่านั้น แต่ในความเป็นจริงแล้ว คุณสามารถสร้าง iota_range{...} ได้โดยตรง แทนที่จะเรียก iota(...) แบบแรกเป็นเพียงการนำเสนอเส้นทางการอัพเกรดที่ง่ายหากผู้ใช้ต้องการเปลี่ยนไปใช้ C ++ 20 ในอนาคต

เวอร์ชั่นจูบ...

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

    // use i here
}

หากกรณีการใช้งานของคุณมีไว้เพื่อป้องกันการแก้ไขดัชนีลูปโดยไม่ได้ตั้งใจ สิ่งนี้น่าจะทำให้ข้อผิดพลาดดังกล่าวชัดเจน (หากคุณต้องการป้องกันการดัดแปลงโดยเจตนา ก็ขอให้โชคดี...)

คุณไม่สามารถย้ายเนื้อหาบางส่วนหรือทั้งหมดของ for loop ในฟังก์ชันที่ยอมรับ i เป็น const ได้หรือไม่

มันเหมาะสมน้อยกว่าวิธีแก้ปัญหาบางอย่างที่เสนอ แต่ถ้าเป็นไปได้ ก็ทำได้ค่อนข้างง่าย

แก้ไข: เป็นเพียงตัวอย่างเพราะฉันมักจะไม่ชัดเจน

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

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

หากคุณไม่สามารถเข้าถึง c ++20 การปรับปรุงทั่วไปโดยใช้ฟังก์ชัน

#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;
}

ตอนนี้คุณทำได้

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

(ดูการสาธิต)

อัปเดต: แรงบันดาลใจจากความคิดเห็นของ @Human-Compiler ฉันสงสัยว่าคำตอบที่ให้มามีความแตกต่างในกรณีของประสิทธิภาพหรือไม่ ปรากฎว่า ยกเว้นแนวทางนี้ สำหรับแนวทางอื่นๆ ทั้งหมดมีประสิทธิภาพเท่ากันอย่างน่าประหลาดใจ (สำหรับช่วง [0, 10)) แนวทาง std::vector นั้นแย่ที่สุด

(ดู Quick-Bench ออนไลน์)

และนี่คือเวอร์ชัน C++11:

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

นี่คือการสาธิตสด

#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.
    }
  }
}

หมายเหตุ: เราจำเป็นต้องซ้อนขอบเขตเนื่องจากมีความโง่เขลาอย่างน่าประหลาดใจในภาษา: ตัวแปรที่ประกาศในส่วนหัว for(...) ถือว่าอยู่ในระดับการซ้อนเดียวกันกับตัวแปรที่ประกาศในคำสั่งผสม {...} ซึ่งหมายความว่า ตัวอย่างเช่น:

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

อะไร เราไม่ได้เพิ่งเปิดเหล็กดัดฟันใช่ไหม? ยิ่งไปกว่านั้น มันไม่สอดคล้องกัน:

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

วิธีการง่ายๆ วิธีหนึ่งที่ยังไม่ได้กล่าวถึงในที่นี้ ซึ่งใช้ได้กับ C++ เวอร์ชันใดก็ตามคือการสร้าง wrapper ฟังก์ชันรอบช่วง คล้ายกับที่ std::for_each ทำกับตัววนซ้ำ จากนั้นผู้ใช้จะต้องรับผิดชอบในการส่งผ่านอาร์กิวเมนต์การทำงานเป็นการเรียกกลับซึ่งจะถูกเรียกใช้ในการวนซ้ำแต่ละครั้ง

ตัวอย่างเช่น:

// 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);
        }
    }
};

การใช้งานจะอยู่ที่ไหน:

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

สิ่งใดก็ตามที่เก่ากว่า C++11 จะต้องติดขัดผ่านตัวชี้ฟังก์ชันที่มีชื่ออย่างยิ่งไปที่ for_each (คล้ายกับ std::for_each) แต่ก็ยังใช้งานได้

นี่คือการสาธิต

แม้ว่านี่อาจไม่ใช่สำนวนสำหรับ for ลูปใน C++ แต่แนวทางนี้ค่อนข้างใช้กันทั่วไปในภาษาอื่น เครื่องห่ออเนกประสงค์มีความทันสมัยมากสำหรับความสามารถในการจัดองค์ประกอบในข้อความที่ซับซ้อน และสามารถใช้งานได้ตามหลักสรีระศาสตร์

โค้ดนี้ยังเขียน ทำความเข้าใจ และบำรุงรักษาได้ง่ายอีกด้วย

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);
}

อาจจะเรียกมันว่า for_i

ไม่มีค่าใช้จ่าย https://godbolt.org/z/e7asGj