strong_ordering Class

class Qt ::strong_ordering

Qt::strong_ordering represents a comparison where equivalent values are indistinguishable. 更多...

头：	#include <QtCompare>
CMake:	find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake:	QT += core
Since:	Qt 6.7

• 所有成员列表，包括继承成员

公共函数

	strong_ordering (std::strong_ordering stdorder )
Qt::partial_ordering	operator Qt::partial_ordering () const
Qt::weak_ordering	operator Qt::weak_ordering () const
std::strong_ordering	operator std::strong_ordering () const

静态公共成员

const Qt::strong_ordering	equal
const Qt::strong_ordering	equivalent
const Qt::strong_ordering	greater
const Qt::strong_ordering	less

相关非成员

bool	is_eq (Qt::strong_ordering o )
bool	is_gt (Qt::strong_ordering o )
bool	is_gteq (Qt::strong_ordering o )
bool	is_lt (Qt::strong_ordering o )
bool	is_lteq (Qt::strong_ordering o )
bool	is_neq (Qt::strong_ordering o )
bool	operator!= (Qt::strong_ordering lhs , Qt::strong_ordering rhs )
bool	operator== (Qt::strong_ordering lhs , Qt::strong_ordering rhs )

详细描述

A value of type Qt::strong_ordering is typically returned from a three-way comparison function. Such a function compares two objects and establishes how they are ordered. It uses this return type to indicate that the ordering is strict; that is, the function establishes a well-defined total order.

Qt::strong_ordering has four values, represented by the following symbolic constants:

• less represents that the left operand is less than the right;
• equal represents that the left operand is equivalent to the right;
• equivalent 是别名化的 equal ;
• greater represents that the left operand is greater than the right.

Qt::strong_ordering is idiomatically used by comparing an instance against a literal zero, for instance like this:

// given a, b, c, d as objects of some type that allows for a 3-way compare,
// and a compare function declared as follows:
Qt::strong_ordering compare(T lhs, T rhs); // defined out-of-line
~~~
Qt::strong_ordering result = compare(a, b);
if (result < 0) {
    // a is less than b
}
if (compare(c, d) >= 0) {
    // c is greater than or equal to d
}
					

另请参阅 Qt::weak_ordering , Qt::partial_ordering ，和 比较类型概述 .

成员函数文档编制

[constexpr noexcept] strong_ordering:: strong_ordering ( std::strong_ordering stdorder )

构造 Qt::strong_ordering 对象从 stdorder 使用下列规则：

• std::strong_ordering::less converts to less .
• std::strong_ordering::equivalent converts to equivalent .
• std::strong_ordering::equal converts to equal .
• std::strong_ordering::greater converts to greater .

[constexpr noexcept] Qt::partial_ordering strong_ordering:: operator Qt::partial_ordering () const

转换此 Qt::strong_ordering value to a Qt::partial_ordering object using the following rules:

• less converts to Qt::partial_ordering::less .
• equivalent converts to Qt::partial_ordering::equivalent .
• equal converts to Qt::partial_ordering::equivalent .
• greater converts to Qt::partial_ordering::greater .

[constexpr noexcept] Qt::weak_ordering strong_ordering:: operator Qt::weak_ordering () const

转换此 Qt::strong_ordering value to a Qt::weak_ordering object using the following rules:

• less converts to Qt::weak_ordering::less .
• equivalent converts to Qt::weak_ordering::equivalent .
• equal converts to Qt::weak_ordering::equivalent .
• greater converts to Qt::weak_ordering::greater .

[constexpr noexcept] std::strong_ordering strong_ordering:: operator std::strong_ordering () const

转换此 Qt::strong_ordering value to a std::strong_ordering object using the following rules:

• less converts to std::strong_ordering::less.
• equivalent converts to std::strong_ordering::equivalent.
• equal converts to std::strong_ordering::equal.
• greater converts to std::strong_ordering::greater.

成员变量文档编制

const Qt::strong_ordering strong_ordering:: equal

Represents the result of a comparison where the left operand is equal to the right operand. Same as Qt::strong_ordering::equivalent .

const Qt::strong_ordering strong_ordering:: equivalent

Represents the result of a comparison where the left operand is equal to the right operand. Same as Qt::strong_ordering::equal .

const Qt::strong_ordering strong_ordering:: greater

Represents the result of a comparison where the left operand is greater than the right operand.

const Qt::strong_ordering strong_ordering:: less

Represents the result of a comparison where the left operand is less than the right operand.

相关非成员

[constexpr noexcept] bool is_eq ( Qt::strong_ordering o )

[constexpr noexcept] bool is_gt ( Qt::strong_ordering o )

[constexpr noexcept] bool is_gteq ( Qt::strong_ordering o )

[constexpr noexcept] bool is_lt ( Qt::strong_ordering o )

[constexpr noexcept] bool is_lteq ( Qt::strong_ordering o )

[constexpr noexcept] bool is_neq ( Qt::strong_ordering o )

转换 o into the result of one of the six relational operators:

函数	Operation
is_eq	o == 0
is_neq	o != 0
is_lt	o < 0
is_lteq	o <= 0
is_gt	o > 0
is_gteq	o >= 0

These functions are provided for compatibility with std::strong_ordering .

[constexpr noexcept] bool operator!= ( Qt::strong_ordering lhs , Qt::strong_ordering rhs )

返回 true 若 lhs and rhs represent different results; otherwise, returns true.

[constexpr noexcept] bool operator== ( Qt::strong_ordering lhs , Qt::strong_ordering rhs )

返回 true 若 lhs and rhs represent the same result; otherwise, returns false.

内容

• 公共函数

• 静态公共成员

• 相关非成员

• 详细描述