C++ STL carte conteneur avec une touche classe et la classe de la valeur

Supposons donc que j'ai une classe comme celle-ci:

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

Maintenant, je veux avoir une carte comme celle-ci:

map<Point, Point> m;

Mais j'ai besoin d'un troisième paramètre. J'ai lu dans cplusplus que ce troisième paramètre est à comparer à quelque chose, mais je n'ai pas compris ce que quelque chose a été. Quelqu'un peut-il expliquer que pour moi?

où voulez-vous un troisième paramètre? Et pour quoi? Voulez-vous stocker 2 points et quelque chose d'autre dans la carte?
Si vous allez garder le set/get fonctions, puis utilisez le public et les membres: struct Point { int x, y; }; est mieux.

OriginalL'auteur petermlm | 2011-08-07

c++containers map

Vous pouvez étendre votre classe avec une telle méthode si vous n'avez pas besoin d'un autre fonction de comparaison

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

Par défaut, la stl carte ordres de tous les éléments, par quelque notion de la commande. Dans ce cas, cet opérateur est utilisé. Parfois, vous n'avez pas le contrôle sur la classe Point ou vous pouvez l'utiliser de deux cartes différentes, chacun définit ses propres commandes. Par exemple, une carte peut trier les points de x en premier et d'autres on peut trier par y le premier. Il pourrait donc être utile si l'opérateur de comparaison est indépendante de la classe Point. Vous pouvez faire quelque chose comme cela.

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;

Merci!!!! Cela a été très utile.

OriginalL'auteur parapura rajkumar

Ce que vous avez besoin est de définir une commande de Point d'éléments.

Cela peut être fait de différentes façons :

Surcharge de la `operator <` pour Point

Vous pouvez fournir une surcharge de la < de l'opérateur, dont le prototype est :

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

Par exemple, pour mes tests, j'ai utilisé la suivante :

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

C'est le moyen le plus facile, mais il suppose, du point de vue sémantique, que l'ordre défini ci-dessus est le droit par défaut.

Fournir un foncteur

Si vous refusez de fournir un < opérateur, ou si vous voulez avoir plusieurs cartes, chacune avec sa propre commande, votre solution est de fournir un foncteur de la carte. C'est le troisième paramètre de modèle défini pour la carte:

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

Le foncteur doit avoir la signature suivante :

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

Donc, pour mes tests, j'ai juste écrit ce qui suit :

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

Et l'a utilisé dans ma carte:

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

Et voilà...

Spécialisée `std::less` pour `Point`

Je vois pas l'intérêt de le faire, mais c'est toujours bon à savoir: vous pouvez Vous spécialiser le std::less modèle de structure pour votre Point classe

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

Cela a le même effet que la surcharge de l' operator <, au moins, autant que la carte est concerné.

Comme pour le operator < solution ci-dessus, du point de vue sémantique, cette solution suppose que l'ordre défini ci-dessus est le droit par défaut, en ce qu'std:less.

Notez que la valeur par défaut std::less la mise en œuvre nécessite la operator < de l'est basé sur un modèle type. Avoir un donnant des résultats différents que l'autre pourrait être considéré comme une erreur sémantique.

OriginalL'auteur paercebal

1

Lorsque vous utilisez une classe définie par l'utilisateur comme un élément clé pour std::map, afin de déterminer la position des éléments dans le conteneur de la carte des besoins de la Comparaison de classe: Une classe qui prend deux arguments de type de clé et retourne un booléen.

C'est, en gros, une comparaison foncteur/fonction qui compare deux valeurs clés.

Merci!!!! Cela a été très utile.

OriginalL'auteur Alok Save
0

Vous n'avez pas besoin de troisième paramètre, vous avez juste besoin de la operator== et 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;
}
```
Vous n'avez pas besoin d'opérateur == pour la carte
Vous n'avez pas besoin operator== à l'ordre des conteneurs.
merci., Je faisais java dernièrement et a été le mélange.
Merci!!!! Cela a aussi été très utile!

OriginalL'auteur J-16 SDiZ
0

Je pense que le code ci-dessus donne un peu de mise à niveau à @parapura rajkumar solutions.
```
class Point{

    private:
        int x, y;

    public:
        bool operator<( const Point& other) const{
            return ((x < other.x) || (y < other.y));
        }
};
```
cela ne semble pas fonctionner si x > autres.x, comme il sera de retour le résultat de la comparaison des valeurs de y dans ce cas. Comme pointes, par @user2963164 dont le montage a été rejetée par d'autres, même s'il semblait valable.
cette réponse a été basée sur le post original. J'éditerai plus tard pour être corrigé pour la version éditée de la awnser.

OriginalL'auteur thalesfc
0

Ce que vous dites en tant que troisième paramètre est dit "de référence" dans la STL.
Pour les types par défaut que les clés youy n'avez pas besoin de fournir un comme compilateur
fait ce travail pour vous.
Mais pour les types définis par vous avoir à les fournir, OU autre, comment le compilateur maintenir
l'ordre de tri de carte/jeu etc.

OriginalL'auteur Player

Vous devez vous connecter pour publier un commentaire.

Surcharge de la operator < pour Point

Fournir un foncteur

Spécialisée std::less pour Point

Surcharge de la `operator <` pour Point

Spécialisée `std::less` pour `Point`