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

Vergleicht zwei Zeichenfolgen.

Eine Zeichenfolge bestehend aus count1 Zeichen beginnend bei data1 wird verglichen mit einer Zeichenfolge bestehend aus count2 Zeichen beginnend bei data2 wie folgt:

• Zuerst wird die Anzahl der zu vergleichenden Zeichen berechnet, wie durch size_type rlen = std:: min ( count1, count2 ) .
• Dann werden die Sequenzen durch Aufruf von Traits :: compare ( data1, data2, rlen ) verglichen. Für Standard-Strings führt diese Funktion einen zeichenweisen lexikographischen Vergleich durch. Wenn das Ergebnis null ist (die Zeichensequenzen sind bis dahin gleich), dann werden ihre Größen wie folgt verglichen:

Parameter

Rückgabewert

• Negativer Wert, wenn * this vor der durch die Argumente spezifizierten Zeichensequenz erscheint, in lexikographischer Reihenfolge.
• Null, wenn beide Zeichensequenzen äquivalent vergleichen.
• Positiver Wert, wenn * this nach der durch die Argumente spezifizierten Zeichensequenz erscheint, in lexikographischer Reihenfolge.

Ausnahmen

Die Überladungen, die Parameter mit den Namen pos1 oder pos2 verwenden, werfen std::out_of_range , wenn das Argument außerhalb des gültigen Bereichs liegt.

Wenn aus irgendeinem Grund eine Exception ausgelöst wird, hat diese Funktion keine Wirkung ( strong exception safety guarantee ).

Mögliche Implementierung

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

Hinweise

Für Situationen, in denen kein Drei-Wege-Vergleich erforderlich ist, std::basic_string bietet die üblichen relationalen Operatoren ( < , <= , == , > , etc).

Standardmäßig (mit den Standard- std::char_traits ) ist diese Funktion nicht lokalisierungsabhängig. Siehe std::collate::compare für eine lokalisierungsbewusste Drei-Wege-Zeichenkettenvergleich.

Beispiel

#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) << " kommt vor "
                  << std::quoted(str2) << ".\n";
    else if (compare_result > 0)
        std::cout << std::quoted(str2) << " kommt vor "
                  << std::quoted(str1) << ".\n";
    else
        std::cout << std::quoted(str1) << " und "
                  << std::quoted(str2) << " sind gleich.\n";
}
int main()
{
    std::string batman{"Batman"};
    std::string superman{"Superman"};
    int compare_result{0};
    // 1) Vergleich mit anderem String
    compare_result = batman.compare(superman);
    std::cout << "1) ";
    print_compare_result("Batman", "Superman", compare_result);
    // 2) Vergleich von Teilstring mit anderem String
    compare_result = batman.compare(3, 3, superman);
    std::cout << "2) ";
    print_compare_result("man", "Superman", compare_result);
    // 3) Vergleich von Teilstring mit anderem Teilstring
    compare_result = batman.compare(3, 3, superman, 5, 3);
    std::cout << "3) ";
    print_compare_result("man", "man", compare_result);
    // Vergleich von Teilstring mit anderem Teilstring
    // Standardmäßig bis zum Ende des anderen Strings
    assert(compare_result == batman.compare(3, 3, superman, 5));
    // 4) Vergleich mit char-Zeiger
    compare_result = batman.compare("Superman");
    std::cout << "4) ";
    print_compare_result("Batman", "Superman", compare_result);
    // 5) Vergleich von Teilstring mit char-Zeiger
    compare_result = batman.compare(3, 3, "Superman");
    std::cout << "5) ";
    print_compare_result("man", "Superman", compare_result);
    // 6) Vergleich von Teilstring mit Teilstring eines char-Zeigers
    compare_result = batman.compare(0, 3, "Superman", 5);
    std::cout << "6) ";
    print_compare_result("Bat", "Super", compare_result);
}

1) "Batman" kommt vor "Superman".
2) "Superman" kommt vor "man".
3) "man" und "man" sind gleich.
4) "Batman" kommt vor "Superman".
5) "Superman" kommt vor "man".
6) "Bat" kommt vor "Super".

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch