Comparison operators

比较算子

比较参数。

所有内置操作符都返回bool，大多数用户定义的重载也返回bool，这样用户定义的操作符就可以与内置操作一样使用。但是，在用户定义的操作符重载中，任何类型都可以用作返回类型%28，包括无效%29。T2可以是任何类型，包括T

• 所有内置操作符返回bool，而且大多数用户定义的重载还回来bool这样，用户定义的操作符就可以与内置操作一样使用。但是，在用户定义的操作符重载中，任何类型都可以用作返回类型%28，包括void29%。

• T2可以是任何类型，包括T

解释

返回参数值比较的布尔结果，这些参数未被修改。

算术比较算子

对于每一对提升的算术类型L和R，包括枚举类型，下列函数签名参与过载解析：

如果操作数具有算术或枚举类型%28范围或非作用域%29，常用算术变换的规则执行。算术算子.换算后的数值比较：

例

二次

#include <iostream>
int main()
{
    std::cout << std::boolalpha;
    int n = -1;
 
    int n2 = 1;
    std::cout << " -1 == 1? " << (n == n2) << '\n'
              << "Comparing two signed values:\n"
              << " -1  < 1? " << (n < n2) << '\n'
              << " -1  > 1? " << (n > n2) << '\n';
 
    unsigned int u = 1;
    std::cout << "Comparing signed and unsigned:\n"
              << " -1  < 1? " << (n < u) << '\n'
              << " -1  > 1? " << (n > u) << '\n';
 
    unsigned char uc = 1;
    std::cout << "Comparing signed and smaller unsigned:\n"
              << " -1  < 1? " << (n < uc) << '\n'
              << " -1  > 1? " << (n > uc) << '\n';
}

二次

产出：

二次

-1 == 1? false
Comparing two signed values:
 -1  < 1? true
 -1  > 1? false
Comparing signed and unsigned:
 -1  < 1? false
 -1  > 1? true
Comparing signed and smaller unsigned:
 -1  < 1? true
 -1  > 1? false

二次

指针比较算子

每种类型P它要么是指向对象的指针，要么是指向函数的指针，或者std::nullptr_t%28在C++14%29之前，下列函数签名参与过载解析：

每种类型MP，即指向成员对象的指针或指向成员函数的指针或std::nullptr_t，下列函数签名参与过载解析：

比较运算符可用于比较两个指针%28或指向成员的指针。operator==和operator!=只有%29，或自C++14%29以来指向成员%28的指针和空指针常数，或两个空指针常数%28，但前提是它们中至少有一个是std::nullptr_tNULL和NULL的比较遵循算术比较规则%29%28，直到C++14%29。

首先，指针转换如果参数是指向成员的指针%29、函数指针转换、%28自C++17%29和资格转换应用于两个操作数以获得复合指针类型，如下。

1%29如果两个操作数都为空指针常量，则复合指针类型为std::nullptr_t

2%29如果一个操作数是空指针常量，而另一个操作数是指针，那么复合类型就是指针类型。

3%29如果一个操作数是指向CV1void另一个是指向CV2T为某种类型T，在哪里T是对象类型或void，复合类型为“指针”。cv 12void“，在哪里cv 12是…的结合CV1和CV2

请注意，这意味着任何指针都可以与void*...

在转换%29之后，将两个指针与对象%28进行比较的结果定义如下：

1%29如果两个指针指向同一数组的不同元素，或者指向同一数组的不同元素中的次对象，则指向具有较高下标的元素的指针。比较大换句话说，它们比较指针的结果与比较它们所指向的元素的索引的结果是相同的。

2%29如果一个指针指向数组的一个元素，或者指向数组元素的子对象，而另一个指针指向数组的最后一个元素，则后一个指针指向数组的最后一个元素。比较大.指向单个对象的指针被视为指向一个对象数组的指针：&obj+1比较大于&obj%28自C++17%29

3%29如果在非联合类类型的对象中，两个指针指向具有相同属性的不同非静态数据成员。成员访问，或者递归地指向这些成员的次对象或数组元素，指向后一个声明成员的指针。比较大换句话说，三个成员访问模式中的每个类成员都按声明顺序放置在内存中。

在转换%29之后，两个指针%28的相等比较结果定义如下：

1%29如果指针都是空指针值，则它们比较相等

2%29如果指针是指向函数的指针并指向同一个函数，那么比较相等

3%29如果指针是指向对象的指针，并且表示相同的地址，则它们比较相等%28这包括两个指向同一联合的非静态成员的指针、指向标准布局结构的指针以及与重新解释相关的第一个成员的指针。[医]铸造等...29

4%29所有其他指针比较不相等

在转换%29之后，将两个指针与成员%28进行比较的结果定义如下：

1%29如果指向成员的两个指针都为空成员指针值，则它们比较相等...

2%29否则，如果指向成员的两个指针中只有一个是空成员指针值，则它们比较不相等。

3%29否则，如果两者都是指向虚拟成员函数的指针，则结果未指定。

4%29否则，两个指向成员的指针比较相等的当且仅当它们引用同一个派生对象的同一个成员或同一个子对象时，如果它们被关联类类型的假想对象取消引用的话。

5%，29，否则他们就会比较不平等。

如果指针p比较相等指向指针q，，，p<=q和p>=q双产率true和p<q和p>q双产率false...

如果指针p比较大比指针q，然后p>=q，，，p>q，，，q<=p，和q<p全产量true和p<=q，，，p<q，，，q>=p，和q>p全产量false...

如果未指定两个指针来比较更大的指针或比较相等的指针，则未指定比较结果。

例

二次

#include <iostream>
struct Foo  { int n1; int n2; };
union Union { int n; double d; };
int main()
{
    std::cout << std::boolalpha;
 
    char a[4] = "abc";
 
    char* p1 = &a[1];
    char* p2 = &a[2];
    std::cout << "Pointers to array elements: p1 == p2 " << (p1 == p2)
              << ", p1 < p2 "  << (p1 < p2) << '\n';
 
    Foo f;
    int* p3 = &f.n1;
    int* p4 = &f.n2;
    std::cout << "Pointers to members of a class: p3 == p4 " << (p3 == p4)
              << ", p3 < p4 "  << (p3 < p4) << '\n';
 
    Union u;
    int* p5 = &u.n;
    double* p6 = &u.d;
    std::cout << "Pointers to members of a union: p5 == (void*)p6 " << (p5 == (void*)p6)
              << ", p5 < p6 "  << (p5 < (void*)p6) << '\n';
}

二次

产出：

二次

Pointers to array elements: p1 == p2 false, p1 < p2 true
Pointers to members of a class: p3 == p4 false, p3 < p4 true
Pointers to members of a union: p5 == (void*)p6 true, p5 < p6 false

二次

注记

因为这些操作符从左到右分组，表达式a<b<c被解析(a<b)<c，而不是a<(b<c)或(a<b)&&(b<c)...

共同要求用户定义运算符<是严格弱序尤其是，这是标准算法和容器所要求的Compare类型：std::sort，，，std::max_element，，，std::map等

虽然比较的结果，指针的随机起源%28等。并非所有指向同一数组%29的成员都未指定，许多实现提供严格全序的指针，例如，如果它们是作为连续虚拟地址空间中的地址实现的。那些没有%28例如的实现。如果指针的并非所有位位都是内存地址的一部分，因此必须忽略以进行比较，或者需要额外的计算，否则指针和整数不是1到1的关系%29，则提供一个专门化的std::less有这个保证的指针。这样就可以在标准关联容器中使用所有随机来源的指针作为键，例如std::set或std::map...

对于这两种类型EqualityComparable和LessThanComparable，C++标准库对平等，它是表达式的值。a == b和等价物，它是表达式的值。!(a < b) && !(b < a)...

在C++14中删除指针和空指针常量之间的比较。

二次

void f(char * p)
{
  if (p > 0) { ... } // OK in C++98..C++11, does not compile in C++14
  if (p > nullptr) { ... } // OK in C++98..C++11, does not compile in C++14
}

二次

标准库

标准库中的许多类都重载了比较运算符。

另见

运算符优先...

操作者超载...

公共算子

*。

分配增量递减算术逻辑比较成员访问其他

a=b a+=b a-=b a%2A=b a/=b a%=b a&=b a=b a^=b a<=b a>>=b.+a-a+a-+a-+a-a+b a-b a%2Ab a/b a%b~a&b ab^b a<<b a>>b.%21 a&b a&b ab a=b a%21=b a<b a>b a<=b a>=b a乙%2AA&A->b A.B a->%2Ab a.%2AA%28...%29 a，b？*

特殊运算符

静态[医]强制转换将一种类型转换为另一种相关类型动态。[医]继承层次结构中的强制转换[医]强制转换添加或删除cv限定符，重新解释[医]CAST将类型转换为不相关的类型C风格的强制转换通过混合静态方式将一种类型转换为另一种类型[医]卡斯特[医]重释[医]强制转换新创建具有动态存储持续时间的对象，删除删除以前由新表达式创建的对象，并释放获得的内存区域大小查询类型的大小...查询参数Pack%28的大小，因为C++11%29 Tyid查询类型no的类型信息，除了检查。表达式可以抛出异常%28，因为C++11%29查询对齐要求类型为%28，因为C++11%29。

 © cppreference.com

在CreativeCommonsAttribution下授权-ShareAlike未移植许可v3.0。

http：//en.cppreference.com/w/cpp/language/Operator[医]比较