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

int compare( const basic_string& str ) const;

int compare( size_type pos1, size_type count1,
             const basic_string& str ) const;

int compare( size_type pos1, size_type count1,
             const basic_string& str,
             size_type pos2, size_type count2 ) const;

int compare( size_type pos1, size_type count1,
             const basic_string& str,
             size_type pos2, size_type count2 = npos ) const;

int compare( const CharT* s ) const;

int compare( size_type pos1, size_type count1,
             const CharT* s ) const;

int compare( size_type pos1, size_type count1,
             const CharT* s, size_type count2 ) const;

template< class StringViewLike >
int compare( const StringViewLike& t ) const noexcept(/* see below */);

template< class StringViewLike >
int compare( size_type pos1, size_type count1,
             const StringViewLike& t ) const;

template< class StringViewLike >
int compare( size_type pos1, size_type count1,
             const StringViewLike& t,
             size_type pos2, size_type count2 = npos) const;

Vergleicht zwei Zeichensequenzen.

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

• Berechne zuerst die Anzahl der zu vergleichenden Zeichen, wie durch size_type rlen = std::min(count1, count2).
• Vergleiche dann die Sequenzen durch Aufruf von Traits::compare(data1, data2, rlen). Für Standard-Strings führt diese Funktion einen zeichenweisen lexikografischen Vergleich durch. Wenn das Ergebnis Null ist (die Zeichensequenzen sind bisher 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