Comparaison de chaînes insensible à la casse en C ++ [fermé]

Quelle est la meilleure façon de faire une comparaison de chaînes insensible à la casse en C ++ sans transformer une chaîne en majuscules ou en minuscules?

Veuillez indiquer si les méthodes sont compatibles avec Unicode et à quel point elles sont portables.

Boost comprend un algorithme pratique pour cela:

#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
}

Profitez de la norme char_traits. Rappelons qu'un std::stringest en fait un typedef pour std::basic_string<char>, ou plus explicitement, std::basic_string<char, std::char_traits<char> >. Le char_traitsgenre décrit comment les personnages se comparent, comment ils copient, comment ils jettent etc. Tout ce que vous devez faire est typedef une nouvelle chaîne sur basic_string, et de fournir avec votre propre coutume char_traitsqui comparent insensible à la casse.

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;

Les détails sont sur le gourou de la semaine numéro 29 .

Le problème avec le boost est que vous devez vous relier au boost et en dépendre. Pas facile dans certains cas (par exemple Android).

Et l'utilisation de char_traits signifie que toutes vos comparaisons sont insensibles à la casse, ce qui n'est généralement pas ce que vous voulez.

Cela devrait suffire. Il devrait être raisonnablement efficace. Ne gère pas unicode ou quoi que ce soit.

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;
}

Mise à jour: Version Bonus 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);
                      });
}

Si vous êtes sur un système POSIX, vous pouvez utiliser strcasecmp . Cette fonction ne fait pas partie de la norme C, cependant, elle n'est pas non plus disponible sur Windows. Cela effectuera une comparaison insensible à la casse sur les caractères 8 bits, tant que les paramètres régionaux sont POSIX. Si les paramètres régionaux ne sont pas POSIX, les résultats ne sont pas définis (il peut donc effectuer une comparaison localisée ou non). Un équivalent à caractères larges n'est pas disponible.

A défaut, un grand nombre d'implémentations de bibliothèque C historiques ont les fonctions stricmp () et strnicmp (). Visual C ++ sur Windows a renommé tous ces éléments en les préfixant avec un trait de soulignement car ils ne font pas partie de la norme ANSI, donc sur ce système, ils sont appelés _stricmp ou _strnicmp . Certaines bibliothèques peuvent également avoir des fonctions équivalentes à caractères larges ou à plusieurs octets (généralement nommées par exemple wcsicmp, mbcsicmp, etc.).

C et C ++ sont tous deux largement ignorants des problèmes d'internationalisation, il n'y a donc pas de bonne solution à ce problème, sauf pour utiliser une bibliothèque tierce. Consultez IBM ICU (International Components for Unicode) si vous avez besoin d'une bibliothèque robuste pour C / C ++. ICU est destiné aux systèmes Windows et Unix.

Parlez-vous d'une comparaison insensible à la casse ou d'une comparaison Unicode normalisée complète?

Une comparaison stupide ne trouvera pas de chaînes qui pourraient être identiques mais qui ne sont pas égales en binaire.

Exemple:

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

Sont tous équivalents mais ont également des représentations binaires différentes.

Cela dit, la normalisation Unicode devrait être une lecture obligatoire, surtout si vous prévoyez de prendre en charge le Hangul, le Thaï et d'autres langues asiatiques.

De plus, IBM a à peu près breveté les algorithmes Unicode les plus optimisés et les a rendus publics. Ils maintiennent également une implémentation: IBM ICU

boost :: iequals n'est pas compatible utf-8 dans le cas d'une chaîne. Vous pouvez utiliser boost :: locale .

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

• Primaire - ignore les accents et la casse des caractères, en comparant uniquement les lettres de base. Par exemple, "façade" et "Façade" sont les mêmes.
• Secondaire - ignorer la casse des caractères mais considérer les accents. "façade" et "façade" sont différents mais "Façade" et "façade" sont les mêmes.
• Tertiaire - considérez à la fois le boîtier et les accents: "Façade" et "façade" sont différents. Ignorez la ponctuation.
• Quaternaire - tenez compte de tous les cas, accents et signes de ponctuation. Les mots doivent être identiques en termes de représentation Unicode.
• Identique - comme quaternaire, mais comparez également les points de code.

Ma première pensée pour une version non-unicode a été de faire quelque chose comme ceci:

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(*c1) != tolower(*c2)) {
            return false;
        }
    }
    return true;
}

Vous pouvez utiliser strcasecmpsur Unix ou stricmpsur Windows.

Une chose qui n'a pas été mentionnée jusqu'à présent est que si vous utilisez des chaînes stl avec ces méthodes, il est utile de comparer d'abord la longueur des deux chaînes, car ces informations sont déjà disponibles dans la classe de chaînes. Cela pourrait empêcher de faire la comparaison de chaînes coûteuse si les deux chaînes que vous comparez ne sont même pas de la même longueur en premier lieu.

Fonctions de chaîne Visual C ++ prenant en charge unicode: http://msdn.microsoft.com/en-us/library/cc194799.aspx

celui que vous cherchez probablement est _wcsnicmp

J'essaie de concocter une bonne réponse de tous les messages, alors aidez-moi à modifier ceci:

Voici une méthode pour le faire, même si elle transforme les chaînes et n'est pas compatible avec Unicode, elle devrait être portable, ce qui est un avantage:

bool caseInsensitiveStringCompare( const std::string& str1, const std::string& str2 ) {
    std::string str1Cpy( str1 );
    std::string str2Cpy( str2 );
    std::transform( str1Cpy.begin(), str1Cpy.end(), str1Cpy.begin(), ::tolower );
    std::transform( str2Cpy.begin(), str2Cpy.end(), str2Cpy.begin(), ::tolower );
    return ( str1Cpy == str2Cpy );
}

D'après ce que j'ai lu, c'est plus portable que stricmp () car stricmp () ne fait en fait pas partie de la bibliothèque std, mais seulement implémenté par la plupart des éditeurs de compilateurs.

Pour obtenir une implémentation vraiment Unicode, il semble que vous devez sortir de la bibliothèque std. Une bonne bibliothèque tierce est l' IBM ICU (International Components for Unicode)

Aussi boost :: iequals fournit un assez bon utilitaire pour faire ce genre de comparaison.

str1.size() == str2.size() && std::equal(str1.begin(), str1.end(), str2.begin(), [](auto a, auto b){return std::tolower(a)==std::tolower(b);})

Vous pouvez utiliser le code ci-dessus en C ++ 14 si vous n'êtes pas en mesure d'utiliser boost. Vous devez utiliser std::towlowerpour les caractères larges.

La bibliothèque Boost.String possède de nombreux algorithmes pour effectuer des comparaisons insensibles à la casse, etc.

Vous pouvez implémenter le vôtre, mais pourquoi s'embêter quand c'est déjà fait?

Pour info, strcmp()et stricmp()sont vulnérables au débordement de tampon, car ils ne traitent que jusqu'à ce qu'ils atteignent un terminateur nul. Il est plus sûr d'utiliser _strncmp()et _strnicmp().

Voir std::lexicographical_compare:

// lexicographical_compare example
#include <iostream>  // std::cout, std::boolalpha
#include <algorithm>  // std::lexicographical_compare
#include <cctype>  // std::tolower

// a case-insensitive comparison function:
bool mycomp (char c1, char c2) {
    return std::tolower(c1) < std::tolower(c2);
}

int main () {
    char foo[] = "Apple";
    char bar[] = "apartment";

    std::cout << std::boolalpha;

    std::cout << "Comparing foo and bar lexicographically (foo < bar):\n";

    std::cout << "Using default comparison (operator<): ";
    std::cout << std::lexicographical_compare(foo, foo + 5, bar, bar + 9);
    std::cout << '\n';

    std::cout << "Using mycomp as comparison object: ";
    std::cout << std::lexicographical_compare(foo, foo + 5, bar, bar + 9, mycomp);
    std::cout << '\n';

    return 0;
}

Démo

Pour mes besoins de comparaison de chaînes insensibles à la casse, je préfère ne pas avoir à utiliser une bibliothèque externe, ni une classe de chaîne distincte avec des traits insensibles à la casse qui est incompatible avec toutes mes autres chaînes.

Donc, ce que j'ai trouvé, c'est ceci:

bool icasecmp(const string& l, const string& r)
{
    return l.size() == r.size()
        && equal(l.cbegin(), l.cend(), r.cbegin(),
            [](string::value_type l1, string::value_type r1)
                { return toupper(l1) == toupper(r1); });
}

bool icasecmp(const wstring& l, const wstring& r)
{
    return l.size() == r.size()
        && equal(l.cbegin(), l.cend(), r.cbegin(),
            [](wstring::value_type l1, wstring::value_type r1)
                { return towupper(l1) == towupper(r1); });
}

Une fonction simple avec une surcharge pour char et une autre pour whar_t. N'utilise rien de non standard, donc ça devrait aller sur n'importe quelle plateforme.

La comparaison d'égalité ne prendra pas en compte les problèmes tels que l'encodage de longueur variable et la normalisation Unicode, mais basic_string n'a aucun support pour cela que je sache de toute façon et ce n'est normalement pas un problème.

Dans les cas où une manipulation lexicographique plus sophistiquée du texte est requise, il vous suffit d'utiliser une bibliothèque tierce comme Boost, ce qui est normal.

Court et agréable. Pas d'autres dépendances, que la bibliothèque std C standard étendue .

strcasecmp(str1.c_str(), str2.c_str()) == 0

renvoie vrai si str1et str2sont égaux. strcasecmppeut ne pas exister, il pourrait y avoir des analogues stricmp, strcmpietc.

Exemple de code:

#include <iostream>
#include <string>
#include <string.h> //For strcasecmp(). Also could be found in <mem.h>

using namespace std;

/// Simple wrapper
inline bool str_ignoreCase_cmp(std::string const& s1, std::string const& s2) {
    if(s1.length() != s2.length())
        return false;  // optimization since std::string holds length in variable.
    return strcasecmp(s1.c_str(), s2.c_str()) == 0;
}

/// Function object - comparator
struct StringCaseInsensetiveCompare {
    bool operator()(std::string const& s1, std::string const& s2) {
        if(s1.length() != s2.length())
            return false;  // optimization since std::string holds length in variable.
        return strcasecmp(s1.c_str(), s2.c_str()) == 0;
    }
    bool operator()(const char *s1, const char * s2){ 
        return strcasecmp(s1,s2)==0;
    }
};


/// Convert bool to string
inline char const* bool2str(bool b){ return b?"true":"false"; }

int main()
{
    cout<< bool2str(strcasecmp("asd","AsD")==0) <<endl;
    cout<< bool2str(strcasecmp(string{"aasd"}.c_str(),string{"AasD"}.c_str())==0) <<endl;
    StringCaseInsensetiveCompare cmp;
    cout<< bool2str(cmp("A","a")) <<endl;
    cout<< bool2str(cmp(string{"Aaaa"},string{"aaaA"})) <<endl;
    cout<< bool2str(str_ignoreCase_cmp(string{"Aaaa"},string{"aaaA"})) <<endl;
    return 0;
}

Production:

true
true
true
true
true

Faire cela sans utiliser Boost peut être fait en obtenant le pointeur de chaîne C avec c_str()et en utilisant strcasecmp:

std::string str1 ="aBcD";
std::string str2 = "AbCd";;
if (strcasecmp(str1.c_str(), str2.c_str()) == 0)
{
    //case insensitive equal 
}

En supposant que vous recherchez une méthode et non une fonction magique qui existe déjà, il n'y a franchement pas de meilleur moyen. Nous pourrions tous écrire des extraits de code avec des astuces intelligentes pour des jeux de caractères limités, mais à la fin de la journée, à un moment donné, vous devez convertir les caractères.

La meilleure approche pour cette conversion est de le faire avant la comparaison. Cela vous permet une grande flexibilité en ce qui concerne les schémas de codage, ce que votre opérateur de comparaison réel devrait ignorer.

Vous pouvez bien sûr «masquer» cette conversion derrière votre propre fonction ou classe de chaîne, mais vous devez toujours convertir les chaînes avant la comparaison.

J'ai écrit une version insensible à la casse de char_traits à utiliser avec std :: basic_string afin de générer une chaîne std :: qui ne respecte pas la casse lors des comparaisons, des recherches, etc. à l'aide des fonctions membres std :: basic_string intégrées.

En d'autres termes, je voulais faire quelque chose comme ça.

std::string a = "Hello, World!";
std::string b = "hello, world!";

assert( a == b );

... que std :: string ne peut pas gérer. Voici l'utilisation de mes nouveaux char_traits:

std::istring a = "Hello, World!";
std::istring b = "hello, world!";

assert( a == b );

... et voici l'implémentation:

/*  ---

        Case-Insensitive char_traits for std::string's

        Use:

            To declare a std::string which preserves case but ignores case in comparisons & search,
            use the following syntax:

                std::basic_string<char, char_traits_nocase<char> > noCaseString;

            A typedef is declared below which simplifies this use for chars:

                typedef std::basic_string<char, char_traits_nocase<char> > istring;

    --- */

    template<class C>
    struct char_traits_nocase : public std::char_traits<C>
    {
        static bool eq( const C& c1, const C& c2 )
        { 
            return ::toupper(c1) == ::toupper(c2); 
        }

        static bool lt( const C& c1, const C& c2 )
        { 
            return ::toupper(c1) < ::toupper(c2);
        }

        static int compare( const C* s1, const C* s2, size_t N )
        {
            return _strnicmp(s1, s2, N);
        }

        static const char* find( const C* s, size_t N, const C& a )
        {
            for( size_t i=0 ; i<N ; ++i )
            {
                if( ::toupper(s[i]) == ::toupper(a) ) 
                    return s+i ;
            }
            return 0 ;
        }

        static bool eq_int_type( const int_type& c1, const int_type& c2 )
        { 
            return ::toupper(c1) == ::toupper(c2) ; 
        }       
    };

    template<>
    struct char_traits_nocase<wchar_t> : public std::char_traits<wchar_t>
    {
        static bool eq( const wchar_t& c1, const wchar_t& c2 )
        { 
            return ::towupper(c1) == ::towupper(c2); 
        }

        static bool lt( const wchar_t& c1, const wchar_t& c2 )
        { 
            return ::towupper(c1) < ::towupper(c2);
        }

        static int compare( const wchar_t* s1, const wchar_t* s2, size_t N )
        {
            return _wcsnicmp(s1, s2, N);
        }

        static const wchar_t* find( const wchar_t* s, size_t N, const wchar_t& a )
        {
            for( size_t i=0 ; i<N ; ++i )
            {
                if( ::towupper(s[i]) == ::towupper(a) ) 
                    return s+i ;
            }
            return 0 ;
        }

        static bool eq_int_type( const int_type& c1, const int_type& c2 )
        { 
            return ::towupper(c1) == ::towupper(c2) ; 
        }       
    };

    typedef std::basic_string<char, char_traits_nocase<char> > istring;
    typedef std::basic_string<wchar_t, char_traits_nocase<wchar_t> > iwstring;

J'ai une bonne expérience de l'utilisation du bibliothèques International Components for Unicode - elles sont extrêmement puissantes et fournissent des méthodes pour la conversion, la prise en charge des paramètres régionaux, le rendu de la date et de l'heure, le mappage de casse (que vous ne semblez pas vouloir) et le classement , qui inclut la comparaison insensible à la casse et à l'accent (et plus). Je n'ai utilisé que la version C ++ des bibliothèques, mais elles semblent également avoir une version Java.

Il existe des méthodes pour effectuer des comparaisons normalisées auxquelles fait référence @Coincoin, et peuvent même prendre en compte les paramètres régionaux - par exemple (et ceci est un exemple de tri, pas strictement égal), traditionnellement en espagnol (en Espagne), la combinaison de lettres "ll" trie entre "l" et "m", donc "lz" <"ll" <"ma".

Utilisez-le simplement strcmp()pour la comparaison sensible à la casse et / strcmpi()ou stricmp()pour la casse. Qui sont tous les deux dans le fichier d'en-tête<string.h>

format:

int strcmp(const char*,const char*);    //for case sensitive
int strcmpi(const char*,const char*);   //for case insensitive

Usage:

string a="apple",b="ApPlE",c="ball";
if(strcmpi(a.c_str(),b.c_str())==0)      //(if it is a match it will return 0)
    cout<<a<<" and "<<b<<" are the same"<<"\n";
if(strcmpi(a.c_str(),b.c_str()<0)
    cout<<a[0]<<" comes before ball "<<b[0]<<", so "<<a<<" comes before "<<b;

Production

apple et ApPlE sont les mêmes

a vient avant b, donc la pomme vient avant la balle

Tard dans la soirée, mais voici une variante qui utilise std::locale, et gère donc correctement le turc:

auto tolower = std::bind1st(
    std::mem_fun(
        &std::ctype<char>::tolower),
    &std::use_facet<std::ctype<char> >(
        std::locale()));

vous donne un foncteur qui utilise les paramètres régionaux actifs pour convertir les caractères en minuscules, que vous pouvez ensuite utiliser via std::transformpour générer des chaînes en minuscules:

std::string left = "fOo";
transform(left.begin(), left.end(), left.begin(), tolower);

Cela fonctionne également pour les wchar_tchaînes basées.

Juste une note sur la méthode que vous choisissez finalement, si cette méthode inclut l'utilisation de strcmp cela, certaines réponses suggèrent:

strcmpne fonctionne pas avec les données Unicode en général. En général, cela ne fonctionne même pas avec les encodages Unicode basés sur les octets, tels que utf-8, car strcmpseules les comparaisons octet par octet et les points de code Unicode encodés dans utf-8 peuvent prendre plus d'un octet. Le seul cas Unicode spécifique strcmpà gérer correctement est lorsqu'une chaîne codée avec un codage basé sur octets ne contient que des points de code inférieurs à U + 00FF - alors la comparaison octet par octet est suffisante.

Début 2013, le projet ICU, maintenu par IBM, est une assez bonne réponse à cela.

http://site.icu-project.org/

ICU est une «bibliothèque Unicode complète et portable qui suit de près les normes de l'industrie». Pour le problème spécifique de la comparaison de chaînes, l'objet Collation fait ce que vous voulez.

Le projet Mozilla a adopté ICU pour l'internationalisation dans Firefox à la mi-2012; vous pouvez suivre la discussion d'ingénierie, y compris les problèmes de génération de systèmes et de taille de fichier de données, ici:

• https://groups.google.com/forum/#!topic/mozilla.dev.platform/sVVpS2sKODw
• https://bugzilla.mozilla.org/show_bug.cgi?id=724529 (tracker)
• https://bugzilla.mozilla.org/show_bug.cgi?id=724531 (système de build)

Il semble que les solutions ci-dessus n'utilisent pas la méthode de comparaison et n'implémentent à nouveau le total, alors voici ma solution et j'espère que cela fonctionne pour vous (cela fonctionne bien).

#include<iostream>
#include<cstring>
#include<cmath>
using namespace std;
string tolow(string a)
{
    for(unsigned int i=0;i<a.length();i++)
    {
        a[i]=tolower(a[i]);
    }
    return a;
}
int main()
{
    string str1,str2;
    cin>>str1>>str2;
    int temp=tolow(str1).compare(tolow(str2));
    if(temp>0)
        cout<<1;
    else if(temp==0)
        cout<<0;
    else
        cout<<-1;
}

Si vous ne voulez pas utiliser la bibliothèque Boost, voici la solution en utilisant uniquement l'en-tête io standard C ++.

#include <iostream>

struct iequal
{
    bool operator()(int c1, int c2) const
    {
        // case insensitive comparison of two characters.
        return std::toupper(c1) == std::toupper(c2);
    }
};

bool iequals(const std::string& str1, const std::string& str2)
{
    // use std::equal() to compare range of characters using the functor above.
    return std::equal(str1.begin(), str1.end(), str2.begin(), iequal());
}

int main(void)
{
    std::string str_1 = "HELLO";
    std::string str_2 = "hello";

    if(iequals(str_1,str_2))
    {
        std::cout<<"String are equal"<<std::endl;   
    }

    else
    {
        std::cout<<"String are not equal"<<std::endl;
    }


    return 0;
}

Si vous devez comparer une chaîne source plus souvent avec d'autres chaînes, une solution élégante consiste à utiliser l'expression régulière.

std::wstring first = L"Test";
std::wstring second = L"TEST";

std::wregex pattern(first, std::wregex::icase);
bool isEqual = std::regex_match(second, pattern);

Un moyen simple de comparer deux chaînes en c ++ (testé pour Windows) utilise _stricmp

// Case insensitive (could use equivalent _stricmp)  
result = _stricmp( string1, string2 );  

Si vous cherchez à utiliser avec std :: string, un exemple:

std::string s1 = string("Hello");
if ( _stricmp(s1.c_str(), "HELLO") == 0)
   std::cout << "The string are equals.";

Pour plus d'informations ici: https://msdn.microsoft.com/it-it/library/e0z9k731.aspx

bool insensitive_c_compare(char A, char B){
  static char mid_c = ('Z' + 'a') / 2 + 'Z';
  static char up2lo = 'A' - 'a'; /// the offset between upper and lowers

  if ('a' >= A and A >= 'z' or 'A' >= A and 'Z' >= A)
      if ('a' >= B and B >= 'z' or 'A' >= B and 'Z' >= B)
      /// check that the character is infact a letter
      /// (trying to turn a 3 into an E would not be pretty!)
      {
        if (A > mid_c and B > mid_c or A < mid_c and B < mid_c)
        {
          return A == B;
        }
        else
        {
          if (A > mid_c)
            A = A - 'a' + 'A'; 
          if (B > mid_c)/// convert all uppercase letters to a lowercase ones
            B = B - 'a' + 'A';
          /// this could be changed to B = B + up2lo;
          return A == B;
        }
      }
}

cela pourrait probablement être rendu beaucoup plus efficace, mais voici une version volumineuse avec tous ses bits à nu.

pas tout à fait portable, mais fonctionne bien avec tout ce qui est sur mon ordinateur (aucune idée, je suis des images pas des mots)

Un moyen simple de comparer des chaînes qui ne diffèrent que par des minuscules et des majuscules consiste à effectuer une comparaison ascii. Toutes les lettres majuscules et minuscules diffèrent de 32 bits dans le tableau ascii, en utilisant ces informations, nous avons ce qui suit ...

    for( int i = 0; i < string2.length(); i++)
    {
       if (string1[i] == string2[i] || int(string1[i]) == int(string2[j])+32 ||int(string1[i]) == int(string2[i])-32) 
    {
      count++;
      continue;
    }
    else 
    {
      break;
    }
    if(count == string2.length())
    {
      //then we have a match
    }
}