ein C ++ hash map dass bewahrt die Reihenfolge der Einfügung [Duplizieren]

Question

    

Diese Frage bereits eine Antwort hier:

    

        
•              A std :: Karte, die den Überblick über die Reihenfolge der Einfügungen?                                      14 Antworten                          
    

    

Ich habe den folgenden Code:

#include <iostream>
#include "boost/unordered_map.hpp"

using namespace std;
using namespace boost;

int main()
{

    typedef unordered_map<int, int> Map;
    typedef Map::const_iterator It;

    Map m;
    m[11] = 0;
    m[0]  = 1;
    m[21] = 2;

    for (It it (m.begin()); it!=m.end(); ++it)
        cout << it->first << " " << it->second << endl;

    return 0;
}

Aber ich bin auf der Suche nach etwas, das bewahrt die Ordnung, so dass später kann ich die Elemente in der gleichen Reihenfolge durchlaufen, in denen sie eingesetzt wurden. Auf meinem Computer erhält der oben genannte Code nicht die Reihenfolge, und druckt die folgende:

 0 1
11 0
21 2

Ich dachte, vielleicht könnte ich ein boost::multi_index_container verwenden

typedef multi_index_container<
    int,
    indexed_by<
        hashed_unique<identity<int> >,
        sequenced<>
    >
> Map;

Kann jemand mir zeigen, wie mein Original-Code mit diesem Behälter (oder einem anderen geeigneten Behälter) zu implementieren, so dass der Iterator die Reihenfolge der Einfügung folgt?

Answer 1

#include <iostream>
#include "boost/unordered_map.hpp"

#include <boost/multi_index_container.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>

using namespace std;
using namespace boost;
using namespace boost::multi_index;


struct key_seq{};
struct key{};

struct Data_t
{
    int key_;
    int data_;
    Data_t (int key_v, int data_v) : key_(key_v), data_(data_v) {}
};

int main()
{
    typedef multi_index_container<
        Data_t,
        indexed_by<
            hashed_unique<tag<key>,  BOOST_MULTI_INDEX_MEMBER(Data_t,int,key_)>,
            sequenced<tag<key_seq> >
        >
    > Map;

    typedef Map::const_iterator It;

    typedef index<Map,key>::type Map_hashed_by_key_index_t;
    typedef index<Map,key>::type::const_iterator  Map_hashed_by_key_iterator_t;

    typedef index<Map,key_seq>::type Map_sequenced_by_key_index_t;
    typedef index<Map,key_seq>::type::const_iterator  Map_sequenced_by_key_iterator_t;

    Map m;
    m.insert(Data_t(11,0));
    m.insert(Data_t(0,1));
    m.insert(Data_t(21,1));

    {
        cout << "Hashed values\n";
        Map_hashed_by_key_iterator_t i = get<key>(m).begin();
        Map_hashed_by_key_iterator_t end = get<key>(m).end();
        for (;i != end; ++i) {
            cout << (*i).key_ << " " << (*i).data_ << endl;
        }
    }

    {
        cout << "Sequenced values\n";
        Map_sequenced_by_key_iterator_t i = get<key_seq>(m).begin();
        Map_sequenced_by_key_iterator_t end = get<key_seq>(m).end();
        for (;i != end; ++i) {
            cout << (*i).key_ << " " << (*i).data_ << endl;
        }
    }

    return 0;
}

Answer 2

Sie können versuchen, eine geordnete Karte zu schaffen, die Kombination von Karte und dem Vektor verwendet wird.

• Vector kann das Paar Schlüssel halten und Wert.
• Vector kann Iterator verwendet werden, wie Iterator bestellt Karte zu durchqueren.
• kann kartieren Zugang können die Elemente schneller.