Парная операторная перегрузка для вставки в набор - PullRequest
Новая
       32

Парная операторная перегрузка для вставки в набор

3 голосов
/ 24 марта 2012

Я пытаюсь добавить pair<int,int> к набору.Если пара имеет те же два значения, что и другое в наборе, она не должна быть вставлена.

Вот мой нерабочий код: 

typedef  std::pair<int, int> PairInt;

template<>
bool std::operator==(const PairInt& l, const PairInt& r) 
{
    return (l.first == r.first && l.second == r.second) ||
           (l.first == r.second && l.second == r.first);
}

int main()
{
    std::set<PairInt> intSet;
    intSet.insert(PairInt(1,3));
    intSet.insert(PairInt(1,4));
    intSet.insert(PairInt(1,4));
    intSet.insert(PairInt(4,1));
}

На данный момент (4,1) пара добавляется, хотя пара уже существует (1,4).Окончательное содержимое набора: 

(1 3)
(1 4)
(4 1)

, и я хочу, чтобы оно было 

(1 3)
(1 4)

Я пытался установить точки останова в перегруженном методе, но они никогда не достигаются.Что я сделал не так?

Ответы [ 3 ]

3 голосов
/ 24 марта 2012

Наборы основаны на operator< (отношение упорядоченности / эквивалентности), а не operator== (что является отношением равенства).

Чтобы сделать то, что вы пытаетесь сделать, используйте пользовательский компаратор: 

#include <set>
#include <utility>
#include <cassert>
typedef std::pair<int, int> PairInt;
PairInt normalize(const PairInt& p) {
    return p.second < p.first ? PairInt(p.second, p.first) : p;
}
struct Comparator {
    bool operator()(const PairInt& l, const PairInt& r) const {
        //Compare canonical forms of l and r.
        return normalize(l) < normalize(r);
    }
};

int main()
{
    std::set<PairInt, Comparator> intSet;
    intSet.insert(PairInt(1,3));
    intSet.insert(PairInt(1,4));
    intSet.insert(PairInt(1,4));
    intSet.insert(PairInt(4,1));
    assert(intSet.size() == 2);
}
2 голосов
/ 24 марта 2012

Вам нужно будет предоставить функцию сравнения для просмотра одного элемента меньше, чем другого, а не для определения, равны ли они. Вот полный пример: 

#include <utility>
#include <algorithm>
#include <set>
#include <iostream>

typedef  std::pair<int, int> PairInt;
typedef bool Compare(const PairInt &,const PairInt &);

bool compare(const PairInt &l,const PairInt &r)
{
  int lfirst = std::min(l.first,l.second);
  int rfirst = std::min(r.first,r.second);
  if (lfirst<rfirst) return true;
  if (rfirst<lfirst) return false;
  return std::max(l.first,l.second)<std::max(r.first,r.second);
}

int main()
{
  typedef std::set<PairInt,Compare*> IntSet;
  IntSet intSet(compare);
  intSet.insert(PairInt(1,3));
  intSet.insert(PairInt(1,4));
  intSet.insert(PairInt(1,4));
  intSet.insert(PairInt(4,1));
  for (IntSet::const_iterator i=intSet.begin(); i!=intSet.end(); ++i) { 
    std::cerr << i->first << "," << i->second << "\n";
  } 
}

Выход: 

1,3
1,4
0 голосов
/ 24 марта 2012

Сравнение должно определить, меньше ли первый элемент, чем второй.Так должно быть так: 

namspace std
{
  template<>
  bool operator < (const PairInt& l, const PairInt& r) 
  {
     //swap only if they're unequal to avoid infinite recursion
     if (l.first != l.second) 
     {
         //swap elements, considering your special case
          if (l.first == r.second && l.second == r.first)
             return l < PairInt(r.second, r.first); //call again!
     }

    //actual comparison is done here
    if ( l.first != r.first )
       return l.first < r.first;
    else 
       return l.second < r.second;
  }
}

Теперь он дает желаемый результат: 

1,3
1,4

Посмотрите на онлайн-демонстрацию .

Обратите внимание, что функция сравнения выглядит следующим образом: Строгий слабый порядок

...