Back to Qt.io
Contact Us Blog Download Qt
Sur cette page

Qt::strong_ordering Class

class Qt::strong_ordering

Qt::strong_ordering représente une comparaison dans laquelle des valeurs équivalentes sont indiscernables. En savoir plus...

En-tête : #include <QtCompare>
CMake : find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake : QT += core
Depuis : Qt 6.7

Fonctions publiques

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

Membres publics statiques

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)

Description détaillée

Une fonction de comparaison à trois voies renvoie généralement une valeur de type ` Qt::strong_ordering `. Une telle fonction compare deux objets et établit leur ordre. Elle utilise ce type de retour pour indiquer que l'ordre est strict ; c'est-à-dire que la fonction établit un ordre total bien défini.

Qt::strong_ordering comporte quatre valeurs, représentées par les constantes symboliques suivantes :

  • less indique que l’opérande de gauche est inférieur à celui de droite ;
  • equal indique que l’opérande de gauche est équivalent à celui de droite ;
  • equivalent est un alias de ` equal` ;
  • greater indique que l’opérande de gauche est supérieur à celui de droite.

Qt::strong_ordering est couramment utilisé pour comparer une instance à un zéro littéral, par exemple comme ceci :

// 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
}

Voir également Qt::weak_ordering, Qt::partial_ordering et la présentation des types de comparaison.

Documentation des fonctions membres

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

Crée un objet ` Qt::strong_ordering ` à partir de ` stdorder ` en appliquant les règles suivantes :

  • std::strong_ordering::less est converti en less.
  • std::strong_ordering::equivalent est converti en equivalent.
  • std::strong_ordering::equal est converti en equal.
  • std::strong_ordering::greater est converti en greater.

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

Convertit cette valeur de type « Qt::strong_ordering » en un objet de type « Qt::partial_ordering » selon les règles suivantes :

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

Convertit cette valeur de type « Qt::strong_ordering » en un objet de type « Qt::weak_ordering » selon les règles suivantes :

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

Convertit cette valeur de type ` Qt::strong_ordering ` en un objet de type `std::strong_ordering` selon les règles suivantes :

  • less convertit en std::strong_ordering::less.
  • equivalent convertit en std::strong_ordering::equivalent.
  • equal convertit en std::strong_ordering::equal.
  • greater convertit en std::strong_ordering::greater.

Documentation sur les variables membres

const Qt::strong_ordering strong_ordering::equal

Représente le résultat d'une comparaison dans laquelle l'opérande de gauche est égal à l'opérande de droite. Équivalent à « Qt::strong_ordering::equivalent ».

const Qt::strong_ordering strong_ordering::equivalent

Représente le résultat d'une comparaison dans laquelle l'opérande de gauche est égal à l'opérande de droite. Équivalent à « Qt::strong_ordering::equal ».

const Qt::strong_ordering strong_ordering::greater

Représente le résultat d'une comparaison dans laquelle l'opérande de gauche est supérieur à l'opérande de droite.

const Qt::strong_ordering strong_ordering::less

Représente le résultat d'une comparaison dans laquelle l'opérande de gauche est inférieur à l'opérande de droite.

Éléments non membres associés

[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)

Convertit une expression de type « o » en le résultat de l'un des six opérateurs relationnels suivants :

FonctionOpération
is_eqo == 0
is_neqo != 0
is_lto < 0
is_lteqo <= 0
is_gto > 0
is_gteqo >= 0

Ces fonctions sont fournies à des fins de compatibilité avec std::strong_ordering.

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

Renvoie « true » si lhs et rhs renvoient des résultats différents ; sinon, renvoie « true ».

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

Renvoie « true » si lhs et rhs renvoient le même résultat ; sinon, renvoie « false ».

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.