Làm thế nào để tạo một biến vòng lặp for const với ngoại lệ của câu lệnh tăng?

Hãy xem xét một tiêu chuẩn cho vòng lặp:

for (int i = 0; i < 10; ++i) 
{
   // do something with i
}

Tôi muốn ngăn không cho biến ibị sửa đổi trong phần thân của forvòng lặp.

Tuy nhiên, tôi không thể tuyên bố inhư constthế này làm cho tuyên bố không hợp lệ tăng. Có cách nào để tạo imột constbiến bên ngoài câu lệnh tăng không?

Từ c ++ 20, bạn có thể sử dụng các dải ô :: views :: iota như thế này:

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

Đây là một bản demo .

Từ c ++ 11, bạn cũng có thể sử dụng kỹ thuật sau, sử dụng IIILE (ngay lập tức được gọi ra biểu thức lambda nội tuyến):

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

Đây là một bản demo .

Lưu ý rằng điều đó [&,i]có nghĩa là nó iđược ghi lại bằng bản sao không thể thay đổi và mọi thứ khác được ghi lại bằng tham chiếu có thể thay đổi. Ở ();cuối vòng lặp chỉ đơn giản có nghĩa là lambda được gọi ngay lập tức.

Đối với bất kỳ ai thích std::views::iotacâu trả lời của Cigien nhưng không hoạt động trong C ++ 20 trở lên, việc triển khai phiên bản std::views::iotatương thích đơn giản và nhẹ sẽ khá dễ dàngc ++ 11 hoặc ở trên.

Tất cả những gì nó yêu cầu là:

• Loại " LegacyInputIterator " cơ bản (thứ xác định operator++và operator*) bao bọc một giá trị tích phân (ví dụ: an int)
• Một số lớp giống như "phạm vi" có begin()và end()trả về các trình vòng lặp ở trên. Điều này sẽ cho phép nó hoạt động trong các forvòng lặp dựa trên phạm vi

Một phiên bản đơn giản của điều này có thể là:

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

Tôi đã xác định ở trên với constexprnơi nó được hỗ trợ, nhưng đối với các phiên bản C ++ trước đó như C ++ 11/14, bạn có thể cần phải loại bỏ constexprnơi không hợp pháp trong các phiên bản đó để làm như vậy.

Bảng mẫu trên cho phép mã sau hoạt động trong phiên bản trước C ++ 20:

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

Điều này sẽ tạo ra cùng một assembly với std::views::iotagiải pháp C ++ 20 và forgiải pháp -loop cổ điển khi được tối ưu hóa.

Điều này hoạt động với bất kỳ trình biên dịch tuân thủ C ++ 11 nào (ví dụ như trình biên dịch như vậy gcc-4.9.4) và vẫn tạo ra một hợp ngữ gần giống với một forđối tác -loop cơ bản .

Lưu ý: Hàm iotatrợ giúp chỉ dành cho tính năng tương đương với std::views::iotagiải pháp C ++ 20 ; nhưng trên thực tế, bạn cũng có thể trực tiếp tạo một iota_range{...}thay vì gọi iota(...). Phần trước chỉ trình bày một đường dẫn nâng cấp dễ dàng nếu người dùng muốn chuyển sang C ++ 20 trong tương lai.

Phiên bản KISS ...

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

    // use i here
}

Nếu trường hợp sử dụng của bạn chỉ là để ngăn chặn việc sửa đổi ngẫu nhiên chỉ mục vòng lặp thì điều này sẽ làm cho một lỗi như vậy rõ ràng. (Nếu bạn muốn ngăn chặn sự sửa đổi có chủ ý , thì, chúc may mắn ...)

Nếu bạn không có quyền truy cập vào c ++ 20, trang điểm điển hình bằng cách sử dụng một hàm

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

bây giờ bạn có thể

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

( Xem Demo )

Cập nhật : Lấy cảm hứng từ bình luận của @ Human-Compiler , tôi đã tự hỏi thời tiết các câu trả lời đã cho có bất kỳ sự khác biệt nào trong trường hợp hiệu suất. Hóa ra, ngoại trừ cách tiếp cận này, tất cả các cách tiếp cận khác đều có cùng hiệu suất (đối với phạm vi [0, 10)) một cách đáng ngạc nhiên . Cách std::vectortiếp cận là tồi tệ nhất.

( Xem Ghế dài nhanh trực tuyến )

Bạn không thể chỉ di chuyển một số hoặc tất cả nội dung của vòng lặp for của bạn trong một hàm chấp nhận tôi là một const?

Nó kém tối ưu hơn một số giải pháp được đề xuất, nhưng nếu có thể thì điều này khá đơn giản để thực hiện.

Chỉnh sửa: Chỉ là một ví dụ vì tôi có xu hướng không rõ ràng.

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

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

Và đây là phiên bản C ++ 11:

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

Đây là bản demo trực tiếp

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

Lưu ý: chúng ta cần lồng phạm vi vào vì có một sự ngu ngốc đáng kinh ngạc trong ngôn ngữ: biến được khai báo trong for(...)tiêu đề được coi là ở cùng mức lồng với các biến được khai báo trong {...}câu lệnh ghép. Điều này có nghĩa là, ví dụ:

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

Gì? Không phải chúng ta vừa mở một dấu ngoặc nhọn sao? Hơn nữa, nó không nhất quán:

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

Một cách tiếp cận đơn giản chưa được đề cập ở đây hoạt động trong bất kỳ phiên bản nào của C ++ là tạo một trình bao bọc chức năng xung quanh một phạm vi, tương tự như những gì std::for_eachlàm với trình vòng lặp. Sau đó, người dùng có trách nhiệm chuyển đối số chức năng dưới dạng một lệnh gọi lại sẽ được gọi trên mỗi lần lặp.

Ví dụ:

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

Việc sử dụng sẽ ở đâu:

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

Bất kỳ thứ gì cũ hơn C ++ 11 sẽ bị mắc kẹt khi truyền một con trỏ hàm có tên mạnh vào for_each(tương tự như std::for_each), nhưng nó vẫn hoạt động.

Đây là bản demo

Mặc dù điều này có thể không phải là thành ngữ đối với forcác vòng lặp trong C ++ , nhưng cách tiếp cận này khá phổ biến trong các ngôn ngữ khác. Các trình bao bọc chức năng thực sự đẹp mắt vì khả năng kết hợp của chúng trong các câu lệnh phức tạp và có thể rất tiện lợi khi sử dụng.

Mã này cũng đơn giản để viết, hiểu và duy trì.

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

có thể gọi nó for_i

Không tốn phí https://godbolt.org/z/e7asGj