Question

我对C ++很陌生（但我知道C的方式）所以我可能错过了一些明显的东西。

TLDR：我使用std :: set存储元素两次，这绝对不是我想要的。

长篇故事：我已经定义了一个类Clique，我需要将这个类的元素存储在一个集合中，所以我已经定义了＆lt; Clique的运营商：

class Clique{
public :
  int b;
  int e;
  int l;
  std::set<int> X;

  bool operator <( const Clique &rhs ) const
  {
    if( b < rhs.b)
      return true;
    if( e < rhs.e)
      return true;
    if( X.size() < rhs.X.size() )
      return true;
    std::set<int>::iterator itX = X.begin();
    std::set<int>::iterator itrhs = rhs.X.begin();
    // both sets have same size, need only to check end for one of them                                                                                                                                            
    while( (*itX == *itrhs) && ( itX != X.end() ) ){
      ++itX;
      ++itrhs;
    }
    if( itX == X.end() ){
      //both sets are equal                                                                                                                                                                                        
      return false;
    }
    else
      return ( *itX < *itrhs );
  }

  void print_clique(FILE *F) const ;
};

（我不确定如何进行集合比较，所以我编写了一个例程，首先按大小比较它们，然后逐个元素地进行比较。）

现在我想将Clique元素存储在一个集合中，这就是出现问题的地方。我的std :: set （1）似乎没有按照我定义的顺序存储Clique元素; （2）存储同一个Clique的几个副本

我已经写了一个打印一套Clique的函数：

void print_cliqueset(std::set<Clique> mySet){
  int setsize = 0;

  std::set<Clique>::iterator it = mySet.begin();
  Clique cur_c = *it;
  Clique prev_c = *it;
  while( it != mySet.end() ){
  //  for( std::set<Clique>::iterator it = mySet.begin(); it != mySet.end(); ++it ){                                                                                                                               
    it->print_clique(stdout);
    setsize ++;
    ++it;
    if( it != mySet.end() ){
      cur_c = *it;
      assert ( prev_c < cur_c);
      gassert( prev_c.b <= cur_c.b );
    prev_c = *it;
    }
  }

  assert( setsize == mySet.size() );
}

我的功能比需要的更复杂，但我想确保我理解发生了什么。

以下是打印这样一组的典型输出：每个Clique都有一行，我首先打印b，然后是e，然后是集合X中的元素。

6829 9716 1 2 3 5 8 9 10 
6792 9687 1 2 3 7 8 9 10 
606 6531 1 2 3 5 6 7 8 9 
6829 9687 1 2 3 5 7 8 9 10 
410 9951 2 6 
484 9805 1 2 4 6 
494 9805 2 4 6 10 
506 9805 1 2 5 6 
484 9821 1 2 4 
484 9871 2 3 4 6 
506 9821 1 2 5 
484 9802 1 2 3 4 6 
486 9805 1 2 4 6 9 
486 9802 1 2 3 4 6 9 
507 9802 1 2 3 4 6 9 10 
502 9802 1 2 3 4 6 10 
506 9802 1 2 3 5 6 
507 9806 1 2 4 9 10 
507 9805 1 2 5 6 9 
527 9806 1 2 5 9 10

正如我们所看到的，派系根本没有按照我定义（或想要定义）的顺序排序。它们应该首先按成员b（每行的第一行）排序，而事实并非如此。

然后我在输出中有一些重复的行（不出现在上面的例子中但出现在完整输出中）。我认为我有重复的事实并不令人惊讶，因为它似乎对订单感到困惑......

我猜答案是相当明显的，但我没有看到。任何帮助将不胜感激！

Answer 1

您的operator<已损坏。考虑两个Clique s：

c1 is {b = 0, e = 1, ...}
c2 is {b = 1, e = 0, ...}

对于true和c1 < c2，您的代码将返回c2 < c1。

显然，在这种情况下std::set显示出奇怪的行为。

我会通过以下方式修复您的operator<：

bool operator <( const Clique &rhs ) const
{
    if( b != rhs.b)
        return b < rhs.b;
    if( e != rhs.e)
        return e < rhs.e;
    if( X.size() != rhs.X.size() )
        return X.size() < rhs.X.size();
    std::set<int>::iterator itX = X.begin();
    std::set<int>::iterator itrhs = rhs.X.begin();
    // both sets have same size, need only to check end for one of them
    while((itX != X.end()) && (itX == *itrhs)){
        ++itX;
        ++itrhs;
    }
    if( itX == X.end() ){
    //both sets are equal
        return false;
    }
    else
        return ( *itX < *itrhs );
}

Answer 2

您的bool operator <( const Clique &rhs ) const错误，因为它不尊重严格的排序。

可能只是：

bool operator <(const Clique& rhs) const
{
    return std::tie(b, e, X) < std::tie(rhs.b, rhs.e, rhs.X);
}

Answer 3

运营商的定义＆lt;应该是这样的：对于每对元素'b'和'e'，关系b < e应该用于确定任何类型的关系。以下等效性在此处有效：

a > b＆lt; ==＆gt; b < a

a == b＆lt; ==＆gt; !(a < b) && !(b < a)

a >= b＆lt; ==＆gt; `！（a＆lt; b）

等等。如果为每个关系检查使用多个字段进行检查，那么您将拥有一种多维范围。从中做出平坦的范围只能这样做：

首先检查更重要的字段;如果在此字段中值不相等，则立即返回结果
否则 - 如果它们相等 - 您检查重要性顺序中的下一个字段，依此类推。

在集合中使用这种复杂关系定义的要求使得事情变得更加困难，因为您应该做的就是说明一个元素是否小于另一个元素。因此，在您的情况下，您必须自己检查相等。如果 lhs.b > rhs.b，您的程序还会检查“重要链中的下一个”字段。

Answer 4

运营商＆lt;必须提供严格的弱序。即如果x < y然后!(y < x)和!(y == x)。

在Clique的情况下，要求似乎是以字面方式比较元素b，e和X.

表示这一点的惯用方法是根据operator<进行所有比较：

#include <set>

class Clique{
public :
    int b;
    int e;
    int l;
    std::set<int> X;

    bool operator <( const Clique &r ) const
    {
        auto const& l = *this;

        if (l.b < r.b) return true;
        if (r.b < l.b) return false;

        if (l.e < r.e) return true;
        if (r.e < l.e) return false;

        if (l.X < r.X) return true;
        if (r.X < l.X) return false;

        return false;
    }

    void print_clique(FILE *F) const ;
};

是的，std::set确实在密钥类型提供时提供operator<。

另一种写这个的方式，正如Jarod所暗示的那样：

#include <set>
#include <tuple>

class Clique{
public :
    int b;
    int e;
    int l;
    std::set<int> X;

    bool operator <( const Clique &r ) const
    {
        auto const& l = *this;
        return std::tie(l.b, l.e, l.X) < std::tie(r.b, r.e, r.X);
    }

    void print_clique(FILE *F) const ;
};

我认为你会同意的是简洁，富有表现力，正确和惯用。

C ++集：存储重复：混淆＆lt;操作者

4 个答案: