c++ - 是否存在比较不比较完整对象状态的常规类型的概念名称？

Question

我有一组看起来像这样的类型:

struct MyFlag
{
     SomeId source_id; // INVALID_ID by default
     SomeData data; // regular type

     friend bool operator==( const MyFlag& a, const MyFlag& b ) { return a.source_id == b.source_id; }
     friend bool operator<( const MyFlag& a, const MyFlag& b ) { return a.source_id < b.source_id; }
     friend bool operator!=( const MyFlag& a, const MyFlag& b ) { return !(a == b); }

     friend bool operator==( const SomeId& a, const MyFlag& b ) { return a == b.source_id; }
     friend bool operator<( const SomeId& a, const MyFlag& b ) { return a < b.source_id; }
};



MyFlag flag_a { id, data_A };
MyFlag flag_b { id, data_B };

assert( flag_a == flag_b );
assert( flag_a.data != flag_b.data );
assert( flag_a == id );
assert( flag_b == id ); 

MyFlag flag = flag_b;
assert( flag == flag_a );
assert( flag == id );
assert( flag.data != flag_a.data );

const MyFlag flag_x ={ id_x, data_A };
flag = flag_X;
assert( flag != flag_a );
assert( flag.data == flag_a.data );

也就是说，比较时只考虑对象状态的特定部分:在这个例子中，任何 MyFlag 对象都将使用它们的 id 与其他对象进行比较，而不是它们包含的其余数据。

我认为它符合 Sean Parent 给出的“值类型”定义，但我也认为这是一种奇怪或不熟悉(但对我来说很有用)的模式。

所以我的问题是:是否有这个...概念的概念名称？

---

那种类型有什么用？我在“黑板”事件系统中使用这种类型，它基本上是一种至少具有常规类型的任何值的集合。然而，这个黑板系统地覆盖插入(插入)其中的值，即使它已经找到(通过比较)。这样，我就可以使用比较运算符作为标识符来覆盖黑板上某个值的完整状态。

我不知道它是否是一个众所周知的模式或想法，或者从长远来看它是否有问题。到目前为止，它非常有用。它也感觉像是“太聪明”的东西，但我缺乏这种模式的经验来证实这一点。可能是我在滥用比较运算符，但感觉这些类型的语义在我的使用中是正确的。

如有必要，我可以提供详细的用法示例。

Answer 1

MyFlag不是 EqualityComparable , 自 ==对于具有不同值的对象返回 true。 EqualityComparable的定义在 §3.3 中包括 axiom { a == b <=> eq(a, b); } .

非正式地，eq是为了表示我们认为是对象的值的相等性，而不管 == 是否存在。对于该对象的类型。这与表示相等性并不严格相同，因为 (a) 不同的表示可以被认为是相等的(例如 -0.0 == 0.0 )，并且 (b) 表示中可能存在无关紧要的状态(通俗地称为“填充”)。

在MyFlag的情况下, 我发现几乎可以肯定 data在 MyFlag 的值(value)中会被认为是重要的在某些情况下(OP 本身出现了几次)。形式上，我可以定义一个运算符 cmp在 MyFlag作为:

bool cmp(const MyFlag& a, const MyFlag& b) {
  return a == b && a.data == b.data;
}

这显然比相应的 operator == 提供了对相等性更强的解释.

考虑 std::copy 的实现:

template <typename In, typename Out>
Out copy_(In first, In last, Out out, std::false_type) {
  while(first != last) {
    *out++ = *first++;
  }
}

template <typename In, typename Out>
Out copy_(In first, In last, Out out, std::true_type) {
  while(first != last) {
    *out = *first;
    *out.data = SomeData();
    ++first;
    ++out;
  }
}

template <typename In, typename Out>
Out copy(In first, In last, Out out) {
  copy_(first, last, out, std::is_same<
          Myflag,
          typename std::iterator_traits<In>::value_type>());
}

您认为这是 copy 的有效实现吗？ ，或者你会说它正在破坏数据？根据 Myflag 保持平等的 operator == .

相比之下，有 Myflag被定义为:

class MyFlag
{
     SomeData trash_bits;
public:
     SomeId source_id; // INVALID_ID by default

     friend bool operator==( const MyFlag& a, const MyFlag& b ) { return a.source_id == b.source_id; }
     friend bool operator<( const MyFlag& a, const MyFlag& b ) { return a.source_id < b.source_id; }
     friend bool operator!=( const MyFlag& a, const MyFlag& b ) { return !(a == b); }

     friend bool operator==( const SomeId& a, const MyFlag& b ) { return a == b.source_id; }
     friend bool operator<( const SomeId& a, const MyFlag& b ) { return a < b.source_id; }
};

你可以提出一个令人信服的论点 trash_bits不是 MyFlag 值的一部分因为他们从未被观察到。 那么我同意MyFlag是Regular .