[expr.eq] (original) (raw)

7 Expressions [expr]

7.6 Compound expressions [expr.compound]

7.6.10 Equality operators [expr.eq]

equality-expression: relational-expression equality-expression == relational-expression equality-expression != relational-expression

The == (equal to) and the != (not equal to) operators group left-to-right.

The lvalue-to-rvalue ([conv.lval]), array-to-pointer ([conv.array]), and function-to-pointer ([conv.func]) standard conversions are performed on the operands.

The comparison is deprecated if both operands were of array type prior to these conversions ([depr.array.comp]).

The converted operands shall have arithmetic, enumeration, pointer, or pointer-to-member type, or type std​::​nullptr_­t.

The operators== and != both yield true or false, i.e., a result of type bool.

In each case below, the operands shall have the same type after the specified conversions have been applied.

Comparing pointers is defined as follows:

• If one pointer represents the address of a complete object, and another pointer represents the address one past the last element of a different complete object,78the result of the comparison is unspecified.
• Otherwise, if the pointers are both null, both point to the samefunction, or bothrepresent the same address, they compare equal.
• Otherwise, the pointers compare unequal.

If at least one of the operands is a pointer to member, pointer-to-member conversions ([conv.mem]), function pointer conversions ([conv.fctptr]), and qualification conversions ([conv.qual]) are performed on both operands to bring them to their composite pointer type ([expr.type]).

Comparing pointers to members is defined as follows:

• If two pointers to members are both the null member pointer value, they compare equal.
• If only one of two pointers to members is the null member pointer value, they compare unequal.
• If either is a pointer to a virtual member function, the result is unspecified.
• If one refers to a member of class C1 and the other refers to a member of a different class C2, where neither is a base class of the other, the result is unspecified.
  [ Example
  :
  struct A {};
  struct B : A { int x; };
  struct C : A { int x; };
  int A::bx = (int(A::))&B::x;
  int A::cx = (int(A::))&C::x;
  bool b1 = (bx == cx);
  — end example
  ]
• If both refer to (possibly different) members of the same union, they compare equal.
• Otherwise, two pointers to members compare equal if they would refer to the same member of the same most derived object or the same subobject if indirection with a hypothetical object of the associated class type were performed, otherwise they compare unequal.
  [ Example
  :
  struct B {
  int f();
  };
  struct L : B { };
  struct R : B { };
  struct D : L, R { };
  int (B::*pb)() = &B::f;
  int (L::*pl)() = pb;
  int (R::*pr)() = pb;
  int (D::*pdl)() = pl;
  int (D::*pdr)() = pr;
  bool x = (pdl == pdr);
  bool y = (pb == pl);
  — end example
  ]

Two operands of type std​::​nullptr_­t or one operand of typestd​::​nullptr_­t and the other a null pointer constant compare equal.

If two operands compare equal, the result is true for the == operator and false for the != operator.

If two operands compare unequal, the result is false for the == operator andtrue for the != operator.

Otherwise, the result of each of the operators is unspecified.

If both operands are of arithmetic or enumeration type, the usual arithmetic conversions are performed on both operands; each of the operators shall yieldtrue if the specified relationship is true and false if it is false.