C++ - STL-map-container mit class-Schlüssel und Klasse Wert

Also angenommen ich habe eine Klasse wie diese:

class Point
{
   private:
      int x, y;
   public:
      void setX(int arg_x) { x = arg_x; }
      void sety(int arg_y) { y = arg_y; }
      int getX() const { return x; }
      int gety() const { return y; }
};

Nun möchte ich eine Karte wie diese:

map<Point, Point> m;

Aber ich brauche einen Dritten parameter. Ich lese in cplusplus, dass dieser Dritte parameter ist der Vergleich etwas, aber ich Verstand nicht, was dieses etwas war. Kann mir jemand erklären für mich?

  • wo wollen Sie einen Dritten parameter? Und was für? Möchten Sie Sie speichern 2 Punkte und etwas anderes in der Karte?
  • Wenn du gehst zu halten Sie die set - /get-Funktionen, dann benutzen Sie die öffentlichen Mitglieder: struct Point { int x, y; }; ist besser.
InformationsquelleAutor petermlm | 2011-08-07
  1. 22

    Erweitern Sie Ihre Klasse mit einer solchen Methode, wenn Sie brauchen nicht eine separate Funktion vergleichen

    class Point
{
   private:
      int x, y;
   public:

      bool operator<( const Point& other) const
      {
          if ( x == other.x )
          {
              return y < other.y;
          }

          return x < other.x;
      }
};

    Standardmäßig werden die stl-map ordnet alle Elemente in es von einigen Begriff von der Bestellung. In diesem Fall wird dieser operator verwendet wird. Manchmal ist Sie nicht die Kontrolle über den Punkt, Klasse oder möchten Sie vielleicht, um es in zwei unterschiedlichen Karten jeder definiert seine eigene Bestellung. Zum Beispiel eine Karte zu Sortieren Punkte, die von x den ersten und die anderen könnte man Sortieren nach y-ersten. So könnte es hilfreich sein, wenn der Vergleichsoperator ist unabhängig von der Klasse Punkt. Sie können so etwas wie dies tun.

    class Point
{
   public:
      int x, y;
};


struct PointComparer
{
    bool operator()( const Point& first , const Point& second) const
    {
        if ( first.x == second.x )
        {
            return first.y < second.y;
        }

        return first.x < second.x;
    }
};

map<Point, Point , PointComparer> m;
    • Danke!!! Das war sehr hilfreich.
    InformationsquelleAutor parapura rajkumar
  2. 9

    Was Sie brauchen, ist zu definieren eine Reihenfolge von Punkt-Elemente.

    Dies kann auf verschiedene Arten erfolgen :

    Überlastung der operator < für Punkt

    Können Sie eine überlastung der < Betreiber, deren Prototyp ist :

    bool operator < (const Point & p_lhs, const Point & p_rhs) ;

    Beispielsweise für meine tests habe ich folgende :

    bool operator < (const Point & p_lhs, const Point & p_rhs)
{
    if(p_lhs.getX() < p_rhs.getX()) { return true ; }
    if(p_lhs.getX() > p_rhs.getX()) { return false ; }
    return (p_lhs.getY() < p_rhs.getY()) ;
}

    Dies ist der einfachste Weg, aber es wird davon ausgegangen, semantisch, dass die Reihenfolge oben definiert, ist der rechts Standard-one.

    Bietet einen Funktor

    Wenn Sie nicht bereit sind, um eine < Betreiber, oder wollen Sie haben mehrere Karten, jede mit seiner eigenen Bestellung, Ihre Lösung ist ein Funktor auf der Karte. Dies ist die Dritte Vorlage definierten parameter für die Karte:

    template < class Key, class T, class Compare = less<Key>,
       class Allocator = allocator<pair<const Key,T> > > class map;

    Den Funktor muss folgende Signatur haben :

    struct MyCompareFunctor
{
    bool operator() (const Point & p_lhs, const Point & p_rhs)
    {
       //the code for comparison
    }
} ;

    So, für meine tests habe, schrieb ich einfach Folgendes :

    struct MyCompare
{
    bool operator() (const Point & p_lhs, const Point & p_rhs)
    {
        if(p_lhs.getX() > p_rhs.getX()) { return true ; }
        if(p_lhs.getX() < p_rhs.getX()) { return false ; }
        return (p_lhs.getY() > p_rhs.getY()) ;
    }
} ;

    Und es in meine map:

    std::map<Point, Point, MyCompare> map ;

    Et voilà...

    Spezialisiert std::less für Point

    Sehe ich keinen Sinn, dies zu tun, aber es ist immer gut zu wissen: Sie können sich spezialisieren, die std::less template-Struktur für Ihre Point Klasse

    #include <functional>

namespace std
{
    template<>
    struct less<Point> : binary_function <Point,Point,bool>
    {
        bool operator() (const Point & p_lhs, const Point & p_rhs)
        {
            if(p_lhs.getX() < p_rhs.getX()) { return true ; }
            if(p_lhs.getX() > p_rhs.getX()) { return false ; }
            return (p_lhs.getY() < p_rhs.getY()) ;
        }
    } ;
}

    Dies hat die gleiche Wirkung wie eine überlastung des operator <, zumindest so weit wie die Karte betroffen ist.

    Als für die operator < Lösung vor, semantisch, diese Lösung wird davon ausgegangen, dass die Reihenfolge oben definiert ist der richtige Standard ein so weit wie std:less betroffen ist.

    Beachten Sie, dass die Standard - std::less Implementierung ruft die operator < von den Vorlagen geben. Dass einer mit dem anderen Ergebnissen als die anderen betrachtet werden könnte als einen semantischen Fehler.

    InformationsquelleAutor paercebal
  3. 1

    Wenn Sie eine benutzerdefinierte Klasse als Schlüssel in std::map, um zu bestimmen, die position der Elemente im container die Karte braucht den Vergleich Klasse: Eine Klasse, die zwei Argumente nimmt die Schlüssel geben und einen bool zurückgibt.

    Es ist im Grunde ein Vergleich functor/Funktion vergleicht zwei wichtige Werte.

    • Danke!!! Dies war sehr hilfreich.
    InformationsquelleAutor Alok Save
  4. 0

    Brauchen Sie nicht Dritten parameter müssen Sie nur die operator== und operator<

    bool operator<(const Point& other) const{
      if ( x == other.x )
          return y < other.y;
      return x < other.x;
}
bool operator==(const Point& other) const{
      return x == other.x && y == other.y;
}
    • Sie brauchen nicht den = = - operator für die Karte
    • Sie brauchen nicht operator== für die bestellten Container.
    • vielen Dank., Ich war java zu tun in letzter Zeit und mischte Sie.
    • Danke!!! Dies war auch hilfreich!
    InformationsquelleAutor J-16 SDiZ
  5. 0

    Ich denke, der code oben gibt ein kleines upgrade zu @parapura rajkumar Lösungen.

    class Point{

    private:
        int x, y;

    public:
        bool operator<( const Point& other) const{
            return ((x < other.x) || (y < other.y));
        }
};
    • dies scheint nicht zu funktionieren, wenn x > anderen.x, wie es das Ergebnis von den Vergleich der y-Werte in diesem Fall. Als pinted heraus, indem Sie @user2963164, dessen Eingabe wurde abgelehnt, von anderen, obwohl es schien gültig.
    • diese Antwort wurde auf Basis der original-post. Ich werde Bearbeiten Sie es später korrigiert werden, für die bearbeitete version des awnser.
    InformationsquelleAutor thalesfc
  6. 0

    Was sagen Sie als Dritten parameter heißt "Komparator" in STL.
    Für Standard-Typen als Schlüssel youy nicht brauchen, um ein als compiler
    tut diese Arbeit für Sie.
    Aber für Ihre definierten Typen, die Sie haben, um anzugeben ODER sonst wie würde der compiler pflegen
    die Sortierung in anzeigen/einstellen etc.

    InformationsquelleAutor Player
Schreibe einen Kommentar