N4532: Proposed wording for default comparisons

Introduction

Open Issues

• It seems natural to generate != from == even if the class doesn't satisfy the constraints. This would only be possible if a user-defined operator== exists, of course. Same for the relational operators other than <. Is that the intent (deviating from N4475, top of page 17)? Example:

    struct S {
      int i = 0;
    };
    bool operator==(const S&, const S&)
    { return true; }
  
    int f() {
      S() != S();    // well-formed, yields false?
    }
  

• A class with a mutable member does not get a memberwise operator== or operator< (deviating from N4475 page 17).
• Should struct S { int a[3]; } acquire generated comparison functions? If yes, what about int[3] (i.e. an array not wrapped in a struct)?
• Generation of memberwise operator< relies on memberwise operator==. Should we generate operator< for a class C (implicitly using memberwise == in its definition) even if we have a user-declared operator== for C, indicating that memberwise == is not desired?
• What exactly does it mean that "a class has a given operator declared"? The operators in question are binary, may be free functions, and may be function templates. Examples:

  struct A { };
  void operator==(const A&, const A&);
  void operator==(const A&, int);
  void operator==(A&, const A&);
  void operator==(A&&, volatile A&);
  void operator==(const volatile A&&, const A&);
  void operator==(A, const A&);
  template<class T>
  void operator==(const T&, A);
  template<class T>
  void operator==(const T&, const T&);
  template<class T>
  void operator==(T&&, T&&);
  

• What kind of lookup is performed for the operator function name when determining that "a class has a given operator declared"? Usual unqualified lookup from which context? Just argument-dependent lookup? Something else? Example:

  struct A { int x, y; } a;
  namespace N {
    void *operator<(A, A);
    auto q = a > a;
  }
  

  What's the type of q? Is this example some flavor of ill-formed? Do we use N::operator<? Do we do a subobject comparison?

Wording

A type cv T supports comparison by subobject if T is an array type, or is a non-union class type that satisfies the following constraints:

• T has no virtual base class (clause 10 [class.derived]),
• T has no virtual member function (10.3 [class.virtual]),
• T has no direct mutable member (7.1.1 [dcl.stc]),
• T has no direct non-static data member of pointer type (9.2 [class.mem]), and
• T has no user-provided or deleted copy/move constructor or assignment operator (12.8 [class.copy]).

T supports operator op if overload resolution (13.3.1.2 [over.match.oper]) finds a viable function for the expression x op y, where x and y are lvalues of type T.

T supports equality comparison by subobject if T supports comparison by subobject and does not support operator== and operator!=.

T supports relational comparison by subobject if T supports equality comparison by subobject and does not support operator <, operator <=, operator >, and operator >=.

• ...
• has all non-static data members and bit-fields in the class and its base classes first declared in as direct members of the same class, and
• ...

The member-specification in a class definition declares the full set of members of the class; no member can be added elsewhere. A direct member of a class is a member of that class that was first declared within the class's member-specification. ...

9.10 Operators [class.oper]

[ Note: This section specifies the meaning of relational (5.9 [expr.rel]) or equality (5.10 [expr.eq]) operators applied to values of class or array type. ]

Comparing for equality two objects x and y that have the same class or array type T (ignoring cv-qualification) is defined as follows:

• A sequence of corresponding subobjects of x and y is formed by starting with a sequence comprising x corresponding to y, and repeatedly replacing each element whose type supports equality comparison by subobject (3.9.2 [basic.compound]) with a sequence of the corresponding subobjects of the direct base classes and direct members of that type, in order of declaration or order of increasing array subscript.
• For each element in the sequence of corresponding subobjects, the corresponding subobjects are compared using ==. If this comparison, when contextually converted to bool, yields false, no further subobjects are compared, and x == y yields false and x != y yields true. If all such comparisons yield true, then x == y yields true and x != y yields false.

Comparing two objects x and y that have the same class or array type T (ignoring cv-qualification) is defined as follows:

• For x > y, the result is y < x. For x >= y, the result is y <= x.
• A sequence of corresponding subobjects of x and y is formed by starting with a sequence comprising x corresponding to y, and repeatedly replacing each element whose type supports relational comparison by subobject (3.9.2 [basic.compound]) with a sequence of the corresponding subobjects of the direct base classes and direct members of that type, in order of declaration or order of increasing array subscript.
• For each element in the sequence of corresponding subobjects, the corresponding subobjects are compared using ==. If this comparison, when contextually converted to bool, yields false for the first time, that element is the first differing one. If the final element is reached for a < comparison, that element is the first differing one, and is not compared with ==. Otherwise, if all such comparisons yield true, there is no first differing element.
• If there is no first differing element, the result of the <= comparison is true. Otherwise, the corresponding subobjects of the first differing element are compared using <. The result of this comparison, when contextually converted to bool, is the result of the overall comparison.

[ Example:

struct B {
  int i = 0;
};

struct S : B {
  int j = 1;
};

struct T : S {
   bool operator>(T) = delete;
};

void f()
{
  B b;
  S s1, s2;
  s2.j = 2;
  s1 == s1;      // yields true
  s1 != s2;      // yields true
  s1 < s1;       // yields false
  s1 < s2;       // yields true
  s1 == b;       // error: not the same class type
  T() == T();    // yields true
  T() < T();     // error: operator> is user-declared
}

-- end example ]

If overload resolution yields no viable function (13.3.2 [over.match.viable]) for a relational (5.9 [expr.rel]) or equality (5.10 [expr.eq]) operator and the operands are of the same class or array type T (ignoring cv-qualification), then:

• If the operator is == and T does not support equality comparison by subobject, the program is ill-formed.
• If the operator is < and T does not support relational comparison by subobject, the program is ill-formed.
• If overload resolution for the operator would yield a viable function in any translation unit, the program is ill-formed, no diagnostic required.
• Otherwise, the operator is treated as a built-in operator and interpreted according to 9.10 [class.oper].

Acknowledgements