std::basic_string<CharT,Traits,Allocator>:: compare

Compare deux séquences de caractères.

Une séquence de caractères composée de count1 caractères commençant à data1 est comparée à une séquence de caractères composée de count2 caractères commençant à data2 comme suit :

• D'abord, calculez le nombre de caractères à comparer, comme par size_type rlen = std:: min ( count1, count2 ) .
• Ensuite, comparez les séquences en appelant Traits :: compare ( data1, data2, rlen ) . Pour les chaînes standard, cette fonction effectue une comparaison lexicographique caractère par caractère. Si le résultat est zéro (les séquences de caractères sont égales jusqu'à présent), alors leurs tailles sont comparées comme suit :

Paramètres

Valeur de retour

• Valeur négative si * this apparaît avant la séquence de caractères spécifiée par les arguments, dans l'ordre lexicographique.
• Zéro si les deux séquences de caractères sont équivalentes.
• Valeur positive si * this apparaît après la séquence de caractères spécifiée par les arguments, dans l'ordre lexicographique.

Exceptions

Les surcharges prenant les paramètres nommés pos1 ou pos2 lancent std::out_of_range si l'argument est hors limites.

Si une exception est levée pour quelque raison que ce soit, cette fonction n'a aucun effet ( garantie forte de sûreté face aux exceptions ).

Implémentation possible

template<class CharT, class Traits, class Alloc>
int std::basic_string<CharT, Traits, Alloc>::compare
    (const std::basic_string& s) const noexcept
{
    size_type lhs_sz = size();
    size_type rhs_sz = s.size();
    int result = traits_type::compare(data(), s.data(), std::min(lhs_sz, rhs_sz));
    if (result != 0)
        return result;
    if (lhs_sz < rhs_sz)
        return -1;
    if (lhs_sz > rhs_sz)
        return 1;
    return 0;
}

Notes

Pour les situations où une comparaison à trois voies n'est pas nécessaire, std::basic_string fournit les opérateurs relationnels habituels ( < , <= , == , > , etc.).

Par défaut (avec les std::char_traits par défaut), cette fonction n'est pas sensible aux paramètres régionaux. Voir std::collate::compare pour une comparaison de chaînes à trois voies prenant en compte les paramètres régionaux.

Exemple

#include <cassert>
#include <iomanip>
#include <iostream>
#include <string>
#include <string_view>
void print_compare_result(std::string_view str1,
                          std::string_view str2,
                          int compare_result)
{
    if (compare_result < 0)
        std::cout << std::quoted(str1) << " vient avant "
                  << std::quoted(str2) << ".\n";
    else if (compare_result > 0)
        std::cout << std::quoted(str2) << " vient avant "
                  << std::quoted(str1) << ".\n";
    else
        std::cout << std::quoted(str1) << " et "
                  << std::quoted(str2) << " sont identiques.\n";
}
int main()
{
    std::string batman{"Batman"};
    std::string superman{"Superman"};
    int compare_result{0};
    // 1) Comparaison avec une autre chaîne
    compare_result = batman.compare(superman);
    std::cout << "1) ";
    print_compare_result("Batman", "Superman", compare_result);
    // 2) Comparaison d'une sous-chaîne avec une autre chaîne
    compare_result = batman.compare(3, 3, superman);
    std::cout << "2) ";
    print_compare_result("man", "Superman", compare_result);
    // 3) Comparaison d'une sous-chaîne avec une autre sous-chaîne
    compare_result = batman.compare(3, 3, superman, 5, 3);
    std::cout << "3) ";
    print_compare_result("man", "man", compare_result);
    // Comparaison d'une sous-chaîne avec une autre sous-chaîne
    // par défaut jusqu'à la fin de l'autre chaîne
    assert(compare_result == batman.compare(3, 3, superman, 5));
    // 4) Comparaison avec un pointeur de caractères
    compare_result = batman.compare("Superman");
    std::cout << "4) ";
    print_compare_result("Batman", "Superman", compare_result);
    // 5) Comparaison d'une sous-chaîne avec un pointeur de caractères
    compare_result = batman.compare(3, 3, "Superman");
    std::cout << "5) ";
    print_compare_result("man", "Superman", compare_result);
    // 6) Comparaison d'une sous-chaîne avec une sous-chaîne de pointeur de caractères
    compare_result = batman.compare(0, 3, "Superman", 5);
    std::cout << "6) ";
    print_compare_result("Bat", "Super", compare_result);
}

1) "Batman" vient avant "Superman".
2) "Superman" vient avant "man".
3) "man" et "man" sont identiques.
4) "Batman" vient avant "Superman".
5) "Superman" vient avant "man".
6) "Bat" vient avant "Super".

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