resueltos - funciones en c++ pdf

Diferencias entre la cadena de C++== y compare()?

Question

Acabo de leer algunas recomendaciones sobre el uso

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

if( !s.compare(t) ) 
{

en lugar de

if( s == t )
{

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

¿Cuáles son las diferencias? ¿En qué contextos se debe favorecer de un modo a otro?

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

Answer 1

En el depurador de Visual Studio 2012, solo lo siguiente funciona correctamente cuando se comprueba que una cadena está vacía o no:

strcmp(somestring.c_str(),"")==0

volver verdadero

somestring.compare("") 

devuelve 1, y

somestring=="" 

return: ningún operador "==" coincide con estos operandos.

somestring.c_str()==""

retorno: Ha ocurrido un error no especificado.

Answer 2

Esto es lo que la norma tiene que decir sobre el 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;

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

Parece que no hay mucha diferencia!

Answer 3

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

Escribí una pequeña aplicación para comparar el rendimiento, y al parecer, 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 compilas y ejecutas tu código en el entorno Release, ambos son prácticamente iguales.

Para su información, corrí 1,000,000 iteraciones para llegar a tal conclusión.

Para demostrar por qué en el entorno de depuración la cadena :: compare es más rápida, fui al ensamblaje y aquí está el 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)

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

Construcción de liberación

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

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

Answer 4

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

Respuesta más larga: la API proporciona un método para verificar la igualdad de cadenas y un método para verificar el orden de las cadenas. Desea la igualdad de cadenas, así que use el operador de igualdad (para que sus expectativas y las de los implementadores de la biblioteca se alineen). Si el rendimiento es importante, le gustaría probar ambos métodos y encontrar el más rápido.

Answer 5

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

Answer 6

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

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

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

Answer 7

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

• igual a cero si s y t son iguales,
• menor que cero si s es menor que t ,
• mayor que cero si s es mayor que t .

Si desea que su primer fragmento de código sea equivalente al segundo, 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 un bool .

Para profundizar en los casos de uso, compare() puede ser útil si está interesado en cómo las dos cadenas se relacionan entre sí (menos o más) cuando son diferentes. PlasmaHH menciona correctamente los árboles, y también podría ser, digamos, un algoritmo de inserción de cadenas que apunta a mantener el contenedor ordenado, un algoritmo de búsqueda dicotómica para el contenedor mencionado anteriormente, etc.

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

Answer 8

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

Así que no tomes el intercambio de uno por otro a la ligera.

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

Answer 9

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

Answer 10

compare tiene sobrecargas para comparar subcadenas. Si está comparando cadenas enteras, debería usar el operador == (y si las compare llamadas son o no bastante irrelevantes).