Itération sur la paire d'éléments dans un conteneur de paires (C++)

Si j'ai un conteneur (vector, list, etc) dont chaque élément est un std::pair, est-il un moyen facile pour effectuer une itération sur chaque élément de chaque paire?

c'est à dire

std::vector<std::pair<int,int> > a;
a.push_back(std::pair(1,3));
a.push_back(std::pair(2,3));
a.push_back(std::pair(4,2));
a.push_back(std::pair(5,2));
a.push_back(std::pair(1,5));

et d'être ensuite en mesure d'effectuer une itération sur la valeur: 1,3,2,3,4,2,5,2,1,5?

De même, ce type de foncteur/fonction serait de retour pour moi, un container (de même type) avec un plat de cotation de la paire d'éléments que ci-dessus?

std:paire ne nécessite pas de deux types de modèle à être du même type, de sorte qu'il n'a pas vraiment de sens d'avoir des méthodes pour faire ce que vous voulez essayer de faire.
Envisager de reconsidérer votre choix du conteneur. Semble que vous n'avez pas besoin d'une paire ici.

OriginalL'auteur Shamster | 2009-11-30

  1. 3

    Pour aplatir votre conteneur de paires dans un deuxième récipient, vous pouvez aussi tout simplement écrire votre propre insertion:

    template<class C>
struct Inserter {
    std::back_insert_iterator<C> in;
    Inserter(C& c) : in(c) {}
    void operator()(const std::pair<typename C::value_type, typename C::value_type>& p)
    {
        *in++ = p.first;
    *in++ = p.second;
    }
};

template<class C>
Inserter<C> make_inserter(C& c)
{ 
    return Inserter<C>(c); 
}

//usage example:
std::list<int> l;
std::for_each(a.begin(), a.end(), make_inserter(l));
    Nous allons tout simplement passer quelques moments en souhaitant que le C++ n'a coroutines, ce qui ferait 1->nombreux et nombreuses->1 itérateur adaptateurs un doddle, et signifie que vous pouvez simplement effectuer une itération sur les éléments souhaités, dans le même nombre de lignes de code, sans avoir à faire une copie de la liste. Ah, les coroutines.
    Ou simplement se rendre compte que les objets sont conceptuellement plus facile, et peut presque toujours remplacer les coroutines. Et ils sont en C++ depuis le début. Honnêtement, un co-routine juste bundles état+, et les classes en faire de même.
    Bien sûr, mais je parlais de lignes de code. Une coroutine n'est pas comme par magie tout faire d'une machine de Turing ne peut pas, mais il ne laisse vous yield sans avoir à enregistrer explicitement état, rappelez-vous où vous êtes à la hauteur, et puis faire un switch ou quoi que ce soit sur la ré-entrée de la fonction. Comme pour "conceptuellement plus facile" - meh. Coroutines peut faire de jolies choses cool avec le producteur-consommateur pipelines, ce qui est exactement ce que ces types de itérateur adaptateurs (ou plutôt ce qu'ils seraient, si elles n'ont pas été basés sur les classiques des appels de fonction).
    Qu'est ce qu'un doddle? Première fois que j'ai entendu ce mot, s'avère.

    OriginalL'auteur Georg Fritzsche

  2. 7

    Pour votre première, vous devez créer votre propre classe iterator, qui paires d'un indicateur indiquant le sein de la paire de position avec un container<pair> itérateur

    Pour le second, il est plus facile, mais pour être aussi général que vous voulez (conteneurs de même type), vous avez besoin d'un modèle de définition de type. Voici pour juste vecteur:

    template <class V>
std::vector<V> flatten_pairs(std::vector<std::pair<V,V> > const& a) {
  typedef std::vector<std::pair<V,V> > A;
  std::vector<V> ret;
  for (typename A::const_iterator i=a.begin(),e=a.end();i!=e;++i) {
    ret.push_back(i->first);
    ret.push_back(i->second);
  }
  return ret;
}

    Voici comment vous faux un modèle de définition de type:

    template <class C>
struct same_container;

template <class V>
struct same_container<std::vector<V> > {
  template <class W> struct rebind { typedef std::vector<W> type; };
};

template <class V>
struct same_list<std::list<V> > {
  template <class W> struct rebind { typedef std::list<W> type; };
};

template <class C>
typename same_container<C>::rebind<typename C::value_type::first_type>::type
flatten_pairs(C const& a);
    qui devrait être std::pair<V,V>
    Merci pour remarquer que - fixe.

    OriginalL'auteur Jonathan Graehl

  3. 5

    Le code suivant va imprimer toutes les valeurs requises:

    for ( size_t x = 0; x < a.size(); ++x ) {
    cout << a[x].first << "," << a[x].second << ",";
}

    Je préfère cette façon facile de créer des itérateur.

    En général je suis d'accord. Si votre récipient est déjà sur le plan conceptuel (et réellement) la tenue de paires, puis l'utiliser comme si vous sont conceptuellement la tenue de paires. Si il y a une raison de penser que c'est un tableau 1D, utiliser un récipient et de la méthode d'accès qui suit conceptuel de paradigme. Si vous avez besoin de penser d'une manière en un seul endroit et une autre manière d'ailleurs, ne vous inquiéter au sujet de cartes ou spécial itérateurs ou de transformations ou quoi que ce soit, et seulement si vous avez une très bonne raison de ces divergences de façons de penser au sujet de vos données.

    OriginalL'auteur Kirill V. Lyadvinsky

  4. 1

    Il n'y a pas de moyen simple d'effectuer l'itération que vous voulez, mais vous voudrez peut-être prendre un coup d'oeil à l'boost::iterator_adaptor de la bibliothèque ou de mettre en œuvre votre propre itérateur de le faire (il ne devrait pas être trop complexe). Ensuite, sur la deuxième question, vous pouvez utiliser std::copie avec votre nouvel itérateur adaptateur.

    OriginalL'auteur David Rodríguez - dribeas

  5. 1

    Non, il n'y a vraiment pas une telle chose pour std::pair. Vous pouvez envisager d'utiliser un coup de pouce Tuple à la place. Un tuple est un peu comme une version élargie de std::pair qui permet à un nombre arbitraire d'éléments (jusqu'à une certaine limite, mais normalement, au moins 10), et donne accès aux éléments de quelque chose comme un vecteur/matrice (c'est à dire vous pouvez accéder aux éléments par nom ou l'index).

    TR1 comprend également std::tr1::tuple, qui est un sous-ensemble de Boost n-uplet, mais si ma mémoire est bonne, il ne comprend toujours le nom/l'indice de la fonctionnalité que vous demandez.

    Edit: notez que dans les deux cas, l'indice de notation nécessite un au moment de la compilation constante de l'indice, de sorte que vous ne pouvez pas écrire un (run-time) de la boucle d'itération sur les éléments d'un tuple -- mais vous pouvez faire le travail avec un peu de métaprogrammation. Boost de fusion comprend un peu à l'appui de ce que vous auriez besoin (par une étrange coïncidence, un tuple est une partie de la fusion de la bibliothèque).

    OriginalL'auteur Jerry Coffin

  6. 0

    À un certain point, vous devez utiliser première et deuxième, même si vous créez votre propre classe iterator. Je ne pense pas qu'il y a un moyen d'en sortir (au moins, d'une manière portable).

    OriginalL'auteur Leandro T. C. Melo