c++ উনল কেস+ইনসেন্সিটিভ স্ট্রিং তুলনা সি++




সি++ বই (24)

সমস্ত বড় হাতের অক্ষর বা সমস্ত ছোট হাতের অক্ষর রূপান্তরিত না করে C ++ তে কেস-অসংবেদনশীল স্ট্রিং তুলনা করার সর্বোত্তম উপায় কী?

ইউনিকোড বান্ধব এবং কিভাবে তারা পোর্টেবল হয় তা নির্দেশ করুন।


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


আপনি যদি স্ট্রিং একটি ভেক্টর আছে, উদাহরণস্বরূপ:

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


একটি অ-ইউনিকোড সংস্করণের জন্য আমার প্রথম চিন্তাটি এমন কিছু করতে হয়েছিল:


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

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

আপনি বুস্ট ব্যবহার করার ক্ষেত্রে না থাকলে আপনি C ++ 14 এ উপরের কোডটি ব্যবহার করতে পারেন। আপনি ব্যাপক অক্ষর জন্য std::towlower ব্যবহার করতে হবে।


আমার মৌলিক ক্ষেত্রে অসংবেদক স্ট্রিং তুলনা প্রয়োজনের জন্য আমি বাহ্যিক লাইব্রেরি ব্যবহার করতে পছন্দ করি না, এবং আমি আমার অন্যান্য স্ট্রিংগুলির সাথে অসঙ্গতিপূর্ণ এমন অসংবেদী বৈশিষ্ট্যগুলির ক্ষেত্রে পৃথক স্ট্রিং ক্লাস চাই না।

তাই আমি কি সঙ্গে আসা করেছি এই হল:

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 জন্য গৃহস্থালি এবং অন্য জন্য এক overload সঙ্গে একটি সহজ ফাংশন। যে কোনও প্ল্যাটফর্মের জন্য ভাল কিছু হওয়া উচিত নয়।

বৈষম্য তুলনাটি পরিবর্তনশীল দৈর্ঘ্য এনকোডিং এবং ইউনিকোড স্বাভাবিককরণের মতো বিষয় বিবেচনা করবে না, তবে মৌলিক_ স্ট্রিংটির যে কোনও কারণে আমি সচেতন থাকি না এবং এটি সাধারণত কোনও সমস্যা নয়।

এমন ক্ষেত্রে যেখানে পাঠ্যের আরো পরিশীলিত লেক্সিকোগ্রাফিক ম্যানিপুলেশন প্রয়োজন হয়, তখন আপনাকে কেবলমাত্র বুস্টের মত তৃতীয় পক্ষের লাইব্রেরি ব্যবহার করতে হবে, যা প্রত্যাশিত হবে।


স্ট্যান্ডার্ড char_traits সুবিধা নিন। মনে রাখবেন যে std::string আসলে std::basic_string<char> , অথবা আরো স্পষ্টভাবে, std::basic_string<char, std::char_traits<char> >char_traits ধরন বর্ণনা করে কিভাবে অক্ষরগুলি তুলনা করে, কীভাবে তারা অনুলিপি করে, কীভাবে তারা কাস্ট করে ইত্যাদি। আপনাকে যা করতে হবে তা হল basic_string উপর একটি নতুন স্ট্রিং basic_string , এবং এটি আপনার নিজস্ব কাস্টম char_traits দিয়ে সরবরাহ করুন যা 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;

বিস্তারিত সপ্তাহের ২9 তারিখের গুরু


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

এই সম্ভবত আরো দক্ষ করা যেতে পারে, কিন্তু এখানে তার সমস্ত বিট বেয়ার সঙ্গে একটি ভারী সংস্করণ।

সব পোর্টেবল নয়, তবে আমার কম্পিউটারে যাই হোক না কেন ভাল কাজ করে (কোনও ধারণা নেই, আমি ছবির শব্দ নয়)


আপনি বুস্ট লাইব্রেরি ব্যবহার করতে না চান তবে এখানে সি ++ স্ট্যান্ডার্ড আইও হেডার ব্যবহার করে এটি সমাধান করুন।

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

আপনি যদি POSIX সিস্টেমে থাকেন তবে আপনি strcasecmp ব্যবহার করতে পারেন। এই ফাংশনটি স্ট্যান্ডার্ড সি এর অংশ নয়, যদিও এটি উইন্ডোজগুলিতে উপলব্ধ নয়। এটি 8-বিট অক্ষরের ক্ষেত্রে একটি কেস-অসংবেদক তুলনা করবে, যতক্ষণ লোকেল POSIX হয়। যদি লোকেল POSIX না হয়, ফলাফলগুলি অনির্ধারিত (তাই এটি স্থানীয়করণের তুলনা করতে পারে, অথবা এটি নাও হতে পারে)। একটি প্রশস্ত চরিত্র সমতুল্য পাওয়া যায় না।

যে ব্যর্থ, ঐতিহাসিক সি লাইব্রেরী বাস্তবায়নের একটি বড় সংখ্যা stricmp () এবং strnicmp ()। উইন্ডোজ এ ভিজুয়াল সি ++ এগুলি এটিকে আন্ডারস্কোরের মাধ্যমে পূর্বাবস্থায় ফিরিয়ে আনার মাধ্যমে এই সমস্ত নামকরণ করে কারণ এটি ANSI স্ট্যান্ডার্ডের অংশ নয়, তাই সেই সিস্টেমে তারা _ স্ট্রিকম্প বা _strnicmp নামে পরিচিত। কিছু লাইব্রেরিগুলিতে বিস্তৃত অক্ষর বা মাল্টিবিট সমতুল্য ফাংশন থাকতে পারে (সাধারণত নামকরণ করা হয় যেমন wcsicmp, mbcsicmp এবং আরও)।

সি এবং সি ++ উভয়ই আন্তর্জাতিকীকরণের বিষয়গুলির অজানা, তাই তৃতীয় পক্ষের লাইব্রেরি ব্যবহার না করেই এই সমস্যার কোনও ভাল সমাধান নেই। সি / সি ++ এর জন্য একটি শক্তিশালী লাইব্রেরির প্রয়োজন হলে আইবিএম আইসিইউ (ইউনিকোডের জন্য আন্তর্জাতিক উপাদান) দেখুন । ICU উভয় উইন্ডোজ এবং ইউনিক্স সিস্টেমের জন্য।


Std :: মৌলিক_ স্ট্রিং ব্যবহার করার জন্য char_traits এর ক্ষেত্রে একটি কেস-অসংবেদক সংস্করণ লিখেছিলাম যা std :: স্ট্রিং উৎপন্ন করার জন্য কেস-সংবেদনশীল নয়, যখন বিল্ট-ইন std :: basic_string সদস্য ফাংশন ব্যবহার করে তুলনা, অনুসন্ধান ইত্যাদি করে।

তাই অন্য কথায়, আমি এমন কিছু করতে চেয়েছিলাম।

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

assert( a == b );

... যা স্টেড :: স্ট্রিং হ্যান্ডেল করতে পারে না। এখানে আমার নতুন 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;

পার্টির কাছে দেরী, কিন্তু এখানে এমন একটি রূপ রয়েছে যা std::locale ব্যবহার করে এবং তাই সঠিকভাবে তুরস্ক পরিচালনা করে:

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

অক্ষরকে ছোট হাতের অক্ষরে রূপান্তর করতে সক্রিয় লোকেল ব্যবহার করে এমন একটি ফাংশক দেয় যা আপনি std::transform মাধ্যমে নিম্ন- std::transform স্ট্রিংগুলি তৈরি করতে ব্যবহার করতে পারেন:

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

এই wchar_t ভিত্তিক স্ট্রিং জন্য কাজ করে।


আপনি ইউনিক্স, অথবা উইন্ডোজ stricmpstricmp ব্যবহার করতে পারেন।

এ পর্যন্ত উল্লেখ করা হয়নি এমন এক জিনিস হল যে যদি আপনি এই পদ্ধতিগুলির সাথে স্টল স্ট্রিংগুলি ব্যবহার করেন তবে প্রথমে দুটি স্ট্রিংগুলির দৈর্ঘ্যের সাথে তুলনা করা উপকারী, কারণ এই তথ্যটি আপনার কাছে ইতিমধ্যে স্ট্রিং ক্লাসে উপলব্ধ। আপনি তুলনা করা দুটি স্ট্রিং প্রথম স্থানে একই দৈর্ঘ্য না হলে এই ব্যয়বহুল স্ট্রিং তুলনা করতে প্রতিরোধ করতে পারে।


২013 সালের শুরুতে, আইবিএম কর্তৃক পরিচালিত আইসিইউ প্রকল্প, এটির একটি সুন্দর উত্তর।

site.icu-project.org

আইসিইউ একটি "সম্পূর্ণ, পোর্টেবল ইউনিকোড লাইব্রেরি যা ঘনিষ্ঠভাবে শিল্পের মানগুলি ট্র্যাক করে।" স্ট্রিং তুলনা নির্দিষ্ট সমস্যা জন্য, Collation বস্তু আপনি চান কি না।

২01২ সালের মাঝামাঝি ফায়ারফক্সে আন্তর্জাতিকীকরণের জন্য মজিলা প্রকল্প আইসিইউ গ্রহণ করেছে; আপনি বিল্ডিং সিস্টেম এবং ডেটা ফাইলের আকার সহ এখানে প্রকৌশল আলোচনা ট্র্যাক করতে পারেন, এখানে:



অনুমান করা হচ্ছে যে আপনি একটি পদ্ধতি খুঁজছেন এবং একটি জাদু ফাংশন যা ইতিমধ্যে বিদ্যমান নেই, সেখানে কোনও ভাল উপায় নেই। আমরা সীমাবদ্ধ চরিত্র সেটগুলির জন্য চতুর কৌশলগুলি সহ কোড স্নিপেটগুলি লিখতে পারি, কিন্তু দিনের শেষে কোনও সময়ে আপনাকে অক্ষর রূপান্তর করতে হবে।

এই রূপান্তর জন্য সেরা পদ্ধতি তুলনা করার আগে তাই করতে হয়। যখন এটি এনকোডিং স্কিমগুলি আসে তখন এটি আপনাকে নমনীয়তার একটি ভাল চুক্তি দেয়, যা আপনার প্রকৃত তুলনা অপারেটরকে অজ্ঞাত হওয়া উচিত।

আপনি অবশ্যই নিজের স্ট্রিং ফাংশন বা বর্গের পিছনে এই রূপান্তরটি লুকিয়ে রাখতে পারেন, তবে আপনাকে তুলনা করার আগে স্ট্রিংগুলিকে রূপান্তর করতে হবে।


আপনি একটি বোকা মামলা অসংবেদী তুলনা বা একটি সম্পূর্ণ স্বাভাবিক ইউনিকোড তুলনা সম্পর্কে কথা বলা হয়?

একটি বোকা তুলনা একই হতে পারে যে স্ট্রিং খুঁজে পাবেন না কিন্তু বাইনারি সমান নয়।

উদাহরণ:

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

সব সমতুল্য কিন্তু তারা বিভিন্ন বাইনারি উপস্থাপনা আছে।

যে বলেন, unicode.org/reports/tr15 একটি বাধ্যতামূলক পড়া উচিত, বিশেষ করে যদি আপনি Hangul, Thai এবং অন্যান্য এশিয়ান ভাষা সমর্থন করার পরিকল্পনা।

এছাড়াও, আইবিএম বেশিরভাগ অপটিমাইজড ইউনিকোড অ্যালগরিদমগুলি পেটেন্ট করেছে এবং তাদের সর্বজনীনভাবে উপলব্ধ করেছে। তারা একটি বাস্তবায়ন বজায় রাখে: আইবিএম আইসিইউ


আমি সব পোস্ট থেকে একটি ভাল উত্তর একত্রিত করার চেষ্টা করছি, তাই আমাকে এই সম্পাদনা করতে সাহায্য করুন:

এখানে এটি করার পদ্ধতি রয়েছে, যদিও এটি স্ট্রিংগুলিকে রূপান্তরিত করে এবং এটি ইউনিকোড বন্ধুত্বপূর্ণ নয় তবে এটি পোর্টেবল হওয়া উচিত যা প্লাস:

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 লাইব্রেরি বাইরে যেতে হবে। একটি ভাল তৃতীয় থার্ড লাইব্রেরি আইবিএম আইসিইউ (ইউনিকোডের আন্তর্জাতিক উপাদান)

এছাড়াও boost :: iququals তুলনা এই সাজানোর জন্য একটি মোটামুটি ভাল ইউটিলিটি প্রদান করে।


Boost.String লাইব্রেরিতে কেস-ইনসেনসিভ তুলনা করার জন্য অনেকগুলি অ্যালগরিদম রয়েছে।

আপনি আপনার নিজের বাস্তবায়ন করতে পারেন, কিন্তু কেন এটি ইতিমধ্যে সম্পন্ন করা হয় যখন বিরক্ত?


কেস সংবেদনশীল এবং strcmpi() অথবা stricmp() ক্ষেত্রে সংবেদনশীল সংবেদনশীলতার জন্য strcmp() ব্যবহার করুন। হেডার ফাইল <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;

আউটপুট

আপেল এবং অ্যাপল একই

একটি বি আগে আসে, তাই আপেল বল আগে আসে


FYI, strcmp() এবং stricmp() বাফার ওভারফ্লোের জন্য ঝুঁকিপূর্ণ, কারণ এটি একটি প্রক্রিয়া সম্পন্ন না হওয়া পর্যন্ত প্রক্রিয়া করে। _strncmp() এবং _strnicmp() ব্যবহার করা নিরাপদ।


যদি আপনি অন্য স্ট্রিংগুলির সাথে প্রায়শই একটি উৎস স্ট্রিং তুলনা করতে চান তবে একটি মার্জিত সমাধান 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);

সংক্ষিপ্ত এবং সুন্দর। বর্ধিত std সি 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

বুস্ট ব্যবহার না করে সিটি স্ট্রিং পয়েন্টারটি c_str() ব্যবহার করে এবং strcasecmp ব্যবহার করে সম্পন্ন করা যেতে পারে:

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

C ++ (উইন্ডোজের জন্য পরীক্ষিত) দুটি স্ট্রিং তুলনা করার একটি সহজ উপায় _ স্ট্রিকম্প ব্যবহার করছে

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

আপনি std :: স্ট্রিং ব্যবহার করতে চান, উদাহরণস্বরূপ:

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







string