Порівняння рядкових рядків у регістрі C ​​++ [закрито]

Який найкращий спосіб порівняння рядків, нечутливих до регістру, у C ++, не перетворюючи рядок у всі великі регістри чи всі маленькі регістри?

Будь ласка, вкажіть, чи методи підходять Unicode і наскільки вони портативні.

Boost включає зручний алгоритм для цього:

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

Скористайтеся стандартом char_traits. Нагадаємо , що std::stringце насправді ЬурейеЕ для std::basic_string<char>або більш явно, std::basic_string<char, std::char_traits<char> >. char_traitsТип описує , як символи порівняти, як вони копіюють, як вони кидають і т.д. Все , що потрібно зробити , це ЬурейеЕ новий рядок над basic_string, і надати його своїм звичаєм , char_traitsщо порівняти випадок невідчутно.

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;

Деталі - у Гуру тижня №29 .

Проблема з прискоренням полягає в тому, що вам потрібно зв’язатись і залежати від прискорення. Нелегко в деяких випадках (наприклад, Android).

А використання char_traits означає, що всі ваші порівняння не залежать від регістру, що зазвичай не є тим, що ви хочете.

Цього повинно вистачити. Це повинно бути досить ефективно. Не обробляє unicode або все-таки нічого.

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

Оновлення: 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);
                      });
}

Якщо у вас є система POSIX, ви можете використовувати strcasecmp . Ця функція не є частиною стандартного C, але вона також не доступна в Windows. Це здійснить порівняння з урахуванням регістру на 8-бітових символах, якщо локал є POSIX. Якщо локал не є POSIX, результати не визначені (тому це може зробити локалізоване порівняння, а може і не). Еквівалент широкого характеру недоступний.

Якщо цього не відбувається, велика кількість реалізацій історичної бібліотеки С має функції stricmp () та strnicmp (). Visual C ++ у Windows перейменував усе це, поставивши їх підкресленням, оскільки вони не входять до стандарту ANSI, тому в цій системі їх називають _stricmp або _strnicmp . Деякі бібліотеки також можуть мати еквівалентні функції з широкими символами або багатобайтовими (зазвичай їх називають, наприклад, wcsicmp, mbcsicmp тощо).

І C, і C ++ в значній мірі не знають проблем інтернаціоналізації, тому немає хорошого рішення цієї проблеми, окрім використання сторонньої бібліотеки. Перевірте IBM ICU (Міжнародні компоненти для Unicode), якщо вам потрібна надійна бібліотека для C / C ++. ICU призначений як для систем Windows, так і для Unix.

Ви говорите про німецьке порівняння з нечутливим випадком або про повне нормоване порівняння Unicode?

Німе порівняння не знайде рядки, які можуть бути однаковими, але не є двійковими рівними.

Приклад:

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

Всі вони рівнозначні, але вони також мають різні бінарні уявлення.

Однак, нормалізація Unicode повинна бути обов'язковою для читання, особливо якщо ви плануєте підтримувати Хангул, Таї та інші азіатські мови.

Крім того, IBM в значній мірі запатентував найбільш оптимізовані алгоритми Unicode та зробив їх загальнодоступними. Вони також підтримують реалізацію: IBM ICU

boost :: iequals не є сумісним utf-8 у разі рядка. Ви можете використовувати boost :: locale .

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

• Основне - ігноруйте наголоси та регістри символів, порівнюючи лише основні літери. Наприклад, "фасад" і "Фасад" однакові.
• Вторинне - ігноруйте випадок символів, але врахуйте акценти. "фасад" і "фасад" різні, але "Фасад" і "Фасад" однакові.
• Третинний - розгляньте і регістр, і наголоси: "Фасад" і "Фасад" різні. Ігноруйте розділові знаки.
• Четвертинний - враховуйте всі регістри, наголоси та розділові знаки. Слова повинні бути ідентичними з точки зору представлення Unicode.
• Ідентичний - як четвертинний, але порівняйте і кодові точки.

Першою моєю думкою для версії, що не містить коду, було зробити щось подібне:

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

Ви можете використовувати strcasecmpв Unix або stricmpв Windows.

Одне, що до цього часу не згадувалося, це те, що якщо ви використовуєте рядки stl з цими методами, корисно спочатку порівняти довжину двох рядків, оскільки ця інформація вже доступна вам у класі рядків. Це може запобігти порівнянню дорогого рядка, якщо два рядки, які ви порівнюєте, не мають однакової довжини в першу чергу.

Функції Visual C ++ string, що підтримують unicode: http://msdn.microsoft.com/en-us/library/cc194799.aspx

той, якого ви, мабуть, шукаєте _wcsnicmp

Я намагаюсь обмотати разом гарну відповідь з усіх публікацій, тому допоможіть мені відредагувати це:

Ось метод цього робити, хоча він перетворює рядки і не є Unicode-дружньою, він повинен бути портативним, що є плюсом:

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

З того, що я прочитав, це більш портативно, ніж stricmp (), оскільки stricmp () насправді не є частиною бібліотеки std, а лише реалізовано більшістю постачальників компіляторів.

Щоб отримати справді зручну реалізацію Unicode, вам потрібно вийти за межі бібліотеки std. Одна хороша сторона-бібліотека - це IBM ICU (Міжнародні компоненти для Unicode)

Також boost :: iequals забезпечує досить хорошу корисність для проведення такого роду порівняння.

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

Ви можете використовувати вищевказаний код на C ++ 14, якщо ви не можете використовувати прискорення. Ви повинні використовувати std::towlowerдля широких символів.

Бібліотека Boost.String має безліч алгоритмів для порівняння, що не враховує регістри, тощо.

Ви можете реалізувати своє, але навіщо турбуватися, коли це вже зроблено?

FYI, strcmp()і stricmp()вони вразливі до переповнення буфера, оскільки вони просто обробляють, поки не потрапляють на нульовий термінатор. Безпечніше використовувати _strncmp()і _strnicmp().

Дивіться 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;
}

Демо

Для мого базового випадку порівняння рядків нечутливих рядків я вважаю за краще не використовувати зовнішню бібліотеку, а також не хочу окремого класу рядків із нечутливими до регістру рисами, несумісними з усіма іншими моїми рядками.

Тому я придумав це:

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

Проста функція з однією перевантаженням для char та іншою для whar_t. Не використовує нічого нестандартного, тому має бути добре на будь-якій платформі.

Порівняння рівності не враховуватиме такі проблеми, як кодування змінної довжини та нормалізація Unicode, але basic_string не підтримує це, про що я все одно знаю, і це, як правило, не проблема.

У випадках, коли потрібні більш складні лексикографічні маніпуляції з текстом, тоді вам просто доведеться використовувати сторонню бібліотеку типу Boost, чого можна очікувати.

Короткий і приємний. Ніяких інших залежностей, ніж розширений std C lib.

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

повертає істину, якщо str1і str2рівні. strcasecmpможе не існувати, не може бути аналогами stricmp, strcmpiі т.д.

Приклад коду:

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

Вихід:

true
true
true
true
true

Зробити це без використання Boost можна, отримавши вказівник C рядка c_str() та використовуючи strcasecmp:

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

Якщо припустити, що ви шукаєте метод, а не магічну функцію, яка вже існує, немає кращого способу. Ми всі могли написати фрагменти коду з розумними хитрощами для обмежених наборів символів, але наприкінці дня в якийсь момент вам доведеться конвертувати символи.

Найкращий підхід для цього перетворення - це зробити перед порівнянням. Це дозволяє вам досягти великої гнучкості, коли мова йде про схеми кодування, про які ваш фактичний оператор порівняння повинен не знати.

Ви, звичайно, можете "приховати" це перетворення за власною функцією рядка або класом, але вам потрібно все-таки конвертувати рядки перед порівнянням.

Я написав нечутливу до регістру версію char_traits для використання з std :: basic_string для того, щоб генерувати std :: рядок, який не відрізняється від регістру при порівнянні, пошуку тощо, використовуючи вбудовані функції std :: basic_string член.

Отже іншими словами, я хотів зробити щось подібне.

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

assert( a == b );

... який std :: string не може обробити. Ось використання моїх нових char_traits:

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

assert( a == b );

... і ось реалізація:

/*  ---

        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;

Я мав хороший досвід використання міжнародних компонентів для бібліотек Unicode - вони надзвичайно потужні та забезпечують методи перетворення, підтримку локалів, візуалізацію дати та часу, відображення справ (які ви, схоже, не хочете) та порівняння , що включає порівняння з великим регістром та акцентом (та багато іншого). Я використовував тільки версії C ++ бібліотек, але, здається, вони також мають версію Java.

Існують методи для виконання нормованих порівнянь, на які посилається @Coincoin, і навіть можуть враховувати локаль - наприклад (і це сортувальний приклад, не суворо рівність), традиційно в іспанській (в Іспанії), буквене поєднання "ll" порівнює між "l" і "m", так "lz" <"ll" <"ma".

Просто використовуйте strcmp()для випадку чутливі і strcmpi()чи stricmp()для випадку нечутливого порівняння. Які є у файлі заголовка<string.h>

формат:

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

Використання:

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;

Вихідні дані

apple і ApPlE - те саме

a приходить перед b, тому яблуко приходить перед м'ячем

Пізно до вечірки, але ось варіант, який використовує std::localeі, таким чином, правильно обробляє турецьку мову:

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

дає вам функціонал, який використовує активну локаль для перетворення символів у малі регістри, за допомогою яких ви можете використовувати std::transformдля створення малих рядків:

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

Це також працює для wchar_tзаснованих рядків.

Лише зауваження щодо того, який метод ви нарешті обрали, якщо цей метод передбачає використання strcmpцього відповіді:

strcmpвзагалі не працює з даними Unicode. Взагалі, він навіть не працює з кодуваннями Unicode на байті, такими як utf-8, оскільки strcmpтільки порівняння байтів за байтом, а точки коду Unicode, закодовані у utf-8, можуть займати більше 1 байта. Єдиний конкретний випадок Unicode, який strcmpналежним чином обробляється, це коли рядок, кодований байтом на основі байтування, містить лише кодові точки нижче U + 00FF - тоді порівняння байтів на байт достатньо.

На початок 2013 року проект ICU, підтримуваний IBM, є досить хорошою відповіддю на це.

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

ICU - це "повна, портативна бібліотека Unicode, яка ретельно відстежує галузеві стандарти". Для конкретної проблеми порівняння рядків об’єкт Collation робить те, що вам потрібно.

Проект Mozilla прийняв ICU для інтернаціоналізації у Firefox в середині 2012 року; ви можете відстежувати інженерну дискусію, включаючи проблеми системи збирання та розмір файлу даних, тут:

• https://groups.google.com/forum/#!topic/mozilla.dev.platform/sVVpS2sKODw
• https://bugzilla.mozilla.org/show_bug.cgi?id=724529 (трекер)
• https://bugzilla.mozilla.org/show_bug.cgi?id=724531 (система побудови)

Схоже, що вищевикладені рішення не використовують метод порівняння та повторне впровадження загальної кількості, тому ось моє рішення і сподіваюся, що воно працює для вас (Це працює чудово).

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

Якщо ви не хочете використовувати бібліотеку Boost, то тут для цього є рішення, використовуючи лише стандартний заголовок io + 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;
}

Якщо вам доводиться частіше порівнювати вихідний рядок з іншими рядками, одним елегантним рішенням є використання регулярного вираження.

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

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

Простий спосіб порівняння двох рядків у c ++ (тестований на Windows) - це використання _stricmp

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

Якщо ви хочете використовувати з std :: string, приклад:

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

Для отримання додаткової інформації тут: 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;
        }
      }
}

це, мабуть, можна зробити набагато ефективнішим, але ось об'ємна версія з усіма її бітами голими.

не все, що портативно, але добре працює з тим, що є на моєму комп’ютері (не маю уявлення, я не фотографії, а слова)

Простий спосіб порівняння рядків, які відрізняються лише малими та великими літерами, - це порівняння ascii. Усі великі і малі літери відрізняються на 32 біти в таблиці ascii, використовуючи цю інформацію, ми маємо наступне ...

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