stl::multimap - comment puis-je obtenir des groupes de données?

Multimap a essentiellement pour des groupes de données triée par la clé. Je veux une méthode par laquelle j'ai pu accéder à ces différents groupes et obtenez le total de leurs valeurs.
Par exemple, dans un std::multimap< string, int > je magasin 

{"Group1", 1}, 
{"Group1", 2}, 
{"Group1", 3}, 

{"Group2", 10}, 
{"Group2", 11}, 
{"Group2", 12}

L'avoir stocké ces valeurs, je devrais être capable de parcourir cette multimap et d'obtenir la somme des valeurs de chaque "groupe". Le problème est qu'il ne sont pas toutes les fonctions définies dans la STL pour l'accès MultiMaps dans une telle voie. Je pourrais utiliser lower_bound, upper_bound manuellement effectuer une itération de la multi-table et total le groupe a du contenu, mais j'espère qu'il pourrait y avoir de meilleures façons déjà défini dans la STL ? Quelqu'un peut-il proposer une solution à comment je pourrais obtenir la somme des valeurs d'un groupe dans l'exemple ci-dessus.

InformationsquelleAutor the_Saint | 2008-10-29
  1. 39
    pair<Iter, Iter> range = my_multimap.equal_range("Group1");
int total = accumulate(range.first, range.second, 0);

    Est une.

    Edit:

    Si vous ne connaissez pas le groupe, vous êtes à la recherche pour, et sont tout simplement en passant par chaque groupe, obtenir la prochaine gamme du groupe peut être fait comme suit:

    template <typename Pair>
struct Less : public std::binary_function<Pair, Pair, bool>
{
    bool operator()(const Pair &x, const Pair &y) const
    {
        return x.first < y.first;
    }
};

Iter first = mmap.begin();
Iter last = adjacent_find(first, mmap.end(), Less<MultimapType::value_type>());
    • Ne devrait-elle pas être x.first == y.first;? Pourquoi avez-vous utilisé operator<? Selon le document de adjacent_find, le prédicat paramètre doit retourner le résultat de la comparaison avec la vraie (non nulle), ce qui signifie qu'ils doivent être considérés comme égaux, et false (zéro) pour les non-égalité. Pourquoi êtes-vous de retourner true pour les non-égalité de résultat?
    • Oui, cela semble être une erreur. adjacent_find s'attend à une "égalité" de prédicat. Aussi, je suis sûr qu'il est std::equal_to<T> prêt à l'emploi.
    • Je crois que votre éditer les modifications du comportement incorrect. "Moins que" l'opérateur est censé trouver le dernier élément avant de la clé est changé (ce qui pourrait être advanced par 1 pour le premier élément avec la nouvelle clé), tandis qu'avec l'opérateur d'égalité, il sera juste de retour d'itérateur à la même (first) de l'élément
    • J'ai roulé la dernière édition de l'original @Greg version
    InformationsquelleAutor Greg Rogers
  2. 21
    //samekey.cpp -- Process groups with identical keys in a multimap

#include <iostream>
#include <string>
#include <map>
using namespace std;

typedef multimap<string, int> StringToIntMap;
typedef StringToIntMap::iterator mapIter;

int main ()
{
    StringToIntMap mymap;

    mymap.insert(make_pair("Group2", 11));
    mymap.insert(make_pair("Group1",  3));
    mymap.insert(make_pair("Group2", 10));
    mymap.insert(make_pair("Group1",  1));
    mymap.insert(make_pair("Group2", 12));
    mymap.insert(make_pair("Group1",  2));

    cout << "mymap contains:" << endl;

    mapIter m_it, s_it;

    for (m_it = mymap.begin();  m_it != mymap.end();  m_it = s_it)
    {
        string theKey = (*m_it).first;

        cout << endl;
        cout << "  key = '" << theKey << "'" << endl;

        pair<mapIter, mapIter> keyRange = mymap.equal_range(theKey);

        //Iterate over all map elements with key == theKey

        for (s_it = keyRange.first;  s_it != keyRange.second;  ++s_it)
        {
           cout << "    value = " << (*s_it).second << endl;
        }
    }

    return 0;

}   // end main

//end samekey.cpp
    InformationsquelleAutor
  3. 10

    Si vous connaissez déjà les touches, vous pouvez utiliser multimap::equal_range pour obtenir les itérateurs de début et de fin du groupe; utiliser tout algorithme standard pour obtenir les résultats souhaités à partir de la plage. Si vous ne connaissez pas les touches, vous pouvez commencer à begin() et parcourir vous-même, en comparant les clés pour trouver le début de chaque nouveau groupe.

    InformationsquelleAutor Mark Ransom
  4. 1

    Vous pouvez utiliser un autre récipient qui peut contenir la somme des montants de chaque groupe. Pour ce faire, vous pourriez faire quelque chose comme:

    template <class KeyType, class ValueType>
struct group_add {
  typedef map<KeyType, ValueType> map_type;
  map_type & aggregates;
  explicit group_add(map_type & aggregates_)
    : aggregates(aggregates_) { };
  void operator() (map_type::value_type const & element) {
    aggregates[element.first] += element.second;
  };
};

template <class KeyType, class ValueType>
group_add<KeyType, ValueType>
make_group_adder(map<KeyType, ValueType> & map_) {
  return group_add<KeyType, ValueType>(map_);
};

//...
multimap<string, int> members;
//populate members
map<string, int> group_aggregates;
for_each(members.begin(), members.end(),
  make_group_adder(group_aggregates));
//group_aggregates now has the sums per group

    Bien sûr, si vous avez Lambda (en C++0x) il pourrait être plus simple:

    multimap<string, int> members;
map<string, int> group_aggregates;
for_each(members.begin(), members.end(),
  [&group_aggregates](multimap<string, int>::value_type const & element) {
    group_aggregates[element.first] += element.second;
  }
  );
    InformationsquelleAutor Dean Michael
  5. 0
    equal_range

    Syntaxe:

    #include <map>
pair<iterator, iterator> equal_range( const key_type& key );

    La fonction equal_range() retourne deux itérateurs - l'un pour le premier élément qui contient la clé, l'autre à un point juste après le dernier élément qui contient la clé.

    InformationsquelleAutor Hayek.Yu
  6. -1

    Pas une multimap réponse, mais vous pouvez faire ce qui suit si vous le souhaitez.

    #include <iostream>
#include <vector>
#include <map>
#include <string>
#include <boost/assign/list_of.hpp>
#include <boost/foreach.hpp>
using namespace std;
using namespace boost;
using namespace boost::assign;

int main() {
    typedef map<string, vector<int> > collection;
    collection m;
    m["Group 1"] = list_of(1)(2)(3);
    m["Group 2"] = list_of(10)(11)(12);
    collection::iterator g2 = m.find("Group 2");
    if (g2 != m.end()) {
        BOOST_FOREACH(int& i, g2->second) {
            cout << i << "\n";
        }
    }
}
    InformationsquelleAutor Shadow2531