std:: lexicographical_compare_three_way

Compare lexicographiquement deux intervalles [ first1 , last1 ) et [ first2 , last2 ) en utilisant la comparaison à trois voies et produit un résultat du type de catégorie de comparaison applicable le plus fort.

Si le type de retour n'est pas l'un des trois types de catégories de comparaison, le programme est mal formé :

• std::strong_ordering
• std::weak_ordering
• std::partial_ordering

Paramètres

Valeur de retour

La valeur d'un type de catégorie de comparaison spécifié ci-dessus.

Complexité

Soit \(\scriptsize N_1\) N 1 défini comme std:: distance ( first1, last1 ) et \(\scriptsize N_2\) N 2 défini comme std:: distance ( first2, last2 ) :

Implémentation possible

template<class I1, class I2, class Cmp>
constexpr auto lexicographical_compare_three_way(I1 f1, I1 l1, I2 f2, I2 l2, Cmp comp)
    -> decltype(comp(*f1, *f2))
{
    using ret_t = decltype(comp(*f1, *f2));
    static_assert(std::disjunction_v<
                      std::is_same<ret_t, std::strong_ordering>,
                      std::is_same<ret_t, std::weak_ordering>,
                      std::is_same<ret_t, std::partial_ordering>>,
                  "Le type de retour doit être un type de catégorie de comparaison.");
    bool exhaust1 = (f1 == l1);
    bool exhaust2 = (f2 == l2);
    for (; !exhaust1 && !exhaust2; exhaust1 = (++f1 == l1), exhaust2 = (++f2 == l2))
        if (auto c = comp(*f1, *f2); c != 0)
            return c;
    return !exhaust1 ? std::strong_ordering::greater:
           !exhaust2 ? std::strong_ordering::less:
                       std::strong_ordering::equal;
}

Exemple

#include <algorithm>
#include <cctype>
#include <compare>
#include <iomanip>
#include <iostream>
#include <string_view>
#include <utility>
using namespace std::literals;
void show_result(std::string_view s1, std::string_view s2, std::strong_ordering o)
{
    std::cout << std::quoted(s1) << " est ";
    std::is_lt(o) ? std::cout << "inférieur à ":
    std::is_gt(o) ? std::cout << "supérieur à ":
                    std::cout << "égal à ";
    std::cout << std::quoted(s2) << '\n';
}
std::strong_ordering cmp_icase(unsigned char x, unsigned char y)
{
    return std::toupper(x) <=> std::toupper(y);
};
int main()
{
    for (const auto& [s1, s2] :
    {
        std::pair{"one"sv, "ONE"sv}, {"two"sv, "four"sv}, {"three"sv, "two"sv}
    })
    {
        const auto res = std::lexicographical_compare_three_way(
            s1.cbegin(), s1.cend(), s2.cbegin(), s2.cend(), cmp_icase);
        show_result(s1, s2, res);
    }
}

"one" is equal to "ONE"
"two" is greater than "four"
"three" is less than "two"

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi