Comment rendre une variable de boucle for constante à l'exception de l'instruction d'incrément ?

Question

Considérez une boucle standard for :

for (int i = 0; i < 10; ++i) 
{
   // faire quelque chose avec i
}

Je veux empêcher la variable i d'être modifiée dans le corps de la boucle for.

Cependant, je ne peux pas déclarer i comme const car cela rendrait l'instruction d'incrémentation invalide. Existe-t-il un moyen de rendre i une variable const en dehors de l'instruction d'incrémentation ?

Answer 1

À partir de c++20, vous pouvez utiliser ranges::views::iota comme ceci :

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

Voici une démonstration.

---

À partir de c++11, vous pouvez également utiliser la technique suivante, qui utilise un IIILE (immediately invoked inline lambda expression) :

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

Voici une démonstration.

Notez que [&,i] signifie que i est capturé par une copie non mutable, et tout le reste est capturé par référence mutable. Le (); à la fin de la boucle signifie simplement que le lambda est invoqué immédiatement.

Answer 2

Pour quiconque aime la réponse de std::views::iota de Cigien mais qui ne fonctionne pas en C++20 ou supérieur, il est plutôt simple de mettre en œuvre une version simplifiée et légère de std::views::iota compatible avec c++11 ou supérieur.

Tout ce dont vous avez besoin est :

• Un type de "LegacyInputIterator" de base (quelque chose qui définit operator++ et operator*) qui enveloppe une valeur entière (par exemple, un int)
• Une classe de type "range" qui a des méthodes begin() et end() qui renvoient les itérateurs mentionnés ci-dessus. Cela permettra de travailler dans des boucles for basées sur les plages

Une version simplifiée de ceci pourrait être :

#include 

// Il s'agit simplement d'une classe qui enveloppe un 'int' dans une abstraction d'itérateur
// Les comparaisons comparent la valeur sous-jacente, et 'operator++' incrémente simplement
// l'entier sous-jacent
class counting_iterator
{
public:
    // boilerplate d'itérateur de base
    using iterator_category = std::input_iterator_tag;
    using value_type = int;
    using reference  = int;
    using pointer    = int*;
    using difference_type = std::ptrdiff_t;

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

    // "Déférencement" (renvoie simplement la valeur sous-jacente)
    constexpr reference operator*() const { return m_value; }
    constexpr pointer operator->() const { return &m_value; }

    // Avancement de l'itérateur (incrémente simplement la valeur)
    constexpr counting_iterator& operator++() {
        m_value++;
        return (*this);
    }
    constexpr counting_iterator operator++(int) {
        const auto copy = (*this);
        ++(*this);
        return copy;
    }

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

// Juste un type conteneur qui définit 'begin' et 'end' pour
// l'itération basée sur les plages. Cela détient le premier et le dernier élément
// (début et fin de la plage)
// L'itérateur de début est créé à partir de la première valeur, et l'itérateur de fin est créé à partir de la seconde valeur.
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}; }
};

// Une fonction d'aide simple pour renvoyer la plage
// Cette fonction n'est pas strictement nécessaire, vous pourriez simplement construire
// directement l 'iota_range'
constexpr iota_range iota(int first, int last)
{
    return iota_range{first, last};
}

J'ai défini le code ci-dessus avec constexpr là où c'est supporté, mais pour les versions antérieures de C++ comme C++11/14, vous devrez peut-être supprimer constexpr là où ce n'est pas autorisé dans ces versions.

Le code ci-dessus permet d'exécuter le code suivant en pré-C++20 :

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

Cela générera le même assemblage que la solution C++20 std::views::iota et la solution classique avec une boucle for lorsqu'elle est optimisée.

Ceci fonctionne avec n'importe quel compilateur conforme à C++11 (par exemple, des compilateurs comme gcc-4.9.4) et produit toujours un assemblage pratiquement identique à une solution de boucle for de base.

Remarque : La fonction d'aide iota est juste pour une parité de fonctionnalités avec la solution C++20 std::views::iota; mais en réalité, vous pourriez aussi construire directement un iota_range{...} au lieu d'appeler iota(...). Le premier présente simplement un chemin de mise à niveau facile si un utilisateur souhaite passer à C++20 à l'avenir.

Answer 3

La version KISS...

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

    // utiliser i ici
}

Si votre cas d'utilisation consiste simplement à empêcher la modification accidentelle de l'index de boucle, alors cela devrait rendre un tel bogue évident. (Si vous souhaitez empêcher toute modification intentionnelle, eh bien, bonne chance...)

Answer 4

Ne pourriez-vous pas simplement déplacer une partie ou la totalité du contenu de votre boucle for dans une fonction qui accepte i comme constante?

Ce n'est pas aussi optimal que certaines des solutions proposées, mais si c'est possible, c'est assez simple à faire.

Édition : Juste un exemple car j'ai tendance à être peu clair.

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

void looper ( const int v )
{
    // faites votre traitement ici
}

Answer 5

Si vous n'avez pas accès à c++20, un relooking typique en utilisant une fonction

#include 
#include  // std::iota

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

maintenant vous pourriez

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

(Voir une démo)

---

Mise à jour: Inspiré par le commentaire de @Human-Compiler, je me demandais si les réponses données avaient des différences en termes de performances. Il s'avère que, excepté pour cette approche, toutes les autres approches ont étonnamment la même performance (pour l'intervalle [0, 10)). L'approche avec std::vector est la pire.

(Voir Quick-Bench en ligne)