Boucle d'itération vs boucle d'index

Question

Duplicata possible :
Pourquoi utiliser des itérateurs au lieu d'indices de tableaux ?

Je suis en train de réviser mes connaissances sur le C++ et je suis tombé sur les itérateurs. Une chose que je veux savoir est ce qui les rend si spéciaux et je veux savoir pourquoi cela :

using namespace std;

vector<int> myIntVector;
vector<int>::iterator myIntVectorIterator;

// Add some elements to myIntVector
myIntVector.push_back(1);
myIntVector.push_back(4);
myIntVector.push_back(8);

for(myIntVectorIterator = myIntVector.begin(); 
        myIntVectorIterator != myIntVector.end();
        myIntVectorIterator++)
{
    cout<<*myIntVectorIterator<<" ";
    //Should output 1 4 8
}

est meilleur que ça :

using namespace std;

vector<int> myIntVector;
// Add some elements to myIntVector
myIntVector.push_back(1);
myIntVector.push_back(4);
myIntVector.push_back(8);

for(int y=0; y<myIntVector.size(); y++)
{
    cout<<myIntVector[y]<<" ";
    //Should output 1 4 8
}

Et oui, je sais que je ne devrais pas utiliser l'espace de noms std. J'ai juste pris cet exemple sur le site de cprogramming. Alors pouvez-vous me dire pourquoi le dernier est pire ? Quelle est la grande différence ?

Answer 1

En écrivant votre code client en termes d'itérateurs, vous faites totalement abstraction du conteneur.

Considérez ce code :

class ExpressionParser // some generic arbitrary expression parser
{
public:
    template<typename It>
    void parse(It begin, const It end)
    {
        using namespace std;
        using namespace std::placeholders;
        for_each(begin, end, 
            bind(&ExpressionParser::process_next, this, _1);
    }
    // process next char in a stream (defined elsewhere)
    void process_next(char c);
};

code client :

ExpressionParser p;

std::string expression("SUM(A) FOR A in [1, 2, 3, 4]");
p.parse(expression.begin(), expression.end());

std::istringstream file("expression.txt");
p.parse(std::istringstream<char>(file), std::istringstream<char>());

char expr[] = "[12a^2 + 13a - 5] with a=108";
p.parse(std::begin(expr), std::end(expr));

Edit : Considérez votre exemple de code original, implémenté avec :

using namespace std;

vector<int> myIntVector;
// Add some elements to myIntVector
myIntVector.push_back(1);
myIntVector.push_back(4);
myIntVector.push_back(8);

copy(myIntVector.begin(), myIntVector.end(), 
    std::ostream_iterator<int>(cout, " "));

Answer 2

Ce qui est bien avec l'itérateur, c'est que plus tard, si vous voulez changer votre vecteur pour un autre conteneur STD. Alors le forloop fonctionnera toujours.

Answer 3

C'est une question de vitesse. l'utilisation de l'itérateur permet d'accéder plus rapidement aux éléments. une réponse à une question similaire a été donnée ici :

Qu'est-ce qui est le plus rapide, itérer un vecteur STL avec vector::iterator ou avec at() ?

Edit : la vitesse d'accès varie avec chaque processeur et compilateur