ความแตกต่างระหว่างสตริง C ++ == และเปรียบเทียบ ()?

ฉันเพิ่งอ่านคำแนะนำเกี่ยวกับการใช้

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

if( !s.compare(t) ) 
{

แทน

if( s == t )
{

ฉันเกือบจะใช้อันสุดท้ายเสมอเพราะฉันชินแล้วและรู้สึกเป็นธรรมชาติอ่านง่ายขึ้น ฉันไม่รู้ด้วยซ้ำว่ามีฟังก์ชั่นการเปรียบเทียบแยกต่างหาก เพื่อให้แม่นยำยิ่งขึ้นฉันคิดว่า == จะเรียกการเปรียบเทียบ ()

อะไรคือความแตกต่าง? ในบริบทใดที่ควรได้รับการสนับสนุนในอีกทางหนึ่ง?

ฉันกำลังพิจารณาเฉพาะกรณีที่ฉันต้องรู้ว่าสตริงเป็นค่าเดียวกันกับสตริงอื่น

นี่คือสิ่งที่มาตรฐานพูดถึง operator==

21.4.8.2 ผู้ประกอบการ ==

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

คืนค่า: lhs.compare (rhs) == 0

ดูเหมือนว่ามีความแตกต่างไม่มาก!

std :: string :: compare ()ส่งคืน an int:

• เท่ากับศูนย์ถ้าsและtเท่ากับ
• น้อยกว่าศูนย์ถ้าsมีค่าน้อยกว่าt,
• มากกว่าศูนย์ถ้ามีค่ามากกว่าst

หากคุณต้องการให้ข้อมูลโค้ดแรกของคุณเทียบเท่ากับข้อมูลโค้ดที่สองควรอ่านจริง:

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

ผู้ประกอบการเท่าเทียมกันเพียงการทดสอบเพื่อความเท่าเทียมกัน (เพราะฉะนั้นชื่อ) boolและผลตอบแทน

ในการอธิบายรายละเอียดเกี่ยวกับกรณีการใช้งานcompare()จะมีประโยชน์หากคุณสนใจว่าทั้งสองสายเกี่ยวข้องกันอย่างไร (น้อยกว่าหรือมากกว่า) เมื่อเกิดความแตกต่าง PlasmaHH กล่าวถึงต้นไม้อย่างถูกต้องและอาจกล่าวได้ว่าเป็นอัลกอริธึมการแทรกสตริงที่มีจุดมุ่งหมายเพื่อให้ภาชนะเรียงลำดับอัลกอริทึมการค้นหาแบบแบ่งขั้วสำหรับคอนเทนเนอร์ดังกล่าวและอื่น ๆ

แก้ไข:ตามที่สตีฟเจสซอพชี้ให้เห็นในความคิดเห็นcompare()มีประโยชน์มากที่สุดสำหรับอัลกอริทึมการเรียงลำดับอย่างรวดเร็วและค้นหา การเรียงลำดับตามธรรมชาติและการค้นหาแบบแบ่งขั้วสามารถนำไปใช้ได้ด้วยstd :: lessเท่านั้น

compareมีภาระเกินสำหรับการเปรียบเทียบสตริงย่อย หากคุณกำลังเปรียบเทียบสตริงทั้งหมดคุณควรใช้==โอเปอเรเตอร์ (และไม่ว่าจะเป็นการโทรcompareหรือไม่นั้นก็ไม่เกี่ยวข้องเลย)

ภายในใช้string::operator==() string::compare()โปรดอ้างอิงถึง: CPlusPlus -string::operator==()

ผมเขียนโปรแกรมขนาดเล็กเพื่อเปรียบเทียบประสิทธิภาพการทำงานและเห็นได้ชัดถ้าคุณรวบรวมและเรียกใช้รหัสของคุณในสภาพแวดล้อมการแก้ปัญหาจะเร็วกว่าเล็กน้อยstring::compare() string::operator==()อย่างไรก็ตามถ้าคุณคอมไพล์และรันโค้ดในสภาวะแวดล้อม Release ทั้งคู่ก็เหมือนกัน

FYI ฉันวิ่ง 1,000,000 ซ้ำเพื่อหาข้อสรุปดังกล่าว

เพื่อพิสูจน์ว่าทำไมในสภาพแวดล้อมการแก้ปัญหาสตริง :: การเปรียบเทียบเร็วขึ้นฉันไปที่การชุมนุมและนี่คือรหัส:

สร้างข้อบกพร่อง

สตริง :: ประกอบ == ()

        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)  

สตริง :: เปรียบเทียบ ()

            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)

คุณจะเห็นว่าใน string :: operator == () มันจะต้องดำเนินการพิเศษ (เพิ่ม esp, 8 และ movzx edx, al)

ปล่อยสร้าง

สตริง :: ประกอบ == ()

        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)  

สตริง :: เปรียบเทียบ ()

            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)

รหัสการประกอบทั้งสองมีความคล้ายคลึงกันมากเนื่องจากคอมไพเลอร์ทำการปรับให้เหมาะสม

ในที่สุดในความคิดของฉันการเพิ่มประสิทธิภาพนั้นเล็กน้อยดังนั้นฉันจะปล่อยให้นักพัฒนาตัดสินใจจริงๆว่าจะเลือกอันไหนดีกว่าทั้งคู่ให้ได้ผลลัพธ์เดียวกัน (โดยเฉพาะอย่างยิ่งเมื่อมีการปล่อยบิลด์)

compare()เทียบเท่ากับ strcmp () ==เป็นการตรวจสอบความเสมอภาคอย่างง่าย compare()จึงส่งกลับint, ==เป็นแบบบูล

compare()จะส่งกลับfalse(ดี0) ถ้าสตริงเท่ากัน

ดังนั้นอย่าเอามาแลกเปลี่ยนกันเบา ๆ

ใช้วิธีใดก็ตามที่ทำให้โค้ดอ่านง่ายขึ้น

หากคุณต้องการตรวจสอบความเท่าเทียมกันของสตริงให้ใช้ตัวดำเนินการ == การพิจารณาว่าสองสตริงเท่ากันนั้นง่ายกว่าการค้นหาการจัดลำดับ (ซึ่งเป็นสิ่งที่เปรียบเทียบ () ให้) ดังนั้นจึงควรใช้ประสิทธิภาพดีกว่าในกรณีของคุณเพื่อใช้ตัวดำเนินการความเท่าเทียมกัน

คำตอบที่ยาวกว่า: API มีวิธีการตรวจสอบความเท่าเทียมกันของสตริงและวิธีตรวจสอบการสั่งซื้อสตริง คุณต้องการความเท่าเทียมกันของสตริงดังนั้นให้ใช้ตัวดำเนินการความเท่าเทียมกัน (เพื่อให้ความคาดหวังของคุณและของผู้จัดทำไลบรารีปรับแนว) หากประสิทธิภาพมีความสำคัญคุณอาจต้องการทดสอบทั้งสองวิธีและหาวิธีที่เร็วที่สุด

สมมติว่าพิจารณาสองสตริง s และ t
ให้คุณค่ากับพวกเขาบ้าง
เมื่อคุณเปรียบเทียบพวกเขาโดยใช้(s == t)มันจะคืนค่าบูลีน (จริงหรือเท็จ, 1 หรือ 0)
แต่เมื่อคุณเปรียบเทียบโดยใช้s.compare (t)นิพจน์จะส่งกลับค่า
(i) 0 - ถ้า s และ t เท่ากับ
(ii) <0 - อย่างใดอย่างหนึ่งหากค่าของอักขระที่ไม่ตรงกันในตัวแรกนั้นน้อยกว่า t หรือความยาวของ s น้อยกว่าของ t
(iii) > 0 - อย่างใดอย่างหนึ่งหากค่าของอักขระที่ไม่ตรงกันใน t มีค่าน้อยกว่า s หรือความยาวของ t น้อยกว่า s

สิ่งหนึ่งที่ไม่ได้กล่าวถึงในที่นี้คือมันขึ้นอยู่กับว่าเราเปรียบเทียบสตริงกับสตริง c หรือไม่?

ข้อแตกต่างที่สำคัญคือการเปรียบเทียบความเท่าเทียมกันของขนาดสตริงสองรายการจะถูกตรวจสอบก่อนทำการเปรียบเทียบและทำให้ตัวดำเนินการ == เร็วกว่าการเปรียบเทียบ

นี่คือการเปรียบเทียบที่ฉันเห็นใน g ++ Debian 7

// operator ==
  /**
   *  @brief  Test equivalence of two strings.
   *  @param __lhs  First string.
   *  @param __rhs  Second string.
   *  @return  True if @a __lhs.compare(@a __rhs) == 0.  False otherwise.
   */
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
           const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) == 0; }

  template<typename _CharT>
    inline
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
    operator==(const basic_string<_CharT>& __lhs,
           const basic_string<_CharT>& __rhs)
    { return (__lhs.size() == __rhs.size()
          && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
                            __lhs.size())); }

  /**
   *  @brief  Test equivalence of C string and string.
   *  @param __lhs  C string.
   *  @param __rhs  String.
   *  @return  True if @a __rhs.compare(@a __lhs) == 0.  False otherwise.
   */
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const _CharT* __lhs,
           const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) == 0; }

  /**
   *  @brief  Test equivalence of string and C string.
   *  @param __lhs  String.
   *  @param __rhs  C string.
   *  @return  True if @a __lhs.compare(@a __rhs) == 0.  False otherwise.
   */
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
           const _CharT* __rhs)
    { return __lhs.compare(__rhs) == 0; }