Wie kann ich meine eigenen comparator für eine Karte?

typedef map<string, string> myMap;

Beim einfügen eines neuen paar zu myMap zu verwenden, wird der Schlüssel string zu vergleichen, durch seine eigene string-Vergleicher. Ist es möglich, dass überschreiben Komparator? Zum Beispiel würde ich gerne vergleichen Sie die Taste string durch seine Länge, nicht durch das alphabet. Oder gibt es irgendeine andere Möglichkeit zum Sortieren der Karte?

InformationsquelleAutor Xitrum | 2011-04-20
  1. 118

    std::map dauert bis zu vier template-Typ-Argumente, die Dritte wird ein Komparator. E. g.:

    struct cmpByStringLength {
    bool operator()(const std::string& a, const std::string& b) const {
        return a.length() < b.length();
    }
};

//...
std::map<std::string, std::string, cmpByStringLength> myMap;

    Alternativ könnte man auch einen Komparator zu maps-Konstruktor.

    Beachten Sie jedoch, dass beim Vergleich von Länge können Sie nur eine Zeichenfolge von jeder Länge in der Karte als ein Schlüssel.

    • beachten Sie, dass wir verwenden können, multimap, wenn wir wollen, zu enthalten duplizierte Schlüssel
    • jede chance, die Sie Sie ein Beispiel geben, übergeben comparitor an den Konstruktor?
    • Es sieht nicht viel anders: std::map<std::string, std::string> myMap(cmpByStringLength());
    • Ich hatte ein problem mit einer std::map<int, int>, einige mit aufsteigendem und andere in absteigender Reihenfolge. Ich habe nicht verwenden möchten, std::map<int, int, std::greater> und std::map<int, int, std::less> weil dann konnte ich nicht verwenden, Karten, die waren sortiert in verschiedenen Ordnungen, die als Parameter an eine einzige Funktion, es sei denn, ich machte alles ein template. Ich fand, dass ich hatte zu tun, die folgenden: typedef std::map<int, int, (bool)*(int, int)> mymap; Dann war ich in der Lage zu gehen in den Funktionen. Ich habe Folgendes versucht, aber es würde nicht funktionieren: typedef std::map<int, int> mymap; mymap-Karte 1(std::less); mymap map2(std::greater);
    • Das wäre std::map<int,int> m(std::less()); - beachten Sie die Klammern. Sie definitiv nicht brauchen Funktionszeiger. Wenn Sie laufen in Probleme, am besten stellen Sie eine neue Frage.
    • Das wird nicht funktionieren, für das bestehen der comparator an den Konstruktor, der als argument im Konstruktor muss eine Instanz des Komparator-Typ, und cmpByStringLength ist nicht eine Instanz von std::less<std::string>. Für eine Allgemeine Karte, die kann jeder haben Komparator set im Konstruktor, müssen Sie so etwas wie std::map<std::string, std::string, std::function<bool(const std::string &, const std::string &)>> myMap(cmpByStringLength);
    • wenn mit Karte diese Weise wird die Reihenfolge der Länge der Saiten gehalten werden, wenn wir die einfügen-string dynamisch?

    InformationsquelleAutor Georg Fritzsche
  2. 12

    Ja, die 3. Vorlagen-parameter auf map gibt der Komparator, der ein binäres Prädikat. Beispiel:

    struct ByLength : public std::binary_function<string, string, bool>
{
    bool operator()(const string& lhs, const string& rhs) const
    {
        return lhs.length() < rhs.length();
    }
};

int main()
{
    typedef map<string, string, ByLength> lenmap;
    lenmap mymap;

    mymap["one"] = "one";
    mymap["a"] = "a";
    mymap["fewbahr"] = "foobar";

    for( lenmap::const_iterator it = mymap.begin(), end = mymap.end(); it != end; ++it )
        cout << it->first << "\n";
}
    • Warum die Ableitung von std::binary_function? Ist es notwendig?
    • std::binary_function entfernt in c++17, so dass diese Antwort könnte wahrscheinlich verwenden, zu aktualisieren.
    InformationsquelleAutor John Dibling
  3. 10

    Seit C++11, Sie können auch eine lambda-Ausdruck statt der Festlegung eines Komparators struct:

    auto comp = [](const string& a, const string& b) { return a.length() < b.length(); };
map<string, string, decltype(comp)> my_map(comp);

my_map["1"]      = "a";
my_map["three"]  = "b";
my_map["two"]    = "c";
my_map["fouuur"] = "d";

for(auto const &kv : my_map)
    cout << kv.first << endl;

    Ausgabe:

    1

    zwei

    drei

    fouuur

    Möchte ich wiederholen Sie den letzten Hinweis von Georg ' s Antwort: Beim Vergleich von Länge können Sie nur eine Zeichenfolge von jeder Länge in der Karte als ein Schlüssel.

    Code auf Ideone

    InformationsquelleAutor honk
  4. 0

    Geben Sie den Typ des Zeigers zu Ihrem Vergleich-Funktion als 3. geben Sie in die Karte, und stellen Sie den Funktionszeiger auf der Karte Konstruktor:

    map<keyType, valueType, typeOfPointerToFunction> mapName(pointerToComparisonFunction);

    Werfen Sie einen Blick auf das Beispiel unten für die Bereitstellung eine Vergleich-Funktion, um eine map mit vector iterator als Schlüssel und int als Wert.

    #include "headers.h"

bool int_vector_iter_comp(const vector<int>::iterator iter1, const vector<int>::iterator iter2) {
    return *iter1 < *iter2;
}

int main() {
    //Without providing custom comparison function
    map<vector<int>::iterator, int> default_comparison;

    //Providing custom comparison function
    //Basic version
    map<vector<int>::iterator, int,
        bool (*)(const vector<int>::iterator iter1, const vector<int>::iterator iter2)>
        basic(int_vector_iter_comp);

    //use decltype
    map<vector<int>::iterator, int, decltype(int_vector_iter_comp)*> with_decltype(&int_vector_iter_comp);

    //Use type alias or using
    typedef bool my_predicate(const vector<int>::iterator iter1, const vector<int>::iterator iter2);
    map<vector<int>::iterator, int, my_predicate*> with_typedef(&int_vector_iter_comp);

    using my_predicate_pointer_type = bool (*)(const vector<int>::iterator iter1, const vector<int>::iterator iter2);
    map<vector<int>::iterator, int, my_predicate_pointer_type> with_using(&int_vector_iter_comp);


    //Testing 
    vector<int> v = {1, 2, 3};

    default_comparison.insert(pair<vector<int>::iterator, int>({v.end(), 0}));
    default_comparison.insert(pair<vector<int>::iterator, int>({v.begin(), 0}));
    default_comparison.insert(pair<vector<int>::iterator, int>({v.begin(), 1}));
    default_comparison.insert(pair<vector<int>::iterator, int>({v.begin() + 1, 1}));

    cout << "size: " << default_comparison.size() << endl;
    for (auto& p : default_comparison) {
        cout << *(p.first) << ": " << p.second << endl;
    }

    basic.insert(pair<vector<int>::iterator, int>({v.end(), 0}));
    basic.insert(pair<vector<int>::iterator, int>({v.begin(), 0}));
    basic.insert(pair<vector<int>::iterator, int>({v.begin(), 1}));
    basic.insert(pair<vector<int>::iterator, int>({v.begin() + 1, 1}));

    cout << "size: " << basic.size() << endl;
    for (auto& p : basic) {
        cout << *(p.first) << ": " << p.second << endl;
    }

    with_decltype.insert(pair<vector<int>::iterator, int>({v.end(), 0}));
    with_decltype.insert(pair<vector<int>::iterator, int>({v.begin(), 0}));
    with_decltype.insert(pair<vector<int>::iterator, int>({v.begin(), 1}));
    with_decltype.insert(pair<vector<int>::iterator, int>({v.begin() + 1, 1}));

    cout << "size: " << with_decltype.size() << endl;
    for (auto& p : with_decltype) {
        cout << *(p.first) << ": " << p.second << endl;
    }

    with_typedef.insert(pair<vector<int>::iterator, int>({v.end(), 0}));
    with_typedef.insert(pair<vector<int>::iterator, int>({v.begin(), 0}));
    with_typedef.insert(pair<vector<int>::iterator, int>({v.begin(), 1}));
    with_typedef.insert(pair<vector<int>::iterator, int>({v.begin() + 1, 1}));

    cout << "size: " << with_typedef.size() << endl;
    for (auto& p : with_typedef) {
        cout << *(p.first) << ": " << p.second << endl;
    }
}
    InformationsquelleAutor yyFred
Schreibe einen Kommentar