std::basic_string<CharT,Traits,Allocator>:: compare

Compara dos secuencias de caracteres.

Una secuencia de caracteres que consiste en count1 caracteres comenzando en data1 se compara con una secuencia de caracteres que consiste en count2 caracteres comenzando en data2 de la siguiente manera:

• Primero, calcula el número de caracteres a comparar, como si fuera mediante size_type rlen = std:: min ( count1, count2 ) .
• Luego compara las secuencias llamando a Traits :: compare ( data1, data2, rlen ) . Para cadenas estándar esta función realiza una comparación lexicográfica carácter por carácter. Si el resultado es cero (las secuencias de caracteres son iguales hasta ahora), entonces sus tamaños se comparan de la siguiente manera:

Parámetros

Valor de retorno

• Valor negativo si * this aparece antes de la secuencia de caracteres especificada por los argumentos, en orden lexicográfico.
• Cero si ambas secuencias de caracteres son equivalentes en la comparación.
• Valor positivo si * this aparece después de la secuencia de caracteres especificada por los argumentos, en orden lexicográfico.

Excepciones

Las sobrecargas que toman parámetros llamados pos1 o pos2 lanzan std::out_of_range si el argumento está fuera de rango.

Si se lanza una excepción por cualquier razón, esta función no tiene efecto ( strong exception safety guarantee ).

Implementación posible

template<class CharT, class Traits, class Alloc>
int std::basic_string<CharT, Traits, Alloc>::compare
    (const std::basic_string& s) const noexcept
{
    size_type lhs_sz = size();
    size_type rhs_sz = s.size();
    int result = traits_type::compare(data(), s.data(), std::min(lhs_sz, rhs_sz));
    if (result != 0)
        return result;
    if (lhs_sz < rhs_sz)
        return -1;
    if (lhs_sz > rhs_sz)
        return 1;
    return 0;
}

Notas

Para las situaciones en las que no se requiere una comparación de tres vías, std::basic_string proporciona los operadores relacionales habituales ( < , <= , == , > , etc).

Por defecto (con la configuración predeterminada de std::char_traits ), esta función no es sensible a la configuración regional. Consulte std::collate::compare para comparación de cadenas triple con reconocimiento de configuración regional.

Ejemplo

#include <cassert>
#include <iomanip>
#include <iostream>
#include <string>
#include <string_view>
void print_compare_result(std::string_view str1,
                          std::string_view str2,
                          int compare_result)
{
    if (compare_result < 0)
        std::cout << std::quoted(str1) << " viene antes de "
                  << std::quoted(str2) << ".\n";
    else if (compare_result > 0)
        std::cout << std::quoted(str2) << " viene antes de "
                  << std::quoted(str1) << ".\n";
    else
        std::cout << std::quoted(str1) << " y "
                  << std::quoted(str2) << " son iguales.\n";
}
int main()
{
    std::string batman{"Batman"};
    std::string superman{"Superman"};
    int compare_result{0};
    // 1) Comparar con otra cadena
    compare_result = batman.compare(superman);
    std::cout << "1) ";
    print_compare_result("Batman", "Superman", compare_result);
    // 2) Comparar subcadena con otra cadena
    compare_result = batman.compare(3, 3, superman);
    std::cout << "2) ";
    print_compare_result("man", "Superman", compare_result);
    // 3) Comparar subcadena con otra subcadena
    compare_result = batman.compare(3, 3, superman, 5, 3);
    std::cout << "3) ";
    print_compare_result("man", "man", compare_result);
    // Comparar subcadena con otra subcadena
    // por defecto hasta el final de la otra cadena
    assert(compare_result == batman.compare(3, 3, superman, 5));
    // 4) Comparar con puntero a caracteres
    compare_result = batman.compare("Superman");
    std::cout << "4) ";
    print_compare_result("Batman", "Superman", compare_result);
    // 5) Comparar subcadena con puntero a caracteres
    compare_result = batman.compare(3, 3, "Superman");
    std::cout << "5) ";
    print_compare_result("man", "Superman", compare_result);
    // 6) Comparar subcadena con subcadena de puntero a caracteres
    compare_result = batman.compare(0, 3, "Superman", 5);
    std::cout << "6) ";
    print_compare_result("Bat", "Super", compare_result);
}

1) "Batman" viene antes de "Superman".
2) "Superman" viene antes de "man".
3) "man" y "man" son iguales.
4) "Batman" viene antes de "Superman".
5) "Superman" viene antes de "man".
6) "Bat" viene antes de "Super".

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

Véase también