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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Bibliothek für Zeichenketten

Klassen

basic_string

basic_string_view (C++17)

char_traits

 

std::basic_string

Memberfunktionen basic_string::basic_string basic_string::~basic_string basic_string::operator= basic_string::assign basic_string::assign_range (C++23)   basic_string::get_allocator Elementzugriff basic_string::at basic_string::operator[] basic_string::front (DR*) basic_string::back (DR*) basic_string::data basic_string::c_str basic_string::operator  basic_string_view (C++17) Iteratoren basic_string::beginbasic_string::cbegin (C++11) basic_string::endbasic_string::cend (C++11) basic_string::rbeginbasic_string::crbegin (C++11) basic_string::rendbasic_string::crend (C++11) Suche basic_string::find basic_string::rfind basic_string::find_first_of basic_string::find_first_not_of basic_string::find_last_of basic_string::find_last_not_of

Modifizierer basic_string::clear basic_string::insert basic_string::insert_range (C++23) basic_string::erase basic_string::push_back basic_string::pop_back (DR*) basic_string::append basic_string::append_range (C++23) basic_string::operator+= basic_string::replace basic_string::replace_with_range (C++23) basic_string::copy basic_string::resize basic_string::resize_and_overwrite (C++23)  basic_string::swap Kapazität basic_string::empty basic_string::sizebasic_string::length basic_string::max_size basic_string::reserve basic_string::capacity basic_string::shrink_to_fit (DR*) Operationen basic_string::compare basic_string::starts_with (C++20) basic_string::ends_with (C++20) basic_string::contains (C++23) basic_string::substr

Konstanten basic_string::npos Nicht-Member-Funktionen operator+ swap(std::basic_string) erase(std::basic_string)erase_if(std::basic_string) (C++20)(C++20) I/O operator<<operator>> getline Vergleich operator==operator!=operator<operator>operator<=operator>=operator<=> (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)(C++20) Numerische Konvertierungen stoistolstoll (C++11)(C++11)(C++11) stoulstoull (C++11)(C++11)  stofstodstold (C++11)(C++11)(C++11) to_string (C++11) to_wstring (C++11) Literale operator""s (C++14) Hilfsklassen hash<std::basic_string> (C++11) Deduction guides (C++17)

 

int compare( const basic_string& str ) const;	(1)	(noexcept seit C++11) (constexpr seit C++20)
int compare( size_type pos1, size_type count1,              const basic_string& str ) const;	(2)	(constexpr seit C++20)
	(3)
int compare( size_type pos1, size_type count1,              const basic_string& str,              size_type pos2, size_type count2 ) const;			(bis C++14)
int compare( size_type pos1, size_type count1,              const basic_string& str,              size_type pos2, size_type count2 = npos ) const;			(seit C++14) (constexpr seit C++20)
int compare( const CharT* s ) const;		(4)	(constexpr seit C++20)
int compare( size_type pos1, size_type count1,              const CharT* s ) const;		(5)	(constexpr seit C++20)
int compare( size_type pos1, size_type count1,              const CharT* s, size_type count2 ) const;		(6)	(constexpr seit C++20)
template< class StringViewLike > int compare( const StringViewLike& t ) const noexcept(/* siehe unten */);		(7)	(seit C++17) (constexpr seit C++20)
template< class StringViewLike > int compare( size_type pos1, size_type count1,              const StringViewLike& t ) const;		(8)	(seit C++17) (constexpr seit C++20)
template< class StringViewLike > int compare( size_type pos1, size_type count1,              const StringViewLike& t,              size_type pos2, size_type count2 = npos) const;		(9)	(seit C++17) (constexpr seit C++20)

Vergleicht zwei Zeichensequenzen.

1) Vergleicht diesen String mit str.

2) Vergleicht einen Teilstring von diesem String [pos1, pos1 + count1) mit str.

• Wenn count1 > size() - pos1, ist der Teilstring [pos1, size()).

3) Vergleicht einen Teilstring von diesem String [pos1, pos1 + count1) mit einem Teilstring von str [pos2, pos2 + count2).

• Wenn count1 > size() - pos1, ist der erste Teilstring [pos1, size()).
• Wenn count2 > str.size() - pos2, ist der zweite Teilstring [pos2, str.size()).

4) Vergleicht diesen String mit der nullterminierten Zeichensequenz, die am durch s zeigenden Zeichen beginnt und die Länge Traits::length(s) hat.

5) Vergleicht einen Teilstring von diesem String [pos1, pos1 + count1) mit der nullterminierten Zeichensequenz, die am durch s zeigenden Zeichen beginnt und die Länge Traits::length(s) hat.

• Wenn count1 > size() - pos1, ist der Teilstring [pos1, size()).

6) Vergleicht einen Teilstring von diesem String [pos1, pos1 + count1) mit den Zeichen im Bereich [s, s + count2). Die Zeichen in [s, s + count2) können Nullzeichen enthalten.

• Wenn count1 > size() - pos1, ist der Teilstring [pos1, size()).

7-9) Konvertiert t implizit in eine String-Ansicht sv, als ob durch std::basic_string_view<CharT, Traits> sv = t;, und vergleicht dann

7) diesen String mit sv;

8) vergleicht einen Teilstring von diesem String [pos1, pos1 + count1) mit sv, als ob durch std::basic_string_view<CharT, Traits>(*this).substr(pos1, count1).compare(sv);

9) vergleicht einen Teilstring von diesem String [pos1, pos1 + count1) mit einem Teilstring von sv [pos2, pos2 + count2), als ob durch std::basic_string_view<CharT, Traits>(*this)
    .substr(pos1, count1).compare(sv.substr(pos2, count2)).

Diese Überladungen nehmen an der Überladungsauflösung teil, nur wenn std::is_convertible_v<const StringViewLike&,
                      std::basic_string_view<CharT, Traits>> true ist und std::is_convertible_v<const StringViewLike&, const CharT*> false ist.

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

• Zuerst wird die Anzahl der zu vergleichenden Zeichen berechnet, als ob 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 bisher gleich), werden ihre Größen wie folgt verglichen:

Bedingung		Ergebnis	Rückgabewert
Traits::compare(data1, data2, rlen) < 0		data1 ist *kleiner* als data2	<0
Traits::compare(data1, data2, rlen) == 0	size1 < size2	data1 ist *kleiner* als data2	<0
	size1 == size2	data1 ist *gleich* data2	​0​
	size1 > size2	data1 ist *größer* als data2	>0
Traits::compare(data1, data2, rlen) > 0		data1 ist *größer* als data2	>0

Parameter

str	-	anderer String zum Vergleichen
s	-	Zeiger auf die zu vergleichende Zeichenkette
count1	-	Anzahl der Zeichen dieses Strings zum Vergleichen
pos1	-	Position des ersten Zeichens in diesem String zum Vergleichen
count2	-	Anzahl der Zeichen des gegebenen Strings zum Vergleichen
pos2	-	Position des ersten Zeichens des gegebenen Strings zum Vergleichen
t	-	Objekt (konvertierbar zu std::basic_string_view), das verglichen werden soll

Rückgabewert

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

Ausnahmen

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

7)

noexcept-Spezifikation:  

noexcept(std::is_nothrow_convertible_v<const T&, std::basic_string_view<CharT, Traits>>)

8,9) Wirft alles, was durch die Konvertierung zu std::basic_string_view geworfen wird.

Wenn aus irgendeinem Grund eine Ausnahme ausgelöst wird, hat diese Funktion keine Auswirkungen (starkes Ausnahmesicherheitsgarantie).

Mögliche Implementierung

Überladung (1)
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; }

Anmerkungen

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

Standardmäßig (mit den Standard-`std::char_traits`) ist diese Funktion nicht sprachabhängig. Sehen Sie std::collate::compare für sprachabhängige Drei-Wege-String-Vergleiche.

Beispiel

Führen Sie diesen Code aus

#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) << " comes before "
                  << std::quoted(str2) << ".\n";
    else if (compare_result > 0)
        std::cout << std::quoted(str2) << " comes before "
                  << std::quoted(str1) << ".\n";
    else
        std::cout << std::quoted(str1) << " and "
                  << std::quoted(str2) << " are the same.\n";
}
 
int main()
{
    std::string batman{"Batman"};
    std::string superman{"Superman"};
    int compare_result{0};
 
    // 1) Compare with other string
    compare_result = batman.compare(superman);
    std::cout << "1) ";
    print_compare_result("Batman", "Superman", compare_result);
 
    // 2) Compare substring with other string
    compare_result = batman.compare(3, 3, superman);
    std::cout << "2) ";
    print_compare_result("man", "Superman", compare_result);
 
    // 3) Compare substring with other substring
    compare_result = batman.compare(3, 3, superman, 5, 3);
    std::cout << "3) ";
    print_compare_result("man", "man", compare_result);
 
    // Compare substring with other substring
    // defaulting to end of other string
    assert(compare_result == batman.compare(3, 3, superman, 5));
 
    // 4) Compare with char pointer
    compare_result = batman.compare("Superman");
    std::cout << "4) ";
    print_compare_result("Batman", "Superman", compare_result);
 
    // 5) Compare substring with char pointer
    compare_result = batman.compare(3, 3, "Superman");
    std::cout << "5) ";
    print_compare_result("man", "Superman", compare_result);
 
    // 6) Compare substring with char pointer substring
    compare_result = batman.compare(0, 3, "Superman", 5);
    std::cout << "6) ";
    print_compare_result("Bat", "Super", compare_result);
}

Ausgabe

1) "Batman" comes before "Superman".
2) "Superman" comes before "man".
3) "man" and "man" are the same.
4) "Batman" comes before "Superman".
5) "Superman" comes before "man".
6) "Bat" comes before "Super".

Fehlerberichte

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

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 5	C++98	Der Parameter count2 der Überladung (6) hatte ein Standardargument npos	Standardargument entfernt, aufgeteilt in die Überladungen (5) und (6)
LWG 847	C++98	Es gab keine Ausnahmesicherheitsgarantie	starke Ausnahmesicherheitsgarantie hinzugefügt
LWG 2946	C++17	Überladung (7) verursachte in einigen Fällen Mehrdeutigkeit	vermieden durch die Erstellung als Template
P1148R0	C++17	noexcept für Überladung (7) wurde versehentlich durch die Auflösung von LWG2946 entfernt	wiederhergestellt

Siehe auch

operator==operator!=operator<operator>operator<=operator>=operator<=> (entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)	vergleicht zwei Strings lexikographisch (function template)
substr	gibt eine Teilzeichenkette zurück (public member function)
collate	definiert lexikographische Vergleiche und Hashing von Zeichenketten (Klassentemplate)
strcoll	vergleicht zwei Strings gemäß der aktuellen Locale (Funktion)
lexicographical_compare	gibt true zurück, wenn ein Bereich lexikographisch kleiner als ein anderer ist (Funktionsvorlage)
compare	vergleicht zwei Ansichten (member function of std::basic_string_view<CharT,Traits>)