Perbandingan string case-insensitive dalam C ++ [ditutup]

Apa cara terbaik untuk melakukan perbandingan string case-insensitive dalam C ++ tanpa mengubah string menjadi semua huruf besar atau semua huruf kecil?

Harap tunjukkan apakah metode ini ramah Unicode dan seberapa portabelnya.

Boost menyertakan algoritme yang berguna untuk ini:

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

Manfaatkan standar ini char_traits. Ingatlah bahwa std::stringsebenarnya adalah typedef untuk std::basic_string<char>, atau lebih eksplisit std::basic_string<char, std::char_traits<char> >,. The char_traitsTipe menjelaskan bagaimana karakter membandingkan, bagaimana mereka menyalin, bagaimana mereka melemparkan dll Semua perlu Anda lakukan adalah typedef string baru lebih basic_string, dan memberikan dengan kustom Anda sendiri char_traitsyang membandingkan kasus 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;

Rinciannya ada di Guru of The Week nomor 29 .

Masalahnya dengan peningkatan adalah Anda harus terhubung dengan dan bergantung pada dorongan. Tidak mudah dalam beberapa kasus (mis. Android).

Dan menggunakan char_traits berarti semua perbandingan Anda tidak peka terhadap huruf besar-kecil, yang biasanya tidak seperti yang Anda inginkan.

Ini sudah cukup. Itu harus cukup efisien. Tidak menangani unicode atau apapun.

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

Pembaruan: Versi 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);
                      });
}

Jika Anda menggunakan sistem POSIX, Anda dapat menggunakan strcasecmp . Namun, fungsi ini bukan bagian dari standar C, juga tidak tersedia di Windows. Ini akan melakukan perbandingan case-insensitive pada karakter 8-bit, selama lokalnya adalah POSIX. Jika lokal bukan POSIX, hasilnya tidak terdefinisi (sehingga mungkin melakukan perbandingan lokal, atau mungkin tidak). Setara karakter lebar tidak tersedia.

Kegagalan itu, sejumlah besar implementasi C library bersejarah memiliki fungsi stricmp () dan strnicmp (). Visual C ++ pada Windows mengganti nama semua ini dengan mengawali mereka dengan garis bawah karena mereka bukan bagian dari standar ANSI, jadi pada sistem itu mereka disebut _stricmp atau _strnicmp . Beberapa perpustakaan mungkin juga memiliki fungsi setara karakter lebar atau multibyte (biasanya dinamakan misalnya wcsicmp, mbcsicmp, dan sebagainya).

C dan C ++ sama-sama tidak mengetahui masalah internasionalisasi, jadi tidak ada solusi yang baik untuk masalah ini, kecuali menggunakan perpustakaan pihak ketiga. Periksa IBM ICU (Komponen Internasional untuk Unicode) jika Anda memerlukan pustaka yang kuat untuk C / C ++. ICU adalah untuk sistem Windows dan Unix.

Apakah Anda berbicara tentang membandingkan kasus bodoh bodoh atau Unicode penuh normalisasi?

Membandingkan bodoh tidak akan menemukan string yang mungkin sama tetapi tidak sama biner.

Contoh:

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

Semuanya setara tetapi mereka juga memiliki representasi biner yang berbeda.

Yang mengatakan, Normalisasi Unicode harus menjadi bacaan wajib terutama jika Anda berencana mendukung Hangul, Thailand dan bahasa asia lainnya.

Selain itu, IBM mematenkan algoritma Unicode yang paling optimal dan membuatnya tersedia untuk umum. Mereka juga mempertahankan implementasi: IBM ICU

boost :: iequals tidak kompatibel dengan utf-8 dalam hal string. Anda dapat menggunakan boost :: locale .

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

• Utama - abaikan aksen dan huruf besar-kecil, membandingkan huruf dasar saja. Misalnya "fasad" dan "Fasad" adalah sama.
• Sekunder - abaikan case character tetapi pertimbangkan aksen. "fasad" dan "fasad" berbeda tetapi "fasad" dan "fasad" sama.
• Tersier - pertimbangkan kasus dan aksen: "Façade" dan "façade" berbeda. Abaikan tanda baca.
• Kuarter - pertimbangkan semua huruf besar, aksen, dan tanda baca. Kata-kata harus identik dalam hal representasi Unicode.
• Identik - sebagai kuaterner, tetapi bandingkan poin kode juga.

Pikiran pertama saya untuk versi non-unicode adalah melakukan sesuatu seperti ini:

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

Anda dapat menggunakan strcasecmpdi Unix, atau stricmpdi Windows.

Satu hal yang belum disebutkan sejauh ini adalah bahwa jika Anda menggunakan string stl dengan metode ini, ada baiknya untuk terlebih dahulu membandingkan panjang kedua string, karena informasi ini sudah tersedia untuk Anda di kelas string. Ini bisa mencegah melakukan perbandingan string yang mahal jika dua string yang Anda bandingkan bahkan tidak sama panjangnya.

Fungsi string Visual C ++ mendukung unicode: http://msdn.microsoft.com/en-us/library/cc194799.aspx

yang mungkin Anda cari adalah _wcsnicmp

Saya mencoba menyusun jawaban yang baik dari semua posting, jadi bantu saya edit ini:

Berikut adalah metode untuk melakukan ini, meskipun itu mengubah string, dan tidak ramah Unicode, itu harus portabel yang merupakan nilai tambah:

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

Dari apa yang saya baca ini lebih portabel daripada stricmp () karena stricmp () sebenarnya bukan bagian dari perpustakaan std, tetapi hanya diimplementasikan oleh sebagian besar vendor kompiler.

Untuk mendapatkan implementasi yang benar-benar ramah Unicode tampaknya Anda harus pergi ke luar perpustakaan std. Satu perpustakaan pihak ketiga yang bagus adalah IBM ICU (Komponen Internasional untuk Unicode)

Juga meningkatkan :: iequals menyediakan utilitas yang cukup baik untuk melakukan perbandingan semacam ini.

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

Anda dapat menggunakan kode di atas dalam C ++ 14 jika Anda tidak berada dalam posisi untuk menggunakan boost. Anda harus menggunakan std::towloweruntuk karakter lebar.

The Boost.String perpustakaan memiliki banyak algoritma untuk melakukan hal-insenstive perbandingan dan sebagainya.

Anda bisa menerapkan sendiri, tetapi mengapa repot ketika itu sudah dilakukan?

FYI, strcmp()dan stricmp()rentan terhadap buffer overflow, karena mereka hanya memproses sampai mereka mencapai terminator nol. Lebih aman digunakan _strncmp()dan _strnicmp().

Lihat 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

Untuk kebutuhan perbandingan string case sensitif dasar saya, saya lebih suka tidak harus menggunakan perpustakaan eksternal, saya juga tidak ingin kelas string terpisah dengan sifat-sifat case sensitif yang tidak kompatibel dengan semua string saya yang lain.

Jadi yang saya pikirkan adalah ini:

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

Fungsi sederhana dengan satu overload untuk char dan lainnya untuk whar_t. Tidak menggunakan apa pun yang tidak standar sehingga harus baik-baik saja pada platform apa pun.

Perbandingan kesetaraan tidak akan mempertimbangkan masalah seperti pengodean panjang variabel dan normalisasi Unicode, tetapi basic_string tidak memiliki dukungan untuk itu yang saya sadari dan itu biasanya bukan masalah.

Dalam kasus di mana manipulasi leksikografis yang lebih canggih dari teks diperlukan, maka Anda hanya harus menggunakan perpustakaan pihak ketiga seperti Boost, yang diharapkan.

Pendek dan bagus. Tidak ada dependensi lain, selain std C lib diperpanjang .

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

mengembalikan true jika str1dan str2sama. strcasecmpmungkin tidak ada, mungkin ada analog stricmp, strcmpi, dll

Kode contoh:

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

Keluaran:

true
true
true
true
true

Melakukan ini tanpa menggunakan Boost dapat dilakukan dengan mendapatkan pointer string C dengan c_str()dan menggunakan strcasecmp:

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

Dengan asumsi Anda sedang mencari metode dan bukan fungsi sihir yang sudah ada, terus terang tidak ada cara yang lebih baik. Kita semua dapat menulis cuplikan kode dengan trik pintar untuk rangkaian karakter terbatas, tetapi pada akhirnya di suatu tempat Anda harus mengonversi karakter.

Pendekatan terbaik untuk konversi ini adalah melakukannya sebelum perbandingan. Ini memungkinkan Anda banyak fleksibilitas dalam hal skema penyandian, yang seharusnya tidak diperhatikan oleh operator perbandingan Anda.

Tentu saja Anda dapat 'menyembunyikan' konversi ini di belakang fungsi atau kelas string Anda sendiri, tetapi Anda masih perlu mengonversi string sebelum perbandingan.

Saya menulis versi char_traits case-insensitive untuk digunakan dengan std :: basic_string untuk menghasilkan string std :: yang tidak peka huruf besar-kecil ketika melakukan perbandingan, pencarian, dll menggunakan fungsi anggota std :: basic_string bawaan.

Jadi dengan kata lain, saya ingin melakukan sesuatu seperti ini.

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

assert( a == b );

... yang std :: string tidak dapat menangani. Inilah penggunaan char_traits baru saya:

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

assert( a == b );

... dan inilah implementasinya:

/*  ---

        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;

Saya memiliki pengalaman yang baik dalam menggunakan Komponen Internasional untuk pustaka Unicode - mereka sangat kuat, dan menyediakan metode untuk konversi, dukungan lokal, rendering tanggal dan waktu, pemetaan kasus (yang sepertinya tidak Anda inginkan), dan pengumpulan , yang mencakup perbandingan case-and-accentitive (dan banyak lagi). Saya hanya menggunakan versi C ++ dari pustaka, tetapi mereka tampaknya memiliki versi Java juga.

Ada metode untuk melakukan pembandingan yang dinormalisasi sebagaimana dimaksud oleh @Coincoin, dan bahkan dapat menjelaskan lokal - misalnya (dan ini contoh penyortiran, tidak sepenuhnya kesetaraan), secara tradisional dalam bahasa Spanyol (di Spanyol), kombinasi huruf "ll" akan memilah antara "l" dan "m", jadi "lz" <"ll" <"ma".

Cukup gunakan strcmp()untuk case sensitive dan strcmpi()atau stricmp()untuk case sensitive case. Yang keduanya di file header<string.h>

format:

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

Pemakaian:

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;

Keluaran

apel dan ApPlE adalah sama

a datang sebelum b, jadi apel datang sebelum bola

Terlambat ke pesta, tetapi di sini ada varian yang menggunakan std::locale, dan dengan demikian menangani Turki dengan benar:

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

memberi Anda functor yang menggunakan lokal aktif untuk mengonversi karakter menjadi huruf kecil, yang kemudian dapat Anda gunakan std::transformuntuk menghasilkan string huruf kecil:

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

Ini juga berfungsi untuk wchar_tstring berbasis.

Hanya catatan tentang metode apa pun yang akhirnya Anda pilih, jika metode itu terjadi termasuk penggunaan strcmp yang beberapa jawaban sarankan:

strcmptidak bekerja dengan data Unicode secara umum. Secara umum, itu bahkan tidak bekerja dengan encode Unicode berbasis byte, seperti utf-8strcmp hanya membuat perbandingan byte per byte dan titik kode Unicode yang dikodekan dalam utf-8 dapat membutuhkan lebih dari 1 byte. Satu-satunya kasus Unicode khusus yang strcmpditangani dengan benar adalah ketika string yang dikodekan dengan pengkodean berbasis byte hanya berisi poin kode di bawah U + 00FF - maka perbandingan byte-per-byte sudah cukup.

Pada awal 2013, proyek ICU, dikelola oleh IBM, adalah jawaban yang cukup bagus untuk ini.

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

ICU adalah "perpustakaan Unicode portabel yang lengkap yang secara ketat melacak standar industri." Untuk masalah spesifik perbandingan string, objek Collation melakukan apa yang Anda inginkan.

Proyek Mozilla mengadopsi ICU untuk internasionalisasi di Firefox pada pertengahan 2012; Anda dapat melacak diskusi teknik, termasuk masalah sistem pembangunan dan ukuran file data, di sini:

• https://groups.google.com/forum/#!topic/mozilla.dev.platform/sVVpS2sKODw
• https://bugzilla.mozilla.org/show_bug.cgi?id=724529 (pelacak)
• https://bugzilla.mozilla.org/show_bug.cgi?id=724531 (sistem bangun)

Sepertinya solusi di atas tidak menggunakan metode bandingkan dan menerapkan total lagi jadi di sini adalah solusi saya dan berharap itu berfungsi untuk Anda (Ini berfungsi dengan baik).

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

Jika Anda tidak ingin menggunakan perpustakaan Boost maka di sini ada solusi untuk itu hanya menggunakan header C ++ io standar.

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

Jika Anda harus membandingkan string sumber lebih sering dengan string lain, salah satu solusi elegan adalah menggunakan 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);

Cara sederhana untuk membandingkan dua string dalam c ++ (diuji untuk windows) adalah menggunakan _stricmp

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

Jika Anda ingin menggunakan dengan std :: string, contoh:

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

Untuk informasi lebih lanjut di sini: 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;
        }
      }
}

ini mungkin bisa dibuat jauh lebih efisien, tetapi di sini ada versi besar dengan semua bitnya telanjang.

tidak semua yang portabel, tetapi bekerja dengan baik dengan apa pun yang ada di komputer saya (tidak tahu, saya gambar bukan kata-kata)

Cara mudah untuk membandingkan string yang hanya berbeda dengan huruf kecil dan huruf besar adalah dengan melakukan perbandingan ascii. Semua huruf besar dan kecil berbeda 32 bit dalam tabel ascii, menggunakan informasi ini kami memiliki ...

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