การเปรียบเทียบสตริงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ใน 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ในความเป็นจริง typedef สำหรับหรือมากกว่าอย่างชัดเจนstd::basic_string<char> ประเภทอธิบายวิธีอักขระเปรียบเทียบวิธีที่พวกเขาคัดลอกวิธีที่พวกเขาโยน ฯลฯ ทั้งหมดที่คุณต้องทำคือการ typedef สตริงใหม่กว่าและให้กับคุณเองว่าเปรียบเทียบกรณี insensitivelystd::basic_string<char, std::char_traits<char> >char_traitsbasic_stringchar_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 หมายถึงการเปรียบเทียบทั้งหมดของคุณนั้นไม่ตรงตามตัวพิมพ์ใหญ่ - เล็กซึ่งไม่ใช่สิ่งที่คุณต้องการ

สิ่งนี้น่าจะพอเพียง มันควรจะมีประสิทธิภาพพอสมควร ไม่ได้จัดการยูนิโค้ดหรืออะไรก็ตาม

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

ถ้าคุณอยู่ในระบบ POSIX คุณสามารถใช้strcasecmp ฟังก์ชันนี้ไม่ได้เป็นส่วนหนึ่งของมาตรฐาน C แม้ว่าจะไม่มีอยู่ใน Windows สิ่งนี้จะทำการเปรียบเทียบแบบตัวพิมพ์เล็กและตัวพิมพ์ใหญ่บนตัวอักษรแบบ 8 บิตตราบใดที่โลแคลเป็น POSIX หากโลแคลไม่ใช่ POSIX ผลลัพธ์จะไม่ถูกกำหนด (ดังนั้นจึงอาจทำการเปรียบเทียบแบบโลคัลไลซ์หรืออาจไม่ได้) ไม่สามารถใช้อักขระตัวกว้างได้

ความล้มเหลวนั้นการใช้งานไลบรารี C ในอดีตจำนวนมากมีฟังก์ชัน stricmp () และ strnicmp () Visual C ++ บน Windows เปลี่ยนชื่อสิ่งเหล่านี้โดยนำหน้าด้วยเครื่องหมายขีดล่างเพราะพวกเขาไม่ได้เป็นส่วนหนึ่งของมาตรฐาน ANSI ดังนั้นในระบบที่เรียกว่า_stricmp หรือ _strnicmp_strnicmp ห้องสมุดบางแห่งอาจมีฟังก์ชั่นเทียบเท่าตัวอักษรกว้างหรือหลายไบต์ (โดยทั่วไปจะมีชื่อเช่น wcsicmp, mbcsicmp และอื่น ๆ )

C และ C ++ นั้นต่างก็ไม่รู้ปัญหาสากลมากนักดังนั้นจึงไม่มีทางออกที่ดีสำหรับปัญหานี้ยกเว้นการใช้ห้องสมุดบุคคลที่สาม ตรวจสอบIBM ICU (International Components for 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 Normalizationควรเป็นข้อบังคับโดยเฉพาะอย่างยิ่งถ้าคุณวางแผนที่จะสนับสนุนภาษาอังกูล, Thaïและภาษาเอเชียอื่น ๆ

นอกจากนี้ IBM อัลกอริทึม Unicode ที่ได้รับการปรับปรุงให้ดีที่สุดยังเป็นสิทธิบัตรและทำให้พวกเขาเปิดเผยต่อสาธารณะ พวกเขายังคงดำเนินการ: IBM ICU

boost :: iequals ไม่รองรับ utf-8 ในกรณีของ string คุณสามารถใช้เพิ่ม :: สถานที่เกิดเหตุ

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

• หลัก - ละเว้นการเน้นเสียงและตัวอักษรพิมพ์เปรียบเทียบตัวอักษรฐานเท่านั้น ตัวอย่างเช่น "facade" และ "Façade" เหมือนกัน
• มัธยมศึกษา - ละเว้นกรณีตัวอักษร แต่ให้คำนึงถึงสำเนียง "facade" และ "façade" นั้นแตกต่างกัน แต่ "Façade" และ "façade" นั้นเหมือนกัน
• ตติยภูมิ - พิจารณาทั้งกรณีและสำเนียง: "Façade" และ "façade" นั้นแตกต่างกัน ละเว้นเครื่องหมายวรรคตอน
• Quaternary - พิจารณาตัวพิมพ์เล็กและตัวใหญ่ทั้งหมด คำจะต้องเหมือนกันในแง่ของการเป็นตัวแทน Unicode
• เหมือนกัน - เหมือน quaternary แต่เปรียบเทียบจุดโค้ดด้วย

ความคิดแรกของฉันสำหรับรุ่นที่ไม่ใช่ 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 ++ ที่สนับสนุนยูนิโค้ด: http://msdn.microsoft.com/en-us/library/cc194799.aspx

สิ่งที่คุณกำลังมองหาคือ _wcsnicmp

ฉันพยายามที่จะ cobble คำตอบที่ดีจากทุกโพสต์ดังนั้นช่วยฉันแก้ไข:

นี่คือวิธีการทำเช่นนี้แม้ว่ามันจะแปลงสตริงและไม่เป็นมิตรกับ 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 (International Components for Unicode)

นอกจากนี้ยังเพิ่ม :: 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ห้องสมุดมีจำนวนมากของอัลกอริทึมสำหรับการทำเปรียบเทียบกรณี insenstive และอื่น ๆ

คุณสามารถใช้งานของคุณเอง แต่ทำไมต้องกังวลเมื่อมันถูกทำไปแล้ว?

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

ฟังก์ชั่นที่เรียบง่ายพร้อมโอเวอร์โหลดหนึ่งตัวสำหรับถ่านและอีกฟังก์ชั่นสำหรับ whar_t ไม่ใช้สิ่งที่ไม่ได้มาตรฐานดังนั้นควรปรับใช้กับแพลตฟอร์มใด ๆ

การเปรียบเทียบความเท่าเทียมกันจะไม่พิจารณาปัญหาต่างๆเช่นการเข้ารหัสความยาวผันแปรและการทำให้เป็นมาตรฐาน Unicode แต่ basic_string ไม่สนับสนุนสิ่งที่ฉันรู้อยู่แล้วและปกติแล้วมันก็ไม่เป็นปัญหา

ในกรณีที่จำเป็นต้องใช้การจัดการข้อความพจนานุกรมที่ซับซ้อนยิ่งขึ้นคุณต้องใช้ไลบรารี่ของบุคคลที่สามอย่างบูสต์ซึ่งเป็นสิ่งที่คาดหวัง

สั้นและดี ไม่มีการพึ่งพาอื่นใดนอกจากการขยาย std C lib

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

ผลตอบแทนจริงถ้าstr1และstr2เท่ากับ strcasecmpไม่อาจมีอยู่อาจจะมี analogs 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 :: 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;

ฉันมีประสบการณ์ที่ดีในการใช้งานคอมโพเนนต์ระหว่างประเทศสำหรับไลบรารี Unicode - พวกเขามีประสิทธิภาพอย่างยิ่งและให้วิธีการสำหรับการแปลง, การสนับสนุนสถานที่, การแสดงวันที่และเวลา, การแมปเคส (ซึ่งคุณไม่ต้องการ) และการเปรียบเทียบ , ซึ่งรวมถึงการเปรียบเทียบตัวพิมพ์เล็กและตัวพิมพ์ใหญ่และเล็ก (และอื่น ๆ ) ฉันใช้ไลบรารีรุ่น C ++ เท่านั้น แต่ดูเหมือนว่าจะมีเวอร์ชัน Java เช่นกัน

วิธีการมีอยู่เพื่อทำการเปรียบเทียบแบบปกติตามที่อ้างอิงโดย @Coincoin และยังสามารถอธิบายถึงสถานที่ - ตัวอย่างเช่น (และนี่เป็นตัวอย่างการเรียงลำดับไม่เท่าเทียมกันอย่างเคร่งครัด) ตามธรรมเนียมในภาษาสเปน (ในสเปน) การรวมตัวอักษร "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 เหมือนกัน

มาก่อน b ดังนั้นแอปเปิ้ลมาก่อนบอล

ไปงานปาร์ตี้สาย แต่ที่นี่เป็นรุ่นที่ใช้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สตริงตาม

เพียงทราบว่าวิธีการใดที่คุณเลือกในที่สุดหากวิธีการที่เกิดขึ้นรวมถึงการใช้ strcmpคำตอบที่แนะนำ:

strcmpไม่ทำงานกับข้อมูล Unicode โดยทั่วไป โดยทั่วไปแล้วมันไม่ได้ทำงานกับการเข้ารหัส Unicode ที่เป็นไบต์เช่น utf-8 เนื่องจากstrcmpทำการเปรียบเทียบไบต์ต่อไบต์เท่านั้นและการเข้ารหัส Unicode ใน utf-8 อาจใช้เวลามากกว่า 1 ไบต์ กรณี Unicode ที่เจาะจงเฉพาะstrcmpจัดการอย่างถูกต้องคือเมื่อสตริงที่เข้ารหัสด้วยการเข้ารหัสแบบไบต์ประกอบด้วยจุดรหัสเฉพาะด้านล่าง U + 00FF - ดังนั้นการเปรียบเทียบไบต์ต่อไบต์ก็เพียงพอแล้ว

เมื่อต้นปี 2556 โครงการ ICU ที่ IBM ดูแลไว้เป็นคำตอบที่ดีในเรื่องนี้

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

ICU เป็น "ไลบรารี Unicode แบบพกพาที่สมบูรณ์และสามารถติดตามมาตรฐานอุตสาหกรรมได้อย่างใกล้ชิด" สำหรับปัญหาเฉพาะของการเปรียบเทียบสตริงวัตถุการเรียงจะทำสิ่งที่คุณต้องการ

โครงการ 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;
}

หากคุณต้องเปรียบเทียบสตริงซอร์สบ่อยขึ้นกับสตริงอื่น ๆ โซลูชันที่สวยงามวิธีหนึ่งคือใช้ regex

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