تحسس حالة الأحرف سلسلة المقارنة في C++ [مغلقة]

Question

ما هي أفضل طريقة للقيام حالة الأحرف سلسلة المقارنة في C++ دون تحويل سلسلة إلى أحرف كبيرة أو أحرف صغيرة ؟

يرجى بيان ما إذا كانت أساليب Unicode-ودية وكيف المحمولة هم.

Answer 1

دفعة يشمل مفيد خوارزمية هذا:

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

Answer 2

الاستفادة من المعيار char_traits.يذكر أن std::string هو في الواقع ل typedef std::basic_string<char>, أو أكثر صراحة ، std::basic_string<char, std::char_traits<char> >.على char_traits نوع يصف كيف الشخصيات قارن اسعار, كيفية نسخ, كيف يلقي الخ.كل ما عليك القيام به هو typedef سلسلة جديدة على basic_string, و تقديم المخصصة الخاصة بك char_traits أن تقارن حال insensitively.

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.

Answer 3

مشكلة مع دفعة هو أن يكون لديك لربط مع وتعتمد على دفعة.ليس من السهل في بعض الحالات (مثلا ، الروبوت).

واستخدام char_traits يعني كل مقارنات الخاص بك حساسة لحالة الأحرف التي ليست عادة ما تريد.

هذا ينبغي أن يكون كافيا.ينبغي أن يكون معقول من الكفاءة.لا التعامل مع يونيكود أو أي شيء على الرغم من.

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

تحديث:مكافأة 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);
                      });
}

Answer 4

إذا كنت على POSIX ، strcasecmp.هذه الوظيفة ليست جزءا من معيار C, رغم أن, كما أنها متوفرة على ويندوز.هذا سوف تؤدي قضية حساسة المقارنة على 8 بت حرف ، طالما أن لغة POSIX.إذا كانت لغة ليست POSIX ، وكانت النتائج غير معروف (لذلك قد فعل مترجم قارن اسعار, أو ربما لا).مجموعة حرف ما يعادل غير متوفر.

إذا تعذر ذلك, عدد كبير من التاريخي ج مكتبة تطبيقات لديهم وظائف stricmp() و strnicmp().Visual C++ على نظام التشغيل Windows تسمية جميع هذه قبل التقديم لهم مع تسطير لأنها ليست جزءا من ANSI القياسية ، لذلك على أن النظام يطلق عليهم _stricmp أو _strnicmp.بعض المكتبات قد يكون لها أيضا واسعة حرف أو multibyte ما يعادل وظائف (عادة اسمه مثلاwcsicmp, mbcsicmp وهلم جرا).

C و C++ إلى حد كبير جاهل تدويل القضايا ، لذلك لا يوجد حل لهذه المشكلة إلا أن استخدام طرف ثالث المكتبة.تحقق من IBM العناية المركزة (الدولية مكونات Unicode) إذا كنت بحاجة قوية مكتبة C/C++.العناية المركزة هي لكل من ويندوز وأنظمة يونكس.

Answer 5

تتحدث غبي قضية حساسة مقارنة أو التطبيع الكامل يونيكود تقارن ؟

غبي مقارنة لن تجد السلاسل التي قد تكون هي نفسها ولكن ليست الثنائية المتساوية.

على سبيل المثال:

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

كل ما يعادلها ولكن لديهم أيضا مختلفة ثنائي التمثيل.

قال ذلك ، Unicode التطبيع ينبغي أن يكون إلزاميا قراءة خاصة إذا كنت تخطط على دعم اللغة الكورية, التايلاندية وغيرها من اللغات الآسيوية.

أيضا, IBM حد كبير على براءة اختراع الأكثر الأمثل Unicode خوارزميات وجعلها متاحة للجمهور.كما أنها تحافظ على التنفيذ : IBM العناية المركزة

Answer 6

دفعة::iequals لا utf-8 متوافق في حالة من السلسلة.يمكنك استخدام دفعة::لغة.

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

• الابتدائية-تجاهل لمسات شخصية الحالة ، مقارنة قاعدة حروف فقط.على سبيل المثال "الواجهة" و "الواجهة" هي نفسها.
• الثانوية -- تجاهل الطابع الحالة ولكن النظر في لهجات."واجهة" و "الواجهة" مختلفة ولكن "الواجهة" و "الواجهة" هي نفسها.
• التعليم العالي-النظر في كل حالة و لهجات:"الواجهة" و "الواجهة" مختلفة.تجاهل علامات الترقيم.
• الرباعية-النظر في كل حالة, لهجات, و علامات الترقيم.الكلمات يجب أن تكون متطابقة من حيث تمثيل Unicode.
• متطابقة-كما الرباعية ، ولكن مقارنة رمز نقطة أيضا.

Answer 7

فكرتي الأولى غير إصدار 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;
}

Answer 8

يمكنك استخدام strcasecmp على يونكس ، أو stricmp على نظام التشغيل ويندوز.

الشيء الوحيد الذي لم يتم ذكره حتى الآن هو أنه إذا كنت تستخدم الخاصة بلبنان السلاسل مع هذه الأساليب ، من المفيد الأولى مقارنة طول سلسلتين ، حيث أن هذه المعلومات متاحة بالفعل في سلسلة الدرجة.هذا يمكن منع القيام مكلفة مقارنة سلسلة إذا السلسلتين تقارنها حتى لا طول نفس في المقام الأول.

Answer 9

Visual C++ وظائف سلسلة دعم يونيكود: http://msdn.microsoft.com/en-us/library/cc194799.aspx

واحد ربما كنت تبحث عنه هو _wcsnicmp

Answer 10

أنا أحاول أن حشده إجابة جيدة من جميع الوظائف ، لذا مساعدتي في تحرير هذا:

هنا هو طريقة للقيام بذلك, على الرغم من أنه لا تحويل سلاسل, وليس 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() ليست في الواقع جزء من الأمراض المنقولة جنسيا المكتبة, ولكن فقط نفذت من قبل معظم مترجم البائعين.

للحصول على حقا Unicode ودية تنفيذ يبدو أنك يجب أن تذهب خارج std المكتبة.واحدة جيدة مكتبة 3rd الطرف هو IBM العناية المركزة (الدولية مكونات Unicode)

أيضا دفعة::iequals يوفر جيدة إلى حد ما فائدة هذا النوع من المقارنة.

Answer 11

على دفعة.سلسلة المكتبة لديها الكثير من الخوارزميات القيام القضية-insenstive مقارنات وهلم جرا.

هل يمكن أن تنفذ الخاصة بك, ولكن لماذا عندما تم القيام به ؟

Answer 12

لمعلوماتك ، strcmp() و stricmp() عرضة تجاوز سعة المخزن المؤقت ، لأنها مجرد عملية حتى ضرب null.انها أكثر أمانا للاستخدام _strncmp() و _strnicmp().

Answer 13

بالنسبة لي الأساسية قضية حساسة مقارنة سلسلة الاحتياجات كنت تفضل عدم استخدام خارجي مكتبة, ولا أريد منفصل سلسلة الدرجة مع قضية حساسة الصفات التي تتنافى مع كل السلاسل الأخرى.

إذا ما جئت به هو هذا:

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

وظيفة بسيطة مع أحد الزائد على شار وآخر whar_t.لا تستخدم أي شيء غير القياسية لذا يجب أن تكون الغرامة على أي منصة.

المساواة بين المقارنة لن تنظر في قضايا مثل طول متغير ترميز Unicode التطبيع ، ولكن basic_string لا يوجد لديه دعم هذا أنا على علم بأي حال ليست عادة مشكلة.

في الحالات التي يكون فيها أكثر تطورا المعجمية التلاعب النص المطلوب, ثم يمكنك ببساطة استخدام طرف ثالث مكتبة مثل دفعة ، وهو أمر متوقع.

Answer 14

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

يمكنك استخدام رمز أعلاه في C++14 إذا لم تكن في وضع يمكنها من استخدام دفعة.لديك لاستخدام std::towlower واسعة حرف.

Answer 15

قصيرة وجميلة.أي تبعيات أخرى ، من مدد الأمراض المنقولة جنسيا ج 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

Answer 16

انظر 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;
}

Demo

Answer 17

على افتراض كنت تبحث عن وسيلة وليس السحر وظيفة موجود بالفعل ، هناك بصراحة لا توجد طريقة أفضل.يمكننا كتابة التعليمات البرمجية المتكررة مع الحيل الذكية لمدة محدودة مجموعات الأحرف ، ولكن في نهاية اليوم في somepoint لديك لتحويل الأحرف.

أفضل نهج لهذا التحويل هو أن تفعل ذلك قبل أن المقارنة.هذا يسمح لك قدرا كبيرا من المرونة عندما يتعلق الأمر ترميز المخططات التي الفعلي عامل المقارنة يجب أن تكون جاهلا.

يمكنك بالطبع 'إخفاء' هذا التحويل وراء الخاص بك string الوظيفة أو الدرجة ، ولكن كنت لا تزال بحاجة إلى تحويل السلاسل قبل المقارنة.

Answer 18

كتبت قضية حساسة نسخة من char_traits للاستخدام مع std::basic_string من أجل توليد std::string ليست حساسة لحالة الأحرف عند القيام المقارنات ، البحث ، وما إلى ذلك باستخدام المدمج في 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;

Answer 19

القيام بذلك دون استخدام دفعة يمكن أن يتم ذلك عن طريق الحصول على C سلسلة المؤشر مع c_str() واستخدام strcasecmp:

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

Answer 20

لدي خبرة جيدة باستخدام الدولية مكونات Unicode المكتبات إنهم قوية للغاية ، وتوفير طرق تحويل لغة الدعم, تاريخ ووقت التقديم ، حالة رسم الخرائط (التي يبدو أنك لا تريد) ، ترتيب, الذي يشمل حال - تمييز-حساس المقارنة (وأكثر).لقد استخدم C++ الإصدار من المكتبات, ولكن على ما يبدو أن يكون جافا الإصدار أيضا.

توجد طرق لأداء تطبيع يقارن النحو المشار إليه من قبل @Coincoin ، وحتى يمكن حساب اللغة - على سبيل المثال (و هذا الفرز سبيل المثال ، ليس صارما بين الجنسين) ، تقليديا في الإسبانية (إسبانيا) ، رسالة الجمع "ll" نوع ما بين "أنا" و "م" ، لذلك "lz" < "ليرة لبنانية" < "ما".

Answer 21

مجرد استخدام 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;

الإخراج

أبل وأبل هي نفسها

وهو يأتي قبل ب ، لذلك أبل يأتي قبل الكرة

Answer 22

فقط ملاحظة على أيا كانت الطريقة اخترت أخيرا ، إذا كان هذا الأسلوب يحدث تشمل استخدام strcmp أن بعض الإجابات تشير إلى:

strcmp لا يعمل مع بيانات Unicode بشكل عام.بشكل عام, لا تعمل حتى مع بايت على أساس Unicode ترميزات ، مثل utf-8 ، منذ strcmp يجعل بايت لكل بايت مقارنات رمز Unicode نقطة ترميز utf-8 يمكن أن تأخذ أكثر من 1 بايت.فقط محددة Unicode حالة strcmp التعامل بشكل صحيح عندما سلسلة المشفرة مع بايت القائم على الترميز يحتوي على رمز فقط النقاط أدناه U+00FF - ثم بايت لكل بايت مقارنة بما فيه الكفاية.

Answer 23

اعتبارا من مطلع عام 2013 ، ICU المشروع ، تحتفظ بها IBM, هو جيد جدا الإجابة على هذا.

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

العناية المركزة هي "استكمال المحمولة Unicode مكتبة يتتبع عن كثب معايير الصناعة." بالنسبة لمشكلة محددة من سلسلة مقارنة جمع وجوه يفعل ما تريد.

مشروع موزيلا اعتمد العناية المركزة للتدويل في فايرفوكس في منتصف عام 2012 ، يمكنك تتبع الهندسة المناقشة ، بما في ذلك قضايا بناء نظم البيانات حجم الملف هنا:

• https://groups.google.com/forum/#!الموضوع/موزيلا.dev.منصة/sVVpS2sKODw
• https://bugzilla.mozilla.org/show_bug.cgi?id=724529 (تعقب)
• https://bugzilla.mozilla.org/show_bug.cgi?id=724531 (بناء نظام)

Answer 24

في وقت متأخر إلى الحزب ، ولكن هنا هو البديل الذي يستخدم std::locale, وبالتالي بشكل صحيح يعالج التركية:

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

يعطيك functor يستخدم النشطة لغة إلى تحويل الأحرف إلى أحرف صغيرة التي يمكنك ثم استخدام طريق std::transform لتوليد أقل حدة السلاسل:

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

يعمل هذا أيضا wchar_t على أساس سلاسل.

Answer 25

يبدو الحلول المذكورة أعلاه ليست مقارنة باستخدام الطريقة وتنفيذ إجمالي مرة أخرى حتى هنا هو بلدي الحل و نأمل أن يعمل لك (انها تعمل بشكل جيد).

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

Answer 26

إذا كنت لا تريد استخدام دفعة المكتبة ثم هنا هو حل ذلك فقط باستخدام C++ القياسية io رأس.

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

Answer 27

إذا كان لديك ناقلات سلاسل, على سبيل المثال:

std::sort(std::begin(myvector), std::end(myvector), [](std::string const &a, std::string const &b)
{
    return std::lexicographical_compare(std::begin(a), std::end(a), std::begin(b), std::end(b), [](std::string::value_type a, std::string::value_type b)
    {
        return std::tolower(a) < std::tolower(b); //case-insensitive
    });
});

http://ideone.com/N6sq6X

Answer 28

إذا كان لديك لمقارنة مصدر السلسلة في كثير من الأحيان مع السلاسل الأخرى واحدة أنيقة حل هو استخدام التعابير المنطقية.

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

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

Answer 29

طريقة بسيطة لمقارنة اثنين من السلسلة في 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

Answer 30

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

هذا ربما يكون أكثر كفاءة بكثير ، ولكن هنا هو ضخمة نسخة مع كل بت العارية.

ليس كل ما المحمولة ، ولكن يعمل بشكل جيد مع كل ما هو على جهاز الكمبيوتر (على فكرة أنا من الصور وليس الكلمات)