Jak zrobić stałą zmienną pętli for z wyjątkiem instrukcji inkrementacji?

Rozważ standard pętli:

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

Chcę, aby zmienna nie ibyła modyfikowana w treści forpętli.

Nie mogę jednak zadeklarować, iponieważ constpowoduje to unieważnienie instrukcji inkrementacji. Czy istnieje sposób, aby ina constzewnątrz zmienny rachunku przyrost?

Od c ++ 20 możesz używać zakresów :: views :: iota w następujący sposób:

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

Oto demo .

W języku c ++ 11 można również użyć następującej techniki, która używa IIILE (natychmiast wywołane wbudowane wyrażenie lambda):

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

Oto demo .

Zauważ, że [&,i]oznacza to, że ijest przechwytywane przez niemodyfikowalną kopię, a wszystko inne jest przechwytywane przez zmienne odniesienie. Na ();końcu pętli oznacza po prostu, że lambda jest wywoływana natychmiast.

Dla każdego, kto lubi std::views::iotaodpowiedź Cigiena, ale nie działa w C ++ 20 lub nowszym, wdrożenie uproszczonej i lekkiej wersji std::views::iotakompatybilnegoc ++ 11 lub wyższy.

Wystarczy:

• Podstawowy typ „ LegacyInputIterator ” (coś, co definiuje operator++i operator*), który otacza wartość całkowitą (np. int)
• Pewna klasa podobna do „zakresu”, która ma begin()i end()zwraca powyższe iteratory. Umożliwi to pracę w forpętlach opartych na zasięgu

Uproszczona wersja może wyglądać następująco:

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

Powyżej zdefiniowałem, constexprgdzie jest obsługiwane, ale w przypadku wcześniejszych wersji C ++, takich jak C ++ 11/14, może być konieczne usunięcie, constexprjeśli nie jest to legalne w tych wersjach, aby to zrobić.

Powyższy schemat umożliwia działanie następującego kodu w wersji przed C ++ 20:

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

Który wygeneruje ten sam zestaw co rozwiązanie C ++ 20 std::views::iotai klasyczne forrozwiązanie pętli po optymalizacji.

Działa to z dowolnymi kompilatorami zgodnymi z C ++ 11 (np. Kompilatorami takimi jak gcc-4.9.4) i nadal tworzy prawie identyczny zestaw z podstawowym forodpowiednikiem -loop.

Uwaga: Funkcja iotapomocnicza służy tylko do zapewnienia parzystości funkcji w rozwiązaniu C ++ 20 std::views::iota; ale realistycznie, możesz również bezpośrednio skonstruować iota_range{...}zamiast dzwonić iota(...). Ten pierwszy przedstawia po prostu łatwą ścieżkę aktualizacji, jeśli użytkownik chce przejść na C ++ 20 w przyszłości.

Wersja KISS ...

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

    // use i here
}

Jeśli twój przypadek użycia ma na celu zapobieżenie przypadkowej modyfikacji indeksu pętli, powinno to uczynić taki błąd oczywistym. (Jeśli chcesz zapobiec celowym modyfikacjom, cóż, powodzenia ...)

Czy nie mógłbyś po prostu przenieść części lub całej zawartości pętli for w funkcji, która akceptuje i jako stałą?

Jest to mniej optymalne niż niektóre proponowane rozwiązania, ale jeśli to możliwe, jest to dość proste.

Edycja: tylko przykład, ponieważ wydaje mi się być niejasny.

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

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

Jeśli nie masz dostępu do c ++ 20, typowa przeróbka za pomocą funkcji

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

teraz możesz

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

( Zobacz demo )

Aktualizacja : Zainspirowany komentarzem @ Human-Compiler , zastanawiałem się, czy podane odpowiedzi mają jakąkolwiek różnicę w przypadku wydajności. Okazuje się, że poza tym podejściem, dla wszystkich innych podejść zaskakująco mają takie same wyniki (dla zakresu [0, 10)). Plikstd::vectorPodejście jest najgorsze.

( Zobacz podręczną ławkę online )

A oto wersja C ++ 11:

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

Oto demo na żywo

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

Uwaga: musimy zagnieździć zakres ze względu na zdumiewającą głupotę języka: zmienna zadeklarowana w for(...)nagłówku jest uważana za znajdującą się na tym samym poziomie zagnieżdżenia, co zmienne zadeklarowane w instrukcji {...}złożonej. Oznacza to na przykład, że:

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

Co? Czy nie otworzyliśmy właśnie kędzierzawego aparatu? Co więcej, jest to niespójne:

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

Jednym prostym podejściem, które nie zostało tu jeszcze wspomniane, które działa w dowolnej wersji C ++, jest utworzenie funkcjonalnego opakowania wokół zakresu, podobnego do tego, co std::for_each w przypadku iteratorów. Użytkownik jest wtedy odpowiedzialny za przekazanie argumentu funkcjonalnego jako wywołania zwrotnego, które będzie wywoływane w każdej iteracji.

Na przykład:

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

Gdzie zastosowanie byłoby:

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

Wszystko starsze niż C ++ 11 utknęłoby, przekazując silnie nazwany wskaźnik funkcji do for_each(podobnie dostd::for_each ), ale nadal działa.

Oto demo

Chociaż może to nie być idiomatyczne dla forpętli w C ++ , to podejście jest dość powszechne w innych językach. Funkcjonalne opakowania są naprawdę eleganckie ze względu na możliwość komponowania się w złożone oświadczenia i mogą być bardzo ergonomiczne w użyciu.

Ten kod jest również łatwy do napisania, zrozumienia i utrzymania.

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

może to nazwać for_i

Bez kosztów https://godbolt.org/z/e7asGj