std::lexicographical_compare_three_way
De fr.cppreference.net
| Défini dans l'en-tête <algorithm>
|
||
template< class InputIt1, class InputIt2, class Cmp >
constexpr auto lexicographical_compare_three_way
( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
Cmp comp ) -> decltype(comp(*first1, *first2));
|
(1) | (depuis C++20) |
template< class InputIt1, class InputIt2 >
constexpr auto lexicographical_compare_three_way
( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2 );
|
(2) | (depuis C++20) |
Compare lexicographiquement deux plages [first1, last1) et [first2, last2) en utilisant la comparaison à trois voies et produit un résultat du type de catégorie de comparaison le plus fort applicable.
1) Renvoie l'ordre entre la première paire d'éléments non équivalents selon
comp dans les deux plages s'il y en a, sinon (si une plage est équivalente au préfixe d'une autre selon comp), renvoie l'ordre entre les longueurs des deux plages.2) Équivalent à
return std::lexicographical_compare_three_way(first1, last1, first2, last2, std::compare_three_way());Si le type de retour n'est pas l'un des trois types de catégorie de comparaison, le programme est mal formé :
Paramètres
| first1, last1 | - | la paire d'itérateurs définissant la première plage d'éléments à examiner |
| first2, last2 | - | la paire d'itérateurs définissant la seconde plage d'éléments à examiner |
| comp | - | un objet fonction |
| Exigences de type | ||
-InputIt1, InputIt2 doit satisfaire aux exigences de LegacyInputIterator.
| ||
Valeur de retour
La valeur d'un type de catégorie de comparaison spécifié ci-dessus.
Complexité
Étant donné N1 comme std::distance(first1, last1) et N2 comme std::distance(first2, last2) :
1) Au plus min(1,N2) applications de
comp.2) Au plus min(N1,N2) applications de
std::compare_three_way().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>>,
"The return type must be a comparison category type.");
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
Exécuter ce code
#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) << " is ";
std::is_lt(o) ? std::cout << "less than ":
std::is_gt(o) ? std::cout << "greater than ":
std::cout << "equal to ";
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);
}
}
Sortie :
"one" is equal to "ONE"
"two" is greater than "four"
"three" is less than "two"
Rapports de défauts
Les rapports de défauts suivants, modifiant le comportement, ont été appliqués rétroactivement aux normes C++ précédemment publiées.
| DR | Appliqué à | Comportement tel que publié | Comportement correct |
|---|---|---|---|
| LWG 3410 | C++20 | des comparaisons superflues entre itérateurs étaient requises | exigence supprimée |
Voir aussi
| compare deux plages lexicographiquement (modèle de fonction & objet fonction d'algorithme) | |
(C++20) |
objet fonction contraint implémentant x <=> y (classe) |
| compare deux plages lexicographiquement (objet fonction d'algorithme) |