Comparación de cadenas que no distingue entre mayúsculas y minúsculas en C++ [closed]

¿Cuál es la mejor manera de hacer una comparación de cadenas que no distingue entre mayúsculas y minúsculas en C++ sin transformar una cadena a mayúsculas o minúsculas?

Indique si los métodos son compatibles con Unicode y qué tan portátiles son.

Boost incluye un algoritmo útil para esto:

#include <boost/algorithm/string.hpp>
// Or, for fewer header dependencies:
//#include <boost/algorithm/string/predicate.hpp>

std::string str1 = "hello, world!";
std::string str2 = "HELLO, WORLD!";

if (boost::iequals(str1, str2))
{
    // Strings are identical
}

Aprovecha el estándar char_traits. Recuerda que un std::string es de hecho un typedef para std::basic_string<char>o más explícitamente, std::basic_string<char, std::char_traits<char> >. los char_traits type describe cómo se comparan los caracteres, cómo se copian, cómo se emiten, etc. Todo lo que necesita hacer es escribir una nueva cadena sobre basic_stringy proporcionarlo con su propia costumbre char_traits que comparan mayúsculas y minúsculas insensiblemente.

struct ci_char_traits : public char_traits<char> {
    static bool eq(char c1, char c2) { return toupper(c1) == toupper(c2); }
    static bool ne(char c1, char c2) { return toupper(c1) != toupper(c2); }
    static bool lt(char c1, char c2) { return toupper(c1) <  toupper(c2); }
    static int compare(const char* s1, const char* s2, size_t n) {
        while( n-- != 0 ) {
            if( toupper(*s1) < toupper(*s2) ) return -1;
            if( toupper(*s1) > toupper(*s2) ) return 1;
            ++s1; ++s2;
        }
        return 0;
    }
    static const char* find(const char* s, int n, char a) {
        while( n-- > 0 && toupper(*s) != toupper(a) ) {
            ++s;
        }
        return s;
    }
};

typedef std::basic_string<char, ci_char_traits> ci_string;

Los detalles están en Gurú de la semana número 29.

El problema con boost es que tienes que vincularte y depender de boost. No es fácil en algunos casos (por ejemplo, android).

Y usar char_traits significa todos sus comparaciones no distinguen entre mayúsculas y minúsculas, lo que generalmente no es lo que desea.

Esto debería ser suficiente. Debe ser razonablemente eficiente. Sin embargo, no maneja Unicode ni nada.

bool iequals(const string& a, const string& b)
{
    unsigned int sz = a.size();
    if (b.size() != sz)
        return false;
    for (unsigned int i = 0; i < sz; ++i)
        if (tolower(a[i]) != tolower(b[i]))
            return false;
    return true;
}

Actualización: versión adicional C++14 (#include <algorithm>):

bool iequals(const string& a, const string& b)
{
    return std::equal(a.begin(), a.end(),
                      b.begin(), b.end(),
                      [](char a, char b) {
                          return tolower(a) == tolower(b);
                      });
}

Actualización: versión C ++ 20 usando std::ranges:

#include <ranges>
#include <algorithm>
#include <string>

bool iequals(const std::string_view& lhs, const std::string_view& rhs) {
    auto to_lower{ std::ranges::views::transform(std::tolower) };
    return std::ranges::equal(lhs | to_lower, rhs | to_lower);
}

Si está en un sistema POSIX, puede usar strcasecmp. Sin embargo, esta función no forma parte del estándar C ni está disponible en Windows. Esto realizará una comparación sin distinción entre mayúsculas y minúsculas en caracteres de 8 bits, siempre que la configuración regional sea POSIX. Si la configuración regional no es POSIX, los resultados no están definidos (por lo que podría hacer una comparación localizada o no). No hay disponible un equivalente de caracteres anchos.

De lo contrario, una gran cantidad de implementaciones históricas de la biblioteca C tienen las funciones stricmp() y strnicmp(). Visual C ++ en Windows cambió el nombre de todos estos prefijándolos con un guión bajo porque no son parte del estándar ANSI, por lo que en ese sistema se llaman _stricmp o _strnicmp. Algunas bibliotecas también pueden tener funciones equivalentes de caracteres anchos o multibyte (normalmente denominadas, por ejemplo, wcsicmp, mbcsicmp, etc.).

C y C++ ignoran en gran medida los problemas de internacionalización, por lo que no hay una buena solución para este problema, excepto usar una biblioteca de terceros. Verificar IBM ICU (Componentes internacionales para Unicode) si necesita una biblioteca robusta para C/C++. ICU es para sistemas Windows y Unix.

¿Está hablando de una comparación tonta que no distingue entre mayúsculas y minúsculas o una comparación Unicode completamente normalizada?

Una comparación tonta no encontrará cadenas que puedan ser iguales pero que no sean binarias iguales.

Ejemplo:

U212B (ANGSTROM SIGN)
U0041 (LATIN CAPITAL LETTER A) + U030A (COMBINING RING ABOVE)
U00C5 (LATIN CAPITAL LETTER A WITH RING ABOVE).

Son todos equivalentes pero también tienen diferentes representaciones binarias.

Dicho esto, Normalización Unicode debería ser una lectura obligatoria, especialmente si planea admitir Hangul, Thai y otros idiomas asiáticos.

Además, IBM prácticamente patentó la mayoría de los algoritmos Unicode optimizados y los puso a disposición del público. También mantienen una implementación: Unidad de cuidados intensivos de IBM

boost::iequals no es compatible con utf-8 en el caso de cadenas. Puedes usar impulso::locale.

comparator<char,collator_base::secondary> cmpr;
cout << (cmpr(str1, str2) ? "str1 < str2" : "str1 >= str2") << endl;

• Primario: ignore los acentos y las mayúsculas y minúsculas, comparando solo las letras base. Por ejemplo, “fachada” y “Fachada” son lo mismo.
• Secundario: ignora las mayúsculas y minúsculas pero considera los acentos. “fachada” y “fachada” son diferentes pero “fachada” y “fachada” son lo mismo.
• Terciario: considere tanto el caso como los acentos: “Fachada” y “fachada” son diferentes. Ignora la puntuación.
• Cuaternario: considere todas las mayúsculas y minúsculas, los acentos y la puntuación. Las palabras deben ser idénticas en términos de representación Unicode.
• Idéntico: como cuaternario, pero también compare puntos de código.

Mi primer pensamiento para una versión no Unicode fue hacer algo como esto:

bool caseInsensitiveStringCompare(const string& str1, const string& str2) {
    if (str1.size() != str2.size()) {
        return false;
    }
    for (string::const_iterator c1 = str1.begin(), c2 = str2.begin(); c1 != str1.end(); ++c1, ++c2) {
        if (tolower(static_cast<unsigned char>(*c1)) != tolower(static_cast<unsigned char>(*c2))) {
            return false;
        }
    }
    return true;
}