Puis-je convertir un itérateur inverse, à un avant itérateur?

J'ai une classe appelée Action, qui est essentiellement un wrapper autour d'une deque de Move objets.

Parce que j'ai besoin de traverser la deque de Moves à la fois en avant et en arrière, j'ai hâte d'itérateur et un reverse_iterator en tant que variables membres de la classe. La raison pour cela est parce que j'ai besoin de savoir quand je suis passé devant la "fin" de la deque, à la fois quand je suis aller en avant ou en arrière.

La classe ressemble à ceci:

class Action
{
public:
    SetMoves(std::deque<Move> & dmoves) { _moves = dmoves; }
    void Advance();
    bool Finished() 
    {
        if( bForward )
            return (currentfwd==_moves.end());
        else
            return (currentbck==_moves.rend());
    }
private:
    std::deque<Move> _moves;
    std::deque<Move>::const_iterator currentfwd;
    std::deque<Move>::const_reverse_iterator currentbck;
    bool bForward;
};

La Advance fonction est la suivante:

void Action::Advance
{
    if( bForward)
        currentfwd++;
    else
        currentbck++;
}

Mon problème est que je veux être en mesure de récupérer un itérateur à l'actuel Move objet, sans avoir à se demander si je vais vers l'avant ou vers l'arrière. Cela signifie une fonction renvoyant un type d'itérateur, mais j'ai deux types.

Dois-je oublier de retourner un itérateur, et retour const référence à un Move objet à la place?

meilleurs vœux,

BeeBand

  • La réponse à votre question "puis-je avoir un reverse_iterator à partir d'un avant itérateur" est oui et ici
InformationsquelleAutor BeeBand | 2010-01-10
  1. 27

    C'est exactement le genre de problème qui a motivé la conception de la STL pour commencer. Il y a de réelles raisons:

    1. ne Pas stocker les itérateurs le long avec des conteneurs
    2. à l'Aide d'algorithmes qui acceptent arbitraire des itérateurs
    3. Avoir des algorithmes d'évaluer une gamme complète au lieu d'un seul élément à la fois

    Je soupçonne ce que vous voyez maintenant est plus ou moins la pointe de l'iceberg de la réalité des problèmes. Mon conseil serait de prendre un peu de recul, et au lieu de se demander à propos de la façon de traiter avec les détails de la conception pour l'instant, de demander un peu plus d'une question d'ordre général à propos de ce que vous essayez d'accomplir, et la meilleure façon de réaliser que résultat final.

    Pour ceux qui s'occupent principalement sur la question dans le titre, la réponse est très qualifié "oui". En particulier, un reverse_iterator a un base() membre pour le faire. Les qualifications sont un peu cependant problématique.

    Le démontrer le problème, considérons le code comme ceci:

    #include <iostream>
#include <vector>
#include <iterator>

int main() { 
    int i[] = { 1, 2, 3, 4};
    std::vector<int> numbers(i, i+4);

    std::cout << *numbers.rbegin() << "\n";
    std::cout << *numbers.rbegin().base() << "\n";
    std::cout << *(numbers.rbegin()+1).base() << "\n";

    std::cout << *numbers.rend() << "\n";
    std::cout << *numbers.rend().base() << "\n";
    std::cout << *(numbers.rend()+1).base() << "\n";
}

    L'exécution de cette à ce moment-là sur ma machine produit la sortie suivante:

    4
0
4
-1879048016
1
-1879048016

    Résumé: avec rbegin() nous doit ajoutez-en un avant de se convertir à l'avant d'une itérateur pour obtenir un itérateur qui est valide -- mais avec rend() nous devons pas ajoutez-en un avant de se convertir pour obtenir une valide itérateur.

    Aussi longtemps que vous utilisez X.rbegin() et X.rend() que les paramètres d'un algorithme générique, c'est très bien-mais l'expérience indique que la conversion à l'avant itérateurs souvent conduit à des problèmes.

    En fin de compte, cependant, pour le corps de la question (plutôt que le titre), la réponse est à peu près comme donné ci-dessus: le problème vient d'essayer de créer un objet qui combine la collection avec un couple d'itérateurs dans cette collection. Résoudre ce problème, et l'ensemble de l'entreprise vers l'avant et inverse les itérateurs devient inutile.

    • J'aime votre réponse. Vous avez peut-être raison. Je suis relativement novice en C++ et de la STL. Et ce qui constitue une bonne C++ design est quelque chose que je suis mal à apprendre.
    • Bien que cette réponse permet de BeeBand il ne répond pas à la question d'origine pour la postérité. Cette réponse devrait plutôt être un commentaire pour le post original. Je voudrais demander BeeBand à envisager une modification de la tique à Mike Seymour réponse.
    • Si vous restreindre "la question" quelle est dans le titre, vous avez raison. Si vous lisez l'ensemble de la question elle-même, cependant, je dirais beaucoup moins (au mieux).
    • Quatre ans en bas de la route, je dirais que les gens trouvent à cette question en raison de son titre de plus qu'en raison de son contenu.
    • Vous sir sont corrects. 🙂
    InformationsquelleAutor Jerry Coffin
  2. 65

    Inverse des itérateurs ont un membre base() qui retourne un correspondant de l'avant itérateur. Méfiez-vous que ce n'est pas un itérateur qui se rapporte au même objet, il fait en réalité référence à l'objet suivant dans la séquence. C'est ainsi que rbegin() correspond à end() et rend() correspond à begin().

    Donc, si vous voulez retourner un itérateur, alors vous devez faire quelque chose comme

    std::deque<Move>::const_iterator Current() const
{
    if (forward)
        return currentfwd;
    else
        return (currentbck+1).base();
}

    Je préfère renvoyer une référence, même si, et expriment toute l'itération de détails à l'intérieur de la classe.

    • (currentbck+1).base() borks quand currentbck est un itérateur. La conversion entre les deux est un monde d'erreurs en attente de se produire.
    InformationsquelleAutor Mike Seymour
  3. 6

    Depuis std::deque est un accès aléatoire conteneur (le même que std::vector) vous êtes beaucoup mieux d'utiliser un seul index entier dans le deque pour les deux traversals.

    • Merci - j'ai été en utilisant deque tout le reste de l'application pour cette même raison. Je ne sais pas pourquoi j'ai eu une vision en tunnel sur les itérateurs 🙂
    • C'est pourquoi vous avez toujours besoin d'une deuxième paire de yeux 🙂
    • Attention cependant: il est assez difficile de tester un nombre entier non signé de savoir si a atteint sous la valeur zéro 😉
    • Bon point. Entier signé puis, je suppose.
    • Vous pouvez utiliser une (avant) itérateur, et être prudent de ne pas incrémenter si elle est égale à l'end(), ou diminuer en cas d'égalité à la fin(). Et de toute façon, regardez pour les opérations d'invalider les itérateurs, car ils pourraient également pour effet d'invalider un indice (soit parce qu'il n'a plus de points à l'élément que vous pensez qu'il fait, ou parce que vous supprimez quelque chose lorsque l'indice de référence à la fin de la deque).
    • Voulez-vous dire de ne pas décrémenter si égal à begin()? Problème avec ça, c'est, si l'Avance() ne va pas à l'équivalent fonctionnel de rené(), une fonction comme GetCurrentMove() retournera begin() alors qu'en réalité, tous les mouvements ont été traitées.
    • Oui, c'est ce que je voulais dire, l'autre chose, c'est un non-sens :-). Vous devez utiliser un indicateur pour indiquer "du début", cas particulier de partout. Le problème est que ce n'est pas intégré dans le itérateur de type qui peut faire les deux extrémités d'un intervalle, donc GetCurrentMove() ne correspond pas bien avec ce que vous faites. Et même une fin itérateur n'est pas pour rien. De sorte que vous aurez spéciales aux deux extrémités de toute façon. Juste une suggestion, je ne sais pas si il fonctionnera en fait tout mieux que d'utiliser un index.

    InformationsquelleAutor Nikolai Fetissov
  4. 1

    Il me semble que vous disposez de deux comportements différents dans la même classe.

    Notamment, il semble que vous ne pouvez parcourir votre collection en une seule commande, sinon, si vous étiez pour commencer le parcours, puis de changer le bforward argument vous vous retrouvez avec une étrange situation.

    Personnellement, je suis pour exposer les deux itérateurs (c'est à dire, avant begin, end, rbegin and rend).

    Vous pouvez également revenir un Itérateur simple objet:

    template <class T>
class Iterator
{
public:
  typedef typename T::reference_type reference_type;

  Iterator(T it, T end) : m_it(it), m_end(end) {}

  operator bool() const { return m_it != m_end; }

  reference_type operator*() const { return *m_it; }

  Iterator& operator++() { ++m_it; return *this; }

private:
  T m_it;
  T m_end;
};

template <class T>
Iterator<T> make_iterator(T it, T end) { return Iterator<T>(it,end); }

    Ensuite, vous pouvez simplement retourner ce simple objet:

    class Action
{
public:
  Action(std::deque<Move> const& d): m_deque(d) {} //const& please

  typedef Iterator< std::deque<Move>::iterator > forward_iterator_type;
  typedef Iterator< std::deque<Move>::reverse_iterator > backward_iterator_type;

  forward_iterator_type forward_iterator()
  {
    return make_iterator(m_deque.begin(), m_deque.end());
  }

  backward_iterator_type backward_iterator()
  {
    return make_iterator(m_deque.rbegin(), m_deque.rend());
  }


private:
  std::deque<Move> m_deque;
};

    Ou si vous voulez choisir dynamiquement entre l'avant et l'arrière de la traversée, vous pourriez faire Itérateur un pur interface virtuelle et ayant à la fois en avant et en arrière de la traversée.

    Mais vraiment, je ne vois vraiment pas le point de stockage à la FOIS en avant et en arrière itérateur si il semble que vous n'utilisera qu'un seul :/

    • J'aime bien cette solution, et elle pourrait être un bon exercice d'apprentissage pour moi. La raison pour stocker à la fois les itérateurs est parce que le "GetCurrentMove() est appelée à partir d'un endroit différent dans l'application à l'Avance(). J'ai donc besoin d'un endroit pratique pour stocker le "courant de déplacement".
    • C'est normalement le rôle de l'itérateur, bien que la mise en œuvre de 2 différents objets en C++, mais il permet d'économiser la place et mimicks de l'arithmétique des pointeurs, c'est assez gênant je pense. L'Itérateur ci-dessus est inspiré de Python > un seul objet de maintenir à la fois sa position actuelle et le point de fin. Dans votre application, vous n'avez pas besoin de passer toutes les Action classe, vous avez seulement besoin de passer le Iterator (ou si vous avez été à faire directement référence à la deque les itérateurs, la position actuelle et la fin). De cette façon, vous la promotion de découplage 🙂
    InformationsquelleAutor Matthieu M.
  5. 0

    Peut-être vous devriez revoir votre choix du conteneur.

    Habituellement, vous n'avez pas besoin d'inverser les itérateurs pour revenir en arrière,

    currentfwd--

    permettra de revenir en arrière, tous les mais il pourrait ne pas fonctionner (qui je suppose que vous avez essayé) avec dequeue.

    Ce que vous devriez vraiment faire est le modèle de votre classe ici en tant que décorateur de retirer et à mettre en œuvre votre propre Action des itérateurs. Ce serait ce que je ferais de toute façon.

    • Merci Charles. Le problème avec une arrière est Fini() fonction - j'ai besoin de savoir quand je suis l'un avant le premier élément ( c'est à dire avoir passé le "rend()" ).
    InformationsquelleAutor Charles