¿Diferencias entre C ++ string == y compare ()?

Acabo de leer algunas recomendaciones sobre el uso

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

if( !s.compare(t) ) 
{

en vez de

if( s == t )
{

Casi siempre uso el último porque estoy acostumbrado y se siente natural, más legible. Ni siquiera sabía que había una función de comparación separada. Para ser más preciso, pensé que == llamaría a compare ().

¿Cuáles son las diferencias? ¿En qué contextos se debe favorecer un camino al otro?

Solo estoy considerando los casos en los que necesito saber si una cadena tiene el mismo valor que otra cadena.

Esto es lo que la norma tiene que decir sobre operator==

21.4.8.2 operador ==

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

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

¡Parece que no hay mucha diferencia!

std :: string :: compare () devuelve un int:

• igual a cero si sy tson iguales,
• menor que cero si ses menor que t,
• mayor que cero si ses mayor que t.

Si desea que su primer fragmento de código sea equivalente al segundo, en realidad debería leer:

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

El operador de igualdad solo prueba la igualdad (de ahí su nombre) y devuelve a bool.

Para elaborar sobre los casos de uso, compare()puede ser útil si está interesado en cómo las dos cadenas se relacionan entre sí (menor o mayor) cuando son diferentes. PlasmaHH menciona con razón los árboles, y también podría ser, por ejemplo, un algoritmo de inserción de cadenas que tiene como objetivo mantener el contenedor ordenado, un algoritmo de búsqueda dicotómica para el contenedor antes mencionado, y así sucesivamente.

EDITAR: Como señala Steve Jessop en los comentarios, compare()es más útil para la clasificación rápida y los algoritmos de búsqueda binaria. Los tipos naturales y las búsquedas dicotómicas se pueden implementar con solo std :: less .

comparetiene sobrecargas para comparar subcadenas. Si está comparando cadenas enteras, solo debe usar el ==operador (y si llama compareo no es prácticamente irrelevante).

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

Escribí una pequeña aplicación para comparar el rendimiento, y aparentemente si compilas y ejecutas tu código en un entorno de depuración string::compare()es un poco más rápido que string::operator==(). Sin embargo, si compila y ejecuta su código en el entorno Release, ambos son más o menos lo mismo.

Para su información, ejecuté 1,000,000 de iteraciones para llegar a tal conclusión.

Para demostrar por qué en el entorno de depuración, string :: compare es más rápido, fui al ensamblado y aquí está el código:

DEPURAR CONSTRUIR

cadena :: operador == ()

        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)

Puede ver que en string :: operator == (), tiene que realizar operaciones adicionales (agregue esp, 8 y movzx edx, al)

LANZAMIENTO CONSTRUIR

cadena :: operador == ()

        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 códigos de ensamblaje son muy similares ya que el compilador realiza la optimización.

Finalmente, en mi opinión, la ganancia de rendimiento es insignificante, por lo tanto, realmente le dejaría al desarrollador decidir cuál es la preferida, ya que ambas logran el mismo resultado (especialmente cuando se trata de la versión de lanzamiento).

compare()es equivalente a strcmp (). ==es simple comprobación de igualdad. compare()por lo tanto, devuelve un int, ==es un booleano.

compare()volverá false(bueno,0 ) si las cadenas son iguales.

Por lo tanto, no tome intercambiar uno por el otro a la ligera.

Use lo que haga que el código sea más legible.

Si solo desea verificar la igualdad de la cadena, use el operador ==. Determinar si dos cadenas son iguales es más simple que encontrar un orden (que es lo que compara () da), por lo que podría ser mejor en términos de rendimiento en su caso utilizar el operador de igualdad.

Respuesta más larga: la API proporciona un método para verificar la igualdad de la cadena y un método para verificar el orden de las cadenas. Si desea la igualdad de cadenas, utilice el operador de igualdad (para que sus expectativas y las de los implementadores de la biblioteca se alineen). Si el rendimiento es importante, entonces puede probar ambos métodos y encontrar el más rápido.

Supongamos considerar dos cadenas s y t.
Dales algunos valores.
Cuando los compara usando (s == t) , devuelve un valor booleano (verdadero o falso, 1 o 0).
Pero cuando compara usando s.compare (t) , la expresión devuelve un valor
(i) 0 , si syt son iguales
(ii) <0 , ya sea si el valor del primer carácter no coincidente en s es menor que el de to la longitud de s es menor que la de t.
(iii) > 0 : si el valor del primer carácter no coincidente en t es menor que el de s o la longitud de t es menor que la de s.

Una cosa que no se cubre aquí es que depende si comparamos cadena con cadena c, cadena con cadena o cadena con cadena.

Una diferencia importante es que para comparar dos cadenas, la igualdad de tamaño se verifica antes de hacer la comparación y eso hace que el operador == sea más rápido que una comparación.

Aquí está la comparación tal como la veo en 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; }