C++ stl:：multimap-如何获取数据组？

Multimap本质上具有按键排序的数据组。我想要一种方法，通过它我可以访问这些单独的组并获得它们的聚合值。 例如，在

std:：multimap

I存储

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

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

---

存储了这些值之后，我应该能够迭代这个多重映射，并获得每个“组”的聚合值。问题是STL中并没有定义任何函数以这种方式访问多重映射。我可以使用

下限

，

上限

手动迭代多重映射并合计组的内容，但我希望STL中已经定义了更好的方法？在上面的示例中，有人能提出一个解决方案来说明如何获取组的聚合值。

如果您已经知道键，可以使用

multimap:：equal_range

将迭代器获取到组的开头和结尾；使用任何标准算法从范围中获得所需的结果。如果您不知道密钥，可以从

begin（）

开始，自己迭代，比较密钥以找到每个新组的开始。

pair range=my_multimap.equal_range（“Group1”）；
pair<Iter, Iter> range = my_multimap.equal_range("Group1");
int total = accumulate(range.first, range.second, 0);

int total=累加（range.first，range.second，0）；

这是一种方法

编辑：

如果您不知道要查找的组，并且只是浏览每个组，则可以这样获得下一组的范围：

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>());

模板
无结构：公共标准：：二进制函数
{
布尔运算符（）（常数对&x，常数对&y）常数
{
返回x.first

不是多重映射答案，但如果您选择，可以执行以下操作

#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";
        }
    }
}

#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
使用名称空间boost；
使用名称空间boost:：assign；
int main（）{
typedef地图收集；
集合m；
m[“第1组”]=第（1）（2）（3）项清单；
m[“第2组”]=第（10）（11）（12）项清单；
集合：：迭代器g2=m.find（“组2”）；
如果（g2！=m.end（））{
提升速度（整数和整数，g2->秒）{
cout您可以使用另一个容器，该容器可以包含每个组的总和。为此，您可以执行以下操作：

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

模板
结构组添加{
类型定义映射类型；
地图类型和集合；
显式组添加（映射类型和聚合）
：聚合（聚合）{}；
void运算符（）（映射类型：：值类型常量和元素）{
聚合[element.first]+=element.second；
};
};
样板
组添加
生成组加法器（映射和映射）{
返回组添加（映射）；
};
// ...
多地图成员；
//填充成员
map组集合；
对于每个（members.begin（）、members.end（），
生成组加法器（组集合）；
//组集合现在具有每个组的总和

当然，如果您有Lambda（在C++0x中），它可能更简单：

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;
  }
  );

多映射成员；
map组集合；
对于每个（members.begin（）、members.end（），
[&组集合]（多重映射：：值类型常量和元素）{
组_聚合[element.first]+=element.second；
}
);
//samekey.cpp--在多重映射中使用相同键的进程组
#包括
#包括
#包括
使用名称空间std；
typedef多重映射StringToIntMap；
typedef StringToIntMap:：迭代器映射器；
int main（）
{
StringToIntMap mymap；
mymap.insert（make_pair（“Group2”，11））；
mymap.insert（配对（“组1”，3））；
mymap.insert（配对（“组2”，10））；
mymap.insert（配对（“组1”，1））；
mymap.insert（配对（“组2”，12））；
mymap.insert（配对（“组1”，2））；
库特
语法：

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

#包括
配对相等范围（常数键类型和键）；

函数
equal_range（）
返回两个迭代器-一个到包含键的第一个元素，另一个到包含键的最后一个元素后面的一个点。
是否应该是
x.first==y.first；
？为什么使用
运算符，这似乎是一个错误。
相邻的\u find
要求“相等”谓词。另外，我确信有
std:：equal_to
可供使用。@leems我相信您的编辑会将行为更改为不正确的行为。“小于”操作符应该在更改键之前找到最后一个元素（可以是
将
d前进1到具有新键的第一个元素），而使用相等运算符时，它只会将迭代器返回到相同的（
first
）元素。我已将最后一次编辑回滚到原始@Greg的版本非常优雅且lambda方法，如下所述：
equal_range

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