Quelle est la différence entre const_iterator et non-const itérateur dans le C++ STL?

Quelle est la différence entre un const_iterator et un iterator et où voulez-vous utiliser l'un plutôt que l'autre?

InformationsquelleAutor Konrad | 2008-11-21
  1. 100

    const_iterators ne vous permettra pas de modifier les valeurs de point de, régulière iterators faire.

    Comme avec toutes les choses en C++, préférez toujours const, sauf s'il y a une bonne raison d'utiliser les itérateurs (c'est à dire que vous souhaitez utiliser le fait qu'ils ne sont pas const pour changer de la pointe-de valeur).

    • Dans un monde parfait, ce serait le cas. Mais avec le C++ const est seulement aussi bon que la personne qui a écrit le code 🙁
    • mutable existe pour une très bonne raison. Il est rarement utilisé, et à la recherche avec Google Recherche de Code, il semble juste de pourcentage valide utilise. Le mot-clé est un très puissant outil d'optimisation, et ce n'est pas, comme le retrait, il permettrait d'améliorer la const-correctness(coughpointerscoughandcoughreferencescough)
    • Plus comme un puissant outil de hack. De toutes les instances que j'ai jamais vu de l'utilisation de la "mutable" mot, tous, mais l'un est un indicateur précis que le code a été mal écrite et mutable a besoin d'un hack pour contourner les défauts.
    • Il possède des utilisations légitimes, comme la mise en cache le résultat d'un long calcul au sein d'un const classe. D'autre part, c'est à peu près la seule fois où j'ai utilisé une mutable pendant près de vingt ans de développement en C++.
    InformationsquelleAutor Dominic Rodger
  2. 34

    Ils devraient assez bien d'être auto-explicatif. Si l'itérateur qui pointe vers un élément de type T, alors const_iterator points à un élément de type "const T'.

    C'est en gros l'équivalent du type pointeur:

    T* //A non-const iterator to a non-const element. Corresponds to std::vector<T>::iterator
T* const //A const iterator to a non-const element. Corresponds to const std::vector<T>::iterator
const T* //A non-const iterator to a const element. Corresponds to std::vector<T>::const_iterator

    Const itérateur qui pointe toujours vers le même élément, de sorte que l'itérateur lui-même est const. Mais l'élément de points pour ne pas être const, de sorte que l'élément de points à peut être changé.
    Un const_iterator est un itérateur qui pointe vers un const élément, alors que l'itérateur lui-même peut être mis à jour (incrémenté ou décrémenté, par exemple), l'élément de points à ne peut pas être changé.

    • "Const itérateur qui pointe toujours vers le même élément," C'est incorrect.
    • Comment alors? Remarque le manque de soulignement. Je suis contrastées une variable de type const std::vector<T>::iterator avec std::vector<T>::const_iterator. Dans le premier cas, l'itérateur est lui-même const, donc il ne peut pas être modifié, mais l'élément de référence peut être modifié librement.
    • Ah, je vois. Oui j'ai raté le trait de soulignement manquant.
    • Upvoted pour expliquer la subtilité entre const iterater et const_iterator.
    InformationsquelleAutor jalf
  3. 7

    Unfortunaty, un grand nombre de méthodes pour les conteneurs STL prend itérateurs au lieu de const_iterators en tant que paramètres. Donc, si vous avez un const_iterator, vous ne pouvez pas dire "insérer un élément avant de l'élément que cet itérateur points" (en disant une telle chose n'est pas conceptuellement un const violation, à mon avis). Si vous voulez faire de toute façon, vous devez la convertir en une non-const itérateur à l'aide de std::advance() ou boost::next(). Par exemple. boost::next(conteneur.begin(), std::distance(récipient.begin(), the_const_iterator_we_want_to_unconst)). Si conteneur est un std::list, alors le temps d'exécution de cet appel sera O(n).

    Donc la règle universelle pour ajouter const où il est "logique" pour le faire, est moins universel quand il s'agit de conteneurs STL.

    Cependant, boost conteneurs prendre const_iterators (eg. boost::unordered_map::erase()). Ainsi, lorsque vous utilisez le boost conteneurs vous pouvez être "const agressive". En passant, quelqu'un sait si ou lorsque les conteneurs STL sera corrigé?

    • Il peut être une question d'opinion. Dans le cas de vector et deque, l'insertion d'un élément invalide tous les itérateurs, qui n'est pas très const. Mais je vois votre point de vue. De telles opérations sont protégés par conteneur const-ness, pas les itérateurs. Et je me demande pourquoi il n'y a pas un const-à-nonconst itérateur fonction de conversion dans le conteneur standard de l'interface.
    • Vous avez raison Potatoswatter, je suis catégorique, c'est une question d'opinion pour l'accès aléatoire aux conteneurs et conteneur.begin() + (the_const_iterator_we_want_to_unconst – conteneur.begin()) est O(1) de toute façon. Je me demande aussi pourquoi il n'y a pas de fonction de conversion pour les non-random access conteneurs, mais peut-être il ya une bonne raison? Savez-vous si il ya une raison que les fonctions pour les non-random access conteneurs ne prenez pas de const_iterators?
    • "dit une telle chose n'est pas conceptuellement un const violation, à mon avis," - c'est un commentaire très intéressant, j'ai quelques idées sur le sujet. Avec de simples pointeurs, on peut dire int const * foo; int * const foo; et int const * const foo;tous les trois sont valables et utiles, chacun à leur manière. std::vector<int> const bar doit être le même que le second, mais il est malheureusement souvent considérée comme la troisième. La cause racine du problème est que nous ne pouvons pas dire std::vector<int const> bar; lorsque les moyens il n'y a aucun moyen d'obtenir le même effet que int const *foo; dans un vecteur.
    InformationsquelleAutor Magnus Andermo
  4. 5

    Utilisation const_iterator chaque fois que vous le pouvez, utilisez itérateur lorsque vous n'avez pas d'autres choix.

    InformationsquelleAutor Naveen
  5. 1

    Minimale exemples

    Non-const itérateurs permettent de modifier ce qu'ils pointent à:

    std::vector<int> v{0};
std::vector<int>::iterator it = v.begin();
*it = 1;
assert(v[0] == 1);

    Const itérateurs ne pas:

    const std::vector<int> v{0};
std::vector<int>::const_iterator cit = v.begin();
//Compile time error: cannot modify container with const_iterator.
//*cit = 1;

    Comme indiqué ci-dessus, v.begin() est const surchargé, et retourne iterator ou const_iterator en fonction de la const-ness du conteneur variable:

    Un cas courant où const_iterator pop-up, c'est quand this est utilisé à l'intérieur d'un const méthode:

    class C {
    public:
        std::vector<int> v;
        void f() const {
            std::vector<int>::const_iterator it = this->v.begin();
        }
        void g(std::vector<int>::const_iterator& it) {}
};

    const fait this const, ce qui rend this->v const.

    Habituellement, vous pouvez l'oublier avec auto, mais si vous passer ces itérateurs autour de vous, vous aurez besoin de penser à eux pour les signatures de méthode.

    Comme const et non const, vous pouvez convertir facilement de non-const de const, mais pas dans l'autre sens:

    std::vector<int> v{0};
std::vector<int>::iterator it = v.begin();

//non-const to const.
std::vector<int>::const_iterator cit = it;

//Compile time error: cannot modify container with const_iterator.
//*cit = 1;

//Compile time error: no conversion from const to no-const.
//it = ci1;

    À utiliser: analogue à const int vs int: préférez const itérateurs chaque fois que vous pouvez les utiliser (quand vous n'avez pas besoin de modifier le récipient avec eux), afin de mieux documenter votre intention de lecture, sans modification.

    InformationsquelleAutor Ciro Santilli 新疆改造中心996ICU六四事件
  6. 0

    (comme d'autres l'ont dit) const_iterator ne vous permet pas de modifier les éléments dont il points de, ce qui est utile à l'intérieur de const méthodes de la classe. Il vous permet également d'exprimer votre intention.

    InformationsquelleAutor Trey Jackson
  7. 0

    ok Permettez-moi de l'expliquer avec un exemple très simple, d'abord sans l'aide constante d'itérateur
    considérons que nous avons de collecte des entiers aléatoires de la collection "randomData"

        for(vector<int>::iterator i = randomData.begin() ; i != randomData.end() ; ++i)*i = 0;
for(vector<int>::const_iterator i = randomData.begin() ; i!= randomData.end() ; ++i)cout << *i;

    Comme on peut le voir pour l'écriture/édition des données à l'intérieur de la collection normale itérateur est utilisé, mais pour la lecture de but constant d'itérateur a été utilisé . Si vous essayez d'utiliser la constante itérateur dans la première boucle for, vous obtiendrez une erreur . Comme un pouce d'utilisation des règles de la constante d'itérateur pour lire les données à l'intérieur de la collection .

    InformationsquelleAutor Mr Coder