Unterschiede zwischen C++ string == und compare()?

Question

Ich habe gerade einige Empfehlungen zur Verwendung von

std::string s = get_string();
std::string t = another_string();

if( !s.compare(t) ) 
{

anstelle von

if( s == t )
{

Ich verwende fast immer die letzte Variante, weil ich daran gewöhnt bin und sie sich natürlicher und besser lesbar anfühlt. Ich wusste nicht einmal, dass es eine separate Vergleichsfunktion gibt. Um genauer zu sein, dachte ich, == würde compare() aufrufen.

Was sind die Unterschiede? In welchen Kontexten sollte die eine Methode der anderen vorgezogen werden?

Ich ziehe nur die Fälle in Betracht, in denen ich wissen muss, ob eine Zeichenkette derselbe Wert wie eine andere Zeichenkette ist.

Answer 1

Dies ist der Inhalt der Norm operator==

21.4.8.2 operator==

template<class charT, class traits, class Allocator>
bool operator==(const basic_string<charT,traits,Allocator>& lhs,
                const basic_string<charT,traits,Allocator>& rhs) noexcept;

Rückgabe: lhs.compare(rhs) == 0.

Es scheint, als gäbe es keinen großen Unterschied!

Answer 2

std::string::compare() gibt eine int :

• gleich Null, wenn s y t gleich sind,
• weniger als Null, wenn s ist kleiner als t ,
• größer als Null, wenn s größer ist als t .

Wenn Sie möchten, dass Ihr erster Codeschnipsel dem zweiten gleichwertig ist, sollte er eigentlich lauten:

if (!s.compare(t)) {
    // 's' and 't' are equal.
}

Der Gleichheitsoperator prüft nur auf Gleichheit (daher sein Name) und gibt eine bool .

Um auf die Anwendungsfälle einzugehen, compare() kann nützlich sein, wenn Sie daran interessiert sind, wie sich die beiden Strings zueinander verhalten (weniger oder mehr), wenn sie unterschiedlich sind. PlasmaHH erwähnt zu Recht Bäume, und es könnte auch, sagen wir, ein Algorithmus zum Einfügen von Zeichenketten sein, der darauf abzielt, den Container sortiert zu halten, ein dichotomer Suchalgorithmus für den oben erwähnten Container und so weiter.

EDIT: Wie Steve Jessop in den Kommentaren anmerkt, compare() ist besonders nützlich für schnelle Sortier- und binäre Suchalgorithmen. Natürliche Sortierungen und dichotomische Suchen können mit nur std::less .

Answer 3

Intern, string::operator==() verwendet string::compare() . Bitte beachten Sie: CPlusPlus - string::operator==()

Ich habe eine kleine Anwendung geschrieben, um die Leistung zu vergleichen, und anscheinend, wenn Sie kompilieren und führen Sie Ihren Code auf Debug-Umgebung die string::compare() ist etwas schneller als string::operator==() . Wenn Sie Ihren Code jedoch in der Release-Umgebung kompilieren und ausführen, sind beide ziemlich gleich.

Zu Ihrer Information: Ich habe 1.000.000 Iterationen durchgeführt, um zu einer solchen Schlussfolgerung zu kommen.

Um zu beweisen, warum in der Debug-Umgebung der string::compare schneller ist, ging ich zur Assembly und hier ist der Code:

DEBUG BUILD

string::operator==()

        if (str1 == str2)
00D42A34  lea         eax,[str2]  
00D42A37  push        eax  
00D42A38  lea         ecx,[str1]  
00D42A3B  push        ecx  
00D42A3C  call        std::operator==<char,std::char_traits<char>,std::allocator<char> > (0D23EECh)  
00D42A41  add         esp,8  
00D42A44  movzx       edx,al  
00D42A47  test        edx,edx  
00D42A49  je          Algorithm::PerformanceTest::stringComparison_usingEqualOperator1+0C4h (0D42A54h)  

string::compare()

            if (str1.compare(str2) == 0)
00D424D4  lea         eax,[str2]  
00D424D7  push        eax  
00D424D8  lea         ecx,[str1]  
00D424DB  call        std::basic_string<char,std::char_traits<char>,std::allocator<char> >::compare (0D23582h)  
00D424E0  test        eax,eax  
00D424E2  jne         Algorithm::PerformanceTest::stringComparison_usingCompare1+0BDh (0D424EDh)

Sie können sehen, dass in string::operator==() zusätzliche Operationen durchgeführt werden müssen (add esp, 8 und movzx edx,al)

FREIGABE GEBÄUDE

string::operator==()

        if (str1 == str2)
008533F0  cmp         dword ptr [ebp-14h],10h  
008533F4  lea         eax,[str2]  
008533F7  push        dword ptr [ebp-18h]  
008533FA  cmovae      eax,dword ptr [str2]  
008533FE  push        eax  
008533FF  push        dword ptr [ebp-30h]  
00853402  push        ecx  
00853403  lea         ecx,[str1]  
00853406  call        std::basic_string<char,std::char_traits<char>,std::allocator<char> >::compare (0853B80h)  

string::compare()

            if (str1.compare(str2) == 0)
    00853830  cmp         dword ptr [ebp-14h],10h  
    00853834  lea         eax,[str2]  
    00853837  push        dword ptr [ebp-18h]  
    0085383A  cmovae      eax,dword ptr [str2]  
    0085383E  push        eax  
    0085383F  push        dword ptr [ebp-30h]  
    00853842  push        ecx  
00853843  lea         ecx,[str1]  
00853846  call        std::basic_string<char,std::char_traits<char>,std::allocator<char> >::compare (0853B80h)

Beide Assemblercodes sind sich sehr ähnlich, da der Compiler eine Optimierung durchführt.

Meiner Meinung nach ist der Leistungsgewinn vernachlässigbar, daher würde ich es dem Entwickler überlassen, zu entscheiden, welche Variante er bevorzugt, da beide das gleiche Ergebnis erzielen (vor allem, wenn es sich um ein Release-Build handelt).

Answer 4

compare hat Überladungen für den Vergleich von Teilzeichenfolgen. Wenn Sie ganze Zeichenketten vergleichen, sollten Sie einfach == Operator (und ob er die compare oder nicht, ist so gut wie irrelevant).

Answer 5

compare() ist äquivalent zu strcmp(). == ist eine einfache Gleichheitsprüfung. compare() gibt daher eine int , == ist ein Boolescher Wert.