Comment puis-je surcharge le comparer opérateur pour un ensemble de paires?

Comment puis-je la surcharge et passer un < (moins de) comparateur à un ensemble de paires d'entiers? Voici mon code actuel:

class A{
public:
    typedef std::pair<int, int> pair_type;  

    bool operator<(const pair_type& a, const pair_type& b){ 
        if (a.first < b.first) return true;
        else if ( (a.first == b.first) && (a.second < b.second) ) return true;
        else return false;
    }

private:
    std::set< pair_type > edge_;
};

Si j'essaie de compiler ce code, j'obtiens l'erreur suivante:

error: 'bool A::operator<(const pair_type&, const pair_type&)' must take exactly one argument

Comment puis-je résoudre ce problème?

InformationsquelleAutor Pippi | 2013-02-28
  1. 5
    class A{
public:
    typedef std::pair<int, int> pair_type;  

    struct compare {
        bool operator()(const pair_type& a, const pair_type& b) {
          if (a.first < b.first) return true;
          else if ( (a.first == b.first) && (a.second < b.second) ) return true;
          else return false;
        }   
    };

  private:
    std::set<pair_type, compare> edge_;
};
    • Pourquoi devons-nous mettre l'opérateur à l'intérieur d'une structure ?
    InformationsquelleAutor smossen
  2. 4

    Vous devez être definining la surcharge de l'opérateur en tant que membre de la classe (avec un seul paramètre, généralement une autre instance de la même classe):

    class pair_type : public std::pair<int, int>
{
public:
    bool operator<(const pair_type &comp) const
    {
        if (this->first < comp.first) return true;
        else if ( (this->first == comp.first) && (this->second < comp.second) ) return true;
        else return false;
    }
};
    • Les opérateurs de comparaison ne doit jamais être les fonctions de membres. La technique la plus appropriée est de la déclarer comme un "ami" de l'opérateur prenant deux arguments du même type.
    • Ah, merci, vous avez raison. Je dois admettre à l'aide de la fonction de membre de version le plus souvent, mais il est logique d'utiliser la fonction friend comme il est expliqué plus en détail ici lien
    InformationsquelleAutor Derek
  3. 2

    Votre opérateur doit être libre de la fonction (qui n'est pas membre-fonction), car il n'a pas toutes les relations de A classe.

    InformationsquelleAutor ForEveR
  4. 1

    Depuis C++11, vous pouvez également utiliser un expression lambda au lieu de définir un comparateur struct:

    using pair_type = std::pair<int, int>;

auto comp = [](const pair_type& a, const pair_type& b) {
    return (a.first < b.first) || ((a.first == b.first) && (a.second < b.second));
};

    J'ai aussi compacté votre comparateur de code afin de sauver deux lignes. Maintenant, vous pouvez définir votre défini de la manière suivante:

    std::set<pair_type, decltype(comp)> edge_(comp);

    Toutefois, si vous voulez utilisez le comparateur pour un jeu qui est un membre de la classe, alors c'est un peu moins à l'aise, parce que vous avez à passer le comparateur également à la constructeur de l'ensemble, comme indiqué ci-dessus.
    Ce qui signifie, vous l'avez à portée de main sur le comparateur dans la liste d'initialiseur de l'constructeur définition:

    class A{
public:
    A() : edge_(comp) {}

private:
    std::set<pair_type, decltype(comp)> edge_;
};

    Code sur Ideone

    InformationsquelleAutor honk