Comment faire pour incrémenter un itérateur par 2?

Quelqu'un peut-il me dire comment faire pour incrémenter la variable d'itération par 2?

iter++ est disponible - ce que je dois faire iter+2? Comment puis-je y parvenir?

  • En juger par le nombre de réponses, vous devez préciser votre question.
  • Oui. Quel type d'itérateur est-il? Montrer un peu de code.
InformationsquelleAutor Cute | 2009-06-29
  1. 93

    std::advance( iter, 2 );

    Cette méthode fonctionne pour les itérateurs qui ne sont pas en accès aléatoire itérateurs, mais il peut encore être spécialisé par la mise en œuvre seront pas moins efficace que iter += 2 lorsqu'il est utilisé avec accès aléatoire itérateurs.

    • Ce qui va se passer si l'itérateur pointe actuellement sur le dernier élément? Où est-il point après l'incrémentation? J'ai essayé avec VC++ - il seulement les progrès et la comparaison avec les vector::end() renvoie la valeur false par la suite. C'est la voie droite de comportements indéfinis, je suppose.
    • Oui, si vous allez faire std::advance avec '2', ou +=2, ou les deux '++' sans vérification de la " fin " dans le milieu, alors vous avez besoin d'une garantie externe que vous n'allez pas aller au-delà d'un passé la fin. (E. g. vous pouvez savoir que vous êtes une itération dans le même numéro (de base zéro) des éléments d'une collection, qui est la garantie d'avoir un même nombre d'éléments.)
    • quelle est la différence entre la prochaine( iter, 2) et suivant( iter, 2 )
    InformationsquelleAutor CB Bailey
  2. 26

    http://www.cplusplus.com/reference/std/iterator/advance/

    std::advance(it,n);

    où n est 2 dans votre cas.

    La beauté de cette fonction est, que Si "il" est un itérateur à accès aléatoire, la rapide

    it += n

    opération est utilisée (c'est à dire vector<,>::iterator). Sinon, le rendu de

    for(int i = 0; i < n; i++)
    ++it;

    (c'est à dire une liste<..>::iterator)

    InformationsquelleAutor Maik Beckmann
  3. 17

    Si vous n'avez pas modifiable lvalue d'un itérateur, ou l'on désire obtenir une copie d'un itérateur (en laissant l'original inchangé), puis C++11 est livré avec de nouvelles fonctions d'assistance - std::next /std::prev:

    std::next(iter, 2);          //returns a copy of iter incremented by 2
std::next(std::begin(v), 2); //returns a copy of begin(v) incremented by 2
std::prev(iter, 2);          //returns a copy of iter decremented by 2
    • Si j'ai un itérateur comme ceci: map<string,string>::iterator iter; for(iter = variations.begin(); iter != variations.end(); iter++) { map<string,string>::iterator it_tmp = std::next(iter, 1); // increment by 1 it_tmp = std::next(iter, 2); // increment by 2 } Sera iter être incrémenté par 2 ? ou iter sera seulement sur it_tmp?
    • Seulement it_tmp
    InformationsquelleAutor Piotr Skotnicki
  4. 7

    Vous pouvez utiliser l'affectation par l'ajout d' " opérateur

    iter += 2;
    • Je me demandais si ++iter++ mais je pense que ce serait juste être source de confusion.
    • Ce qui va se passer si l'itérateur pointe actuellement sur le dernier élément? Où est-il point après l'incrémentation?
    • Vous ne devriez pas le faire. C'est un comportement indéfini.
    • ++iter++ lie à ++(iter++), iter++ n'est pas modifiable lvalue de sorte que vous ne pouvez pas "faire" ++(iter++). Si elle est autorisée, il ne serait probablement pas faire ce que l'on pourrait attendre d'elle.
    • Cela ne fonctionne pas pour tous les types iterator. Seulement RandomAccessIterators sont nécessaires à l'appui de plus.
    InformationsquelleAutor teabot
  5. 4

    Si vous ne savez pas si vous avez assez à côté d'éléments dans votre récipient ou pas, vous avez besoin de vérifier à la fin de votre conteneur entre chaque incrément. Ni ++, ni std::advance va le faire pour vous.

    if( ++iter == collection.end())
  ... //stop

if( ++iter == collection.end())
  ... //stop

    Vous pouvez même rouler votre propre lié-secure avance de la fonction.

    Si vous êtes sûr que vous ne serez pas aller au-delà de la fin, puis std::advance( iter, 2 ) est la meilleure solution.

    InformationsquelleAutor Jem
  6. 3

    Nous pouvons utiliser les deux std::advance ainsi que std::suivant, mais il y a une différence entre les deux.

    advance modifie son argument et ne renvoie rien. De sorte qu'il peut être utilisé comme: 

    vector<int> v;
v.push_back(1);
v.push_back(2);
auto itr = v.begin();
advance(itr, 1);          //modifies the itr
cout << *itr<<endl        //prints 2

    next renvoie une copie modifiée de l'itérateur:

    vector<int> v;
v.push_back(1);
v.push_back(2);
cout << *next(v.begin(), 1) << endl;    //prints 2
    InformationsquelleAutor skpro19
  7. 0

    En supposant que la taille de la liste peut ne pas être un multiple de l'étape vous devez vous prémunir contre overflow:

    static constexpr auto step = 2;

//Guard against invalid initial iterator.
if (!list.empty())
{
    for (auto it = list.begin(); /*nothing here*/; std::advance(it, step))
    {
        //do stuff...

        //Guard against advance past end of iterator.
        if (std::distance(it, list.end()) > step)
            break;
    }
}

    En fonction de la collection de la mise en œuvre, la distance de calcul peut être très lent. Ci-dessous est optimale et plus lisible. La fermeture pourrait être changé pour un modèle pour les services publics avec la fin la liste des valeur transmise par const référence:

    const auto advance = [&](list_type::iterator& it, size_t step)
{
    for (size_t i = 0; it != list.end() && i < step; std::next(it), ++i);
};

static constexpr auto step = 2;

for (auto it = list.begin(); it != list.end(); advance(it, step))
{
    //do stuff...
}

    Si il n'y a pas de boucle:

    static constexpr auto step = 2;
auto it = list.begin();

if (step <= list.size())
{
    std::advance(it, step);
}
    InformationsquelleAutor evoskuil
  8. -5

    La réponse très simple:

    ++++iter

    La réponse longue:

    Vous devriez vraiment s'habituer à l'écriture ++iter au lieu de iter++. Ce dernier doit retourner une copie de l'ancienne valeur, qui est différente de la valeur nouvelle; cela prend du temps et de l'espace.

    Notez que le préfixe de l'incrément (++iter) prend une lvalue et renvoie une lvalue, alors que postfix incrément (iter++) prend une lvalue et renvoie une rvalue.

    • Un comportement indéfini si iter est un pointeur brut (que certains types iterator peut être). ++it; ++it; ce serait bien.
    • Mauvaise idée et il n'est pas très lisible.
    • S'il vous plaît dites-moi ce n'est pas une réponse sérieuse.
    InformationsquelleAutor Jonas Kölker