Diferenças entre C ++ string == e compare ()?

Acabei de ler algumas recomendações sobre o uso

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

if( !s.compare(t) ) 
{

ao invés de

if( s == t )
{

Estou quase sempre usando o último porque estou acostumado a isso e parece natural, mais legível. Eu nem sabia que havia uma função de comparação separada. Para ser mais preciso, pensei que == chamaria compare ().

Quais são as diferenças? Em quais contextos uma maneira deve ser favorecida à outra?

Estou considerando apenas os casos em que preciso saber se uma string tem o mesmo valor que outra string.

É isso que o padrão tem a dizer sobre 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;

Retorna: lhs.compare (rhs) == 0.

Parece que não há muita diferença!

std :: string :: compare () retorna um int:

• igual a zero se se tsão iguais,
• menor que zero se sfor menor que t,
• maior que zero se sfor maior que t.

Se você deseja que seu primeiro trecho de código seja equivalente ao segundo, ele deve realmente ler:

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

O operador de igualdade testa apenas a igualdade (daí seu nome) e retorna a bool.

Para elaborar os casos de uso, compare()pode ser útil se você estiver interessado em saber como as duas seqüências se relacionam (menos ou maior) quando elas são diferentes. O PlasmaHH menciona com razão as árvores e também pode ser, por exemplo, um algoritmo de inserção de string que visa manter o contêiner classificado, um algoritmo de pesquisa dicotômica para o contêiner mencionado e assim por diante.

EDIT: Como Steve Jessop aponta nos comentários, compare()é mais útil para ordenação rápida e algoritmos de pesquisa binária. Classificações naturais e pesquisas dicotômicas podem ser implementadas apenas com std :: less .

comparepossui sobrecargas para comparar substrings. Se você estiver comparando cadeias inteiras, use o ==operador (e se chama compareou não, é praticamente irrelevante).

Internamente, string::operator==()está usando string::compare(). Consulte: CPlusPlus -string::operator==()

Eu escrevi um pequeno aplicativo para comparar o desempenho e, aparentemente, se você compilar e executar seu código no ambiente de depuração, string::compare()é um pouco mais rápido que string::operator==(). No entanto, se você compilar e executar seu código no ambiente Release, ambos serão praticamente iguais.

Para sua informação, executei 1.000.000 de iterações para chegar a essa conclusão.

Para provar por que, no ambiente de depuração, a string :: compare é mais rápida, fui ao assembly e aqui está o código:

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)

Você pode ver que em string :: operator == (), ele precisa executar operações extras (adicione esp, 8 e movzx edx, al)

CONSTRUÇÃO DE LANÇAMENTO

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)

Ambos os códigos de montagem são muito semelhantes, pois o compilador executa a otimização.

Finalmente, na minha opinião, o ganho de desempenho é insignificante, portanto, eu realmente deixaria para o desenvolvedor decidir qual é o preferido, pois ambos alcançam o mesmo resultado (especialmente quando é a versão lançada).

compare()é equivalente a strcmp (). ==é simples verificação de igualdade. compare()portanto retorna um int, ==é um booleano.

compare()retornará false(bem 0) se as strings forem iguais.

Portanto, não pense em trocar um pelo outro de ânimo leve.

Use o que tornar o código mais legível.

Se você quiser apenas verificar a igualdade das cadeias, use o operador ==. Determinar se duas seqüências são iguais é mais simples do que encontrar uma ordenação (que é o que compare () dá,) para que ele possa ser melhor em termos de performance no seu caso para usar o operador de igualdade.

Resposta mais longa: a API fornece um método para verificar a igualdade de cadeias e um método para verificar a ordem das cadeias. Você deseja igualdade de string, portanto, use o operador de igualdade (para que suas expectativas e as dos implementadores de bibliotecas se alinhem.) Se o desempenho for importante, você poderá testar os dois métodos e encontrar o mais rápido.

Suponha que considere duas cadeias s e t.
Dê a eles alguns valores.
Quando você os compara usando (s == t), ele retorna um valor booleano (verdadeiro ou falso, 1 ou 0).
Mas quando você compara usando s.compare (t) , a expressão retorna um valor
(i) 0 - se s e t forem iguais
(ii) <0 - se o valor do primeiro caractere não correspondido em s for menor que o valor de t ou o comprimento de s é menor que o de t.
(iii) > 0 - se o valor do primeiro caractere não correspondido em t for menor que o de s ou se o comprimento de t for menor que o de s.

Uma coisa que não é abordada aqui é que depende se compararmos string com c string, c string com string ou string com string.

Uma grande diferença é que, para comparar duas cadeias, a igualdade de tamanho é verificada antes de fazer a comparação e isso torna o operador == mais rápido que uma comparação.

aqui está a comparação que eu vejo no 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; }