So sánh chuỗi không phân biệt chữ hoa chữ thường trong C ++ [đã đóng]

Cách tốt nhất để thực hiện so sánh chuỗi không phân biệt chữ hoa chữ thường trong C ++ mà không chuyển đổi một chuỗi thành tất cả chữ hoa hoặc tất cả chữ thường là gì?

Vui lòng cho biết liệu các phương thức có thân thiện với Unicode và mức độ di động của chúng hay không.

Boost bao gồm một thuật toán tiện dụng cho việc này:

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

Tận dụng tiêu chuẩn char_traits. Hãy nhớ lại rằng a std::stringthực tế là một typedef cho std::basic_string<char>, hoặc rõ ràng hơn , std::basic_string<char, std::char_traits<char> >. Cácchar_traits loại mô tả cách nhân vật so sánh, làm thế nào họ sao chép, làm thế nào họ đúc vv Tất cả bạn cần làm là typedef một chuỗi mới hơn basic_string, và cung cấp cho nó với tùy chỉnh của riêng bạn char_traitsmà so sánh trường hợp 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;

Các chi tiết có trong phần của Tuần lễ số 29 .

Rắc rối với boost là bạn phải liên kết và phụ thuộc vào boost. Không dễ dàng trong một số trường hợp (ví dụ Android).

Và sử dụng char_traits có nghĩa là tất cả các so sánh của bạn không phân biệt chữ hoa chữ thường, đây không phải là điều bạn muốn.

Điều này là đủ. Nó nên được hiệu quả hợp lý. Không xử lý unicode hoặc bất cứ điều gì mặc dù.

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ập nhật: Phần thưởng C ++ 14 phiên bản ( #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);
                      });
}

Nếu bạn đang sử dụng hệ thống POSIX, bạn có thể sử dụng strcasecmp . Tuy nhiên, chức năng này không phải là một phần của tiêu chuẩn C, cũng không có sẵn trên Windows. Điều này sẽ thực hiện so sánh không phân biệt chữ hoa chữ thường trên ký tự 8 bit, miễn là miền địa phương là POSIX. Nếu miền địa phương không phải là POSIX, kết quả không được xác định (do đó, nó có thể thực hiện so sánh cục bộ hoặc có thể không). Một tương đương rộng ký tự là không có sẵn.

Không, một số lượng lớn các triển khai thư viện C lịch sử có các hàm stricmp () và strnicmp (). Visual C ++ trên Windows đã đổi tên tất cả những thứ này bằng cách thêm tiền tố vào chúng bằng dấu gạch dưới vì chúng không phải là một phần của tiêu chuẩn ANSI, vì vậy trên hệ thống đó chúng được gọi là _stricmp hoặc _strnicmp . Một số thư viện cũng có thể có các hàm tương đương ký tự rộng hoặc đa nhân (thường được đặt tên là wcsicmp, mbcsicmp, v.v.).

C và C ++ hầu như không biết gì về các vấn đề quốc tế hóa, vì vậy không có giải pháp tốt cho vấn đề này, ngoại trừ việc sử dụng thư viện của bên thứ ba. Hãy xem IBM ICU (Các thành phần quốc tế cho Unicode) nếu bạn cần một thư viện mạnh mẽ cho C / C ++. ICU dành cho cả hệ thống Windows và Unix.

Bạn đang nói về một trường hợp ngu ngốc so sánh không nhạy cảm hoặc so sánh Unicode bình thường hóa hoàn toàn?

Một so sánh ngu ngốc sẽ không tìm thấy các chuỗi có thể giống nhau nhưng không phải là nhị phân bằng nhau.

Thí dụ:

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

Tất cả đều tương đương nhưng chúng cũng có các biểu diễn nhị phân khác nhau.

Điều đó nói rằng, Chuẩn hóa Unicode phải là một cách đọc bắt buộc đặc biệt nếu bạn có kế hoạch hỗ trợ Hangul, Thaï và các ngôn ngữ châu Á khác.

Ngoài ra, IBM đã cấp bằng sáng chế hầu hết các thuật toán Unicode được tối ưu hóa và cung cấp chúng công khai. Họ cũng duy trì triển khai: IBM ICU

boost :: iequals không tương thích utf-8 trong trường hợp chuỗi. Bạn có thể sử dụng boost :: locale .

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

• Chính - bỏ qua dấu và trường hợp ký tự, chỉ so sánh các chữ cái cơ sở. Ví dụ: "mặt tiền" và "Mặt tiền" là như nhau.
• Thứ cấp - bỏ qua trường hợp nhân vật nhưng xem xét các dấu. "Mặt tiền" và "mặt tiền" khác nhau nhưng "Mặt tiền" và "mặt tiền" là như nhau.
• Đệ tam - xem xét cả trường hợp và dấu: "Mặt tiền" và "mặt tiền" là khác nhau. Bỏ qua dấu câu.
• Đệ tứ - xem xét tất cả các trường hợp, dấu và dấu chấm câu. Các từ phải giống hệt nhau về mặt đại diện Unicode.
• Đồng nhất - như là bậc bốn, nhưng so sánh các điểm mã là tốt.

Suy nghĩ đầu tiên của tôi về một phiên bản không unicode là làm một cái gì đó như thế này:

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

Bạn có thể sử dụng strcasecmptrên Unix hoặcstricmp trên Windows.

Một điều chưa được đề cập cho đến nay là nếu bạn đang sử dụng chuỗi stl với các phương thức này, trước tiên, việc so sánh độ dài của hai chuỗi là rất hữu ích, vì thông tin này đã có sẵn cho bạn trong lớp chuỗi. Điều này có thể ngăn việc thực hiện so sánh chuỗi tốn kém nếu hai chuỗi bạn đang so sánh thậm chí không có cùng độ dài ở vị trí đầu tiên.

Các hàm chuỗi Visual C ++ hỗ trợ unicode: http://msdn.microsoft.com/en-us/l Library / cc194799.aspx

người mà bạn có thể đang tìm kiếm là _wcsnicmp

Tôi đang cố gắng đưa ra một câu trả lời hay từ tất cả các bài viết, vì vậy hãy giúp tôi chỉnh sửa điều này:

Đây là một phương pháp để làm điều này, mặc dù nó biến đổi các chuỗi và không thân thiện với Unicode, nhưng nó có thể mang theo được là một ưu điểm:

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

Từ những gì tôi đã đọc, nó dễ mang theo hơn stricmp () vì stricmp () thực tế không phải là một phần của thư viện std, mà chỉ được thực hiện bởi hầu hết các nhà cung cấp trình biên dịch.

Để có được một triển khai thực sự thân thiện với Unicode, có vẻ như bạn phải ra ngoài thư viện tiêu chuẩn. Một thư viện bên thứ 3 tốt là ICU của IBM (Các thành phần quốc tế cho Unicode)

Ngoài ra boost :: iequals cung cấp một tiện ích khá tốt để thực hiện loại so sánh này.

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

Bạn có thể sử dụng đoạn mã trên trong C ++ 14 nếu bạn không ở vị trí để sử dụng boost. Bạn phải sử dụng std::towlowercho ký tự rộng.

Các Boost.String thư viện có rất nhiều thuật toán để thực hiện so sánh trường insenstive và vân vân.

Bạn có thể tự thực hiện, nhưng tại sao phải bận tâm khi nó đã được thực hiện?

FYI, strcmp()và stricmp()dễ bị tràn bộ đệm, vì chúng chỉ xử lý cho đến khi chúng chạm vào một bộ kết thúc null. Nó an toàn hơn để sử dụng _strncmp()và _strnicmp().

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

Bản giới thiệu

Đối với nhu cầu so sánh chuỗi không nhạy cảm trường hợp cơ bản của tôi, tôi không muốn phải sử dụng thư viện bên ngoài, tôi cũng không muốn một lớp chuỗi riêng biệt với các đặc điểm không nhạy cảm trường hợp không tương thích với tất cả các chuỗi khác của tôi.

Vì vậy, những gì tôi đã đưa ra là đây:

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

Một hàm đơn giản với một quá tải cho char và một hàm khác cho whar_t. Không sử dụng bất cứ thứ gì không chuẩn nên sẽ ổn trên mọi nền tảng.

Việc so sánh bằng sẽ không xem xét các vấn đề như mã hóa độ dài thay đổi và chuẩn hóa Unicode, nhưng basic_ chuỗi không hỗ trợ cho điều đó mà tôi biết về dù sao và nó thường không phải là vấn đề.

Trong trường hợp yêu cầu thao tác văn bản từ vựng phức tạp hơn, bạn chỉ cần sử dụng thư viện của bên thứ ba như Boost, điều này sẽ được mong đợi.

Ngắn và đẹp. Không phụ thuộc khác, ngoài mở rộng std C lib.

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

trả về true nếu str1và str2bằng nhau. strcasecmpcó thể không tồn tại, có thể có chất tương tự stricmp, strcmpivv

Mã ví dụ:

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

Đầu ra:

true
true
true
true
true

Làm điều này mà không sử dụng Boost có thể được thực hiện bằng cách lấy con trỏ chuỗi C c_str()và sử dụng strcasecmp:

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

Giả sử bạn đang tìm kiếm một phương pháp và không phải là một chức năng ma thuật đã tồn tại, thực sự không có cách nào tốt hơn. Tất cả chúng ta đều có thể viết các đoạn mã với các thủ thuật thông minh cho các bộ ký tự giới hạn, nhưng vào cuối ngày, vào lúc nào đó, bạn phải chuyển đổi các ký tự.

Cách tiếp cận tốt nhất cho việc chuyển đổi này là làm như vậy trước khi so sánh. Điều này cho phép bạn rất linh hoạt khi nói đến các sơ đồ mã hóa, mà toán tử so sánh thực tế của bạn nên không biết gì.

Tất nhiên bạn có thể 'ẩn' chuyển đổi này đằng sau hàm hoặc lớp chuỗi của riêng bạn, nhưng bạn vẫn cần chuyển đổi các chuỗi trước khi so sánh.

Tôi đã viết một phiên bản char_traits không phân biệt chữ hoa chữ thường để sử dụng với std :: basic_ chuỗi để tạo chuỗi std :: không phân biệt chữ hoa chữ thường khi thực hiện so sánh, tìm kiếm, v.v. bằng cách sử dụng các hàm thành viên std :: basic_ chuỗi tích hợp.

Nói cách khác, tôi muốn làm một cái gì đó như thế này.

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

assert( a == b );

... mà std :: chuỗi không thể xử lý. Đây là cách sử dụng char_traits mới của tôi:

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

assert( a == b );

... và đây là việc thực hiện:

/*  ---

        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;

Tôi đã có kinh nghiệm sử dụng các Thành phần Quốc tế cho các thư viện Unicode - chúng cực kỳ mạnh mẽ và cung cấp các phương thức để chuyển đổi, hỗ trợ ngôn ngữ, kết xuất ngày và giờ, ánh xạ trường hợp (mà bạn dường như không muốn) và đối chiếu , trong đó bao gồm so sánh không phân biệt chữ hoa và chữ thường (và hơn thế nữa). Tôi chỉ sử dụng phiên bản C ++ của các thư viện, nhưng dường như chúng cũng có phiên bản Java.

Các phương thức tồn tại để thực hiện so sánh chuẩn hóa như được đề cập bởi @Coincoin và thậm chí có thể tính đến ngôn ngữ - ví dụ (và đây là một ví dụ sắp xếp, không hoàn toàn bình đẳng), theo truyền thống ở Tây Ban Nha (ở Tây Ban Nha), kết hợp chữ cái "sẽ" sắp xếp giữa "l" và "m", vì vậy "lz" <"ll" <"ma".

Chỉ sử dụng strcmp()cho trường hợp nhạy cảm và strcmpi()hoặc stricmp()cho trường hợp so sánh không nhạy cảm. Cả hai đều nằm trong tệp tiêu đề<string.h>

định dạng:

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

Sử dụng:

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;

Đầu ra

táo và ApPlE giống nhau

a đến trước b, vì vậy táo đến trước bóng

Đến bữa tiệc muộn, nhưng đây là một biến thể sử dụng std::locale, và do đó xử lý chính xác tiếng Thổ Nhĩ Kỳ:

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

cung cấp cho bạn một functor sử dụng ngôn ngữ hoạt động để chuyển đổi các ký tự thành chữ thường, sau đó bạn có thể sử dụng thông qua std::transformđể tạo các chuỗi chữ thường:

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

Điều này cũng hoạt động cho các wchar_tchuỗi dựa.

Chỉ cần một lưu ý về bất kỳ phương pháp nào cuối cùng bạn chọn, nếu phương pháp đó xảy ra bao gồm việc sử dụng strcmp một số câu trả lời gợi ý:

strcmpkhông hoạt động với dữ liệu Unicode nói chung. Nói chung, nó thậm chí không hoạt động với các bảng mã Unicode dựa trên byte, chẳng hạn như utf-8, vì strcmpchỉ thực hiện so sánh byte trên mỗi byte và các điểm mã Unicode được mã hóa trong utf-8 có thể mất hơn 1 byte. Trường hợp Unicode cụ thể duy nhất strcmpxử lý đúng là khi một chuỗi được mã hóa bằng mã hóa dựa trên byte chỉ chứa các điểm mã dưới U + 00FF - thì so sánh byte trên mỗi byte là đủ.

Ngay từ đầu năm 2013, dự án ICU, được IBM duy trì, là một câu trả lời khá hay cho vấn đề này.

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

ICU là một "thư viện Unicode hoàn chỉnh, di động theo dõi chặt chẽ các tiêu chuẩn ngành." Đối với vấn đề cụ thể của so sánh chuỗi, đối tượng Collation thực hiện những gì bạn muốn.

Dự án Mozilla đã thông qua ICU để quốc tế hóa trong Firefox vào giữa năm 2012; bạn có thể theo dõi các cuộc thảo luận kỹ thuật, bao gồm các vấn đề về hệ thống xây dựng và kích thước tệp dữ liệu, tại đây:

• https://groups.google.com/forum/#!topic/mozilla.dev.pl platform / sVVpS2sKODw
• https://ormszilla.mozilla.org/show_orms.cgi?id=724529 (theo dõi)
• https://ormszilla.mozilla.org/show_orms.cgi?id=724531 (xây dựng hệ thống)

Có vẻ như các giải pháp trên không sử dụng phương pháp so sánh và thực hiện lại toàn bộ vì vậy đây là giải pháp của tôi và hy vọng nó có hiệu quả với bạn (Nó hoạt động tốt).

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

Nếu bạn không muốn sử dụng thư viện Boost thì đây là giải pháp cho nó chỉ sử dụng tiêu đề io tiêu chuẩn 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;
}

Nếu bạn phải so sánh một chuỗi nguồn thường xuyên hơn với các chuỗi khác, một giải pháp tao nhã là sử dụng 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);

Một cách đơn giản để so sánh hai chuỗi trong c ++ (đã thử nghiệm cho windows) là sử dụng _stricmp

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

Nếu bạn đang tìm cách sử dụng với std :: string, một ví dụ:

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

Để biết thêm thông tin ở đây: https://msdn.microsoft.com/it-it/l 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;
        }
      }
}

điều này có thể được thực hiện hiệu quả hơn nhiều, nhưng đây là một phiên bản cồng kềnh với tất cả các bit của nó.

không phải tất cả đều có thể mang theo, nhưng hoạt động tốt với bất cứ thứ gì có trên máy tính của tôi (không có ý tưởng, tôi là hình ảnh không phải từ ngữ)

Một cách dễ dàng để so sánh các chuỗi chỉ khác nhau bằng các ký tự viết thường và viết hoa là thực hiện so sánh ascii. Tất cả chữ in hoa và chữ thường khác nhau 32 bit trong bảng ascii, sử dụng thông tin này, chúng tôi có ...

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