Danke

#include <unordered_map>

int main()
{
    std::unordered_multimap<int,int> myumm({{1,3},{3,2},{5,5},{0,9}});
    auto first = myumm.begin();
    auto second = first+1;
    auto third = --myumm.end();
    auto fourth = myumm.end();
}

ich habe das erste Bsp. erweitert. Der Sinn dahinter ist immer 2 Elemente einer unordered_map mit den letzten beiden zu vergleichen. Wenn gleich, dann ist die Schleife zu Ende. Leider kompiliert das Bsp. nicht.

Wie würdet ihr iterieren?

#include <functional>
#include <iostream>
#include <boost/iterator/zip_iterator.hpp>
#include <boost/tuple/tuple.hpp>

int main()
{
    std::unordered_multimap<int,int> myumm({{1,3},{3,2},{5,5},{0,9}});

    auto first = myumm.begin();
    auto second = std::next(first,1);
    auto third = std::next(first,myumm.size()-1);
    auto fourth = myumm.end();

    std::for_each (
        boost::make_zip_iterator (
            boost::make_tuple(first,second)
        )
      , boost::make_zip_iterator (
            boost::make_tuple(third, fourth)
        )
      , [] (
            boost::tuple <
                std::unordered_multimap<int,int>::iterator
              , std::unordered_multimap<int,int>::iterator
            > const & _layout
        ) {
        }
    );
}

Fehlermeldung

/usr/include/boost/tuple/detail/tuple_basic.hpp:310:37: error: no matching
      constructor for initialization of 'stored_head_type' (aka
      'std::__detail::_Node_iterator<std::pair<const int, int>, false, false>')
  cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}

Zum Anwendungsfall:
Das erste Element des o.g. myumm ergibt mit dem Wert des Nächsten die Größe mehrerer Matrizen z.B. a0 = start->first X next->first, a1 = start->first X 1, ..., b0 = ++start->first X ++next->first, ..., usw.

Wie der Name sagt, sind die Elemente unsortiert, d.h. jedes mit jedem muss eine Matrix ergeben und auch noch sinnvoll sein. Damit willst du wohl eher ein Vector oder eine normale map.

Ob die unordered_map Sinn macht wird an anderer Stelle geprüft.

Verstehe ich nicht.
Die unordered_map kann keinen Sinn machen wenn du eine bestimmte Reihenfolge brauchst.
D.h. wenn map nicht geht weil es die Einträge sortiert (und damit deren Reihenfolge ändert), dann kann unordered_map aus dem selben Grund nicht gehen.