Як зробити змінну const змінної con, за винятком оператора збільшення?

Розглянемо стандарт для циклу:

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

Я хочу запобігти зміні змінної iв тілі forциклу.

Однак я не можу оголосити i, constоскільки це робить оператор збільшення недійсним. Чи є спосіб , щоб зробити iз constперемінним поза заяви збільшення?

З c ++ 20 ви можете використовувати діапазони :: 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фіксується незмінною копією, а все інше фіксується змінною посиланням. ();В кінці циклу просто означає , що лямбда викликається негайно.

Для тих, хто любить відповідь Cigien, std::views::iotaале не працює на C ++ 20 або вище, досить просто впровадити спрощену та полегшену версію std::views::iotaсумісногоc ++ 11 або вище.

Для цього потрібно лише:

• Базовий тип " LegacyInputIterator " (щось, що визначає operator++і operator*), що обертає інтегральне значення (наприклад, an 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де це не є законним у цих версіях.

Наведений вище шаблон дає змогу наступному коду працювати в попередній версії 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аналогу-циклу.

Примітка:iota допоміжна функція тільки для ознаки-парності з C ++ 20 std::views::iotaрішення; але реально, ви також можете безпосередньо побудувати iota_range{...}замість того, щоб дзвонити iota(...). Перший просто представляє простий шлях оновлення, якщо користувач бажає перейти на C ++ 20 у майбутньому.

Версія KISS ...

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

    // use i here
}

Якщо ви використовуєте лише запобігання випадковій зміні індексу циклу, це повинно зробити таку помилку очевидною. (Якщо ви хочете запобігти навмисному внесенню змін, ну, удачі ...)

Чи не могли б ви просто перемістити частину або весь вміст циклу for у функцію, яка приймає 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Підхід є найгіршим.

( Див. Інтернет-швидкий тест )

І ось версія 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
}

Одним простим підходом, про який ще не згадувалося тут, який працює в будь-якій версії С ++, є створення функціональної обгортки навколо діапазону, подібного до того, що 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