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。a std::stringは実際にはstd::basic_string<char>、またはより明示的にはのtypedefであることを思い出してくださいstd::basic_string<char, std::char_traits<char> >。char_traitsタイプは、彼らはあなたがする必要があるのは、新しい文字列のtypedefであるなどをキャストする方法、彼らはどのようにコピーし、文字を比較する方法について説明basic_stringし、独自のカスタムでそれを提供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;

詳細は、第一週の教祖第29号に記載されています。

ブーストの問題は、ブーストにリンクして依存する必要があることです。場合によっては簡単ではありません（例：android）。

また、char_traitsを使用すると、すべての比較で大文字と小文字が区別されなくなります。通常、これは必要ありません。

これで十分です。それはかなり効率的でなければなりません。ただし、Unicodeなどは処理しません。

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でも使用できません。これは、ロケールがPOSIXである限り、8ビット文字に対して大文字と小文字を区別しない比較を実行します。ロケールがPOSIXでない場合、結果は未定義です（ローカライズされた比較が行われる場合と行われない場合があります）。同等のワイド文字は使用できません。

これに失敗すると、多くの歴史的なCライブラリの実装に関数stricmp（）とstrnicmp（）があります。Windows上のVisual C ++は、ANSI標準の一部ではないため、アンダースコアを前に付けることにより、これらすべての名前を変更しました。そのため、そのシステムでは、これらは_stricmpまたは_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の正規化を必ずお読みください。

また、IBMはほとんどの最適化されたUnicodeアルゴリズムの特許を取得し、それらを一般に公開しました。彼らは実装も維持しています：IBM ICU

boost :: iequalsは、文字列の場合、utf-8互換ではありません。boost :: localeを使用できます。

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

• プライマリ-基本文字のみを比較して、アクセントと大文字小文字を無視します。たとえば、「ファサード」と「ファサード」は同じです。
• 二次-文字の大文字小文字を無視しますが、アクセントを考慮します。「ファサード」と「ファサード」は異なりますが、「ファサード」と「ファサード」は同じです。
• 三次-大文字小文字の区別とアクセントの両方を考慮します。「ファサード」と「ファサード」は異なります。句読点を無視します。
• 第四紀-すべての大文字小文字、アクセント、句読点を考慮します。単語は、Unicode表現に関して同一である必要があります。
• 同一-4項と同じですが、コードポイントも比較します。

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

strcasecmpUnixまたはstricmpWindowsで使用できます。

これまで言及されていないことの1つは、これらのメソッドでstl文字列を使用している場合、最初に2つの文字列の長さを比較すると便利です。この情報は文字列クラスですでに利用できるためです。これにより、比較する2つの文字列がそもそも同じ長さでない場合に、コストのかかる文字列比較を実行できなくなる可能性があります。

ユニコードをサポートするVisual C ++文字列関数： http //msdn.microsoft.com/en-us/library/cc194799.aspx

あなたがおそらく探しているのは _wcsnicmp

私はすべての投稿から良い答えをまとめようとしていますので、これを編集してください：

これはこれを行う方法ですが、文字列を変換し、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（）は実際にはstdライブラリの一部ではなく、ほとんどのコンパイラベンダーによってのみ実装されているため、これはstricmp（）よりも移植性があります。

本当にUnicodeフレンドリーな実装を得るには、stdライブラリの外に出なければならないようです。良いサードパーティライブラリの1つは IBM ICU（International Components for Unicode）です。

また、boost :: 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()and を使用する方が安全_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); });
}

charのオーバーロードとwhar_tのオーバーロードを持つ単純な関数。標準以外のものは使用しないため、どのプラットフォームでも問題ありません。

等価比較では、可変長エンコーディングやUnicode正規化などの問題は考慮されませんが、basic_stringは、私が知っていることをサポートしていないため、通常は問題になりません。

テキストのより洗練された辞書編集操作が必要な場合は、Boostのようなサードパーティのライブラリを使用する必要がありますが、これは期待されています。

短くて素敵です。拡張 std C lib 以外の依存関係はありません。

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

とが等しい場合にtrueを返します。 類似があるかもしれない、存在しないかもしれない、など、str1str2strcasecmpstricmpstrcmpi

コード例：

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

すでに存在する魔法の関数ではなくメソッドを探しているとすると、率直に言ってこれ以上の方法はありません。限られた文字セット用の巧妙なトリックを使用してコードスニペットを作成することはできますが、結局のところ、ある時点で文字を変換する必要があります。

この変換の最善の方法は、比較の前に行うことです。これにより、実際の比較演算子が無視されるべきであるエンコードスキームに関して、かなりの柔軟性が得られます。

もちろん、この変換を独自の文字列関数またはクラスの背後に「隠す」ことができますが、比較する前に文字列を変換する必要があります。

組み込みのstd :: basic_stringメンバー関数を使用して比較や検索などを行うときに大文字と小文字を区別しないstd :: stringを生成するために、std :: basic_stringで使用するchar_traitsの大文字と小文字を区別しないバージョンを作成しました。

つまり、こういうことをやりたかったんです。

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;

International Components for Unicodeライブラリの使用経験は豊富です。これらは非常に強力であり、変換、ロケールのサポート、日付と時刻のレンダリング、大文字小文字のマッピング（必要ではないようです）、および照合のメソッドを提供します。これには、大文字と小文字およびアクセントを区別しない比較（およびその他）が含まれます。私はライブラリのC ++バージョンのみを使用しましたが、Javaバージョンもあるようです。

@Coincoinによって参照される正規化された比較を実行するメソッドが存在し、ロケールを説明することもできます-たとえば（これは厳密な等価ではなく、ソートの例です）、伝統的にスペイン語（スペイン）では、文字の組み合わせ「ll」は"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は同じです

aはbの前に来るので、リンゴはボールの前に来ます

パーティーには遅れますが、これはを使用するバリアントでありstd::locale、トルコ語を正しく処理します。

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

は、アクティブなロケールを使用して文字を小文字に変換するファンクターを提供します。これを使用して、小文字のstd::transform文字列を生成できます。

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

これは、wchar_tベースの文字列でも機能します。

最終的に選択した方法についてのメモです。もしその方法が偶然に strcmpいくつかの回答の、します。

strcmp一般的にUnicodeデータでは機能しません。一般に、strcmpバイトごとの比較とutf-8でエンコードされたUnicodeコードポイントは1バイト以上しか使用できないため、utf-8 などのバイトベースのUnicodeエンコーディングでも機能しません。strcmp適切に処理される唯一の特定のUnicodeケースは、バイトベースのエンコーディングでエンコードされた文字列にU + 00FF未満のコードポイントのみが含まれる場合であり、バイトごとの比較で十分です。

2013年の初めの時点で、IBMが管理しているICUプロジェクトは、これに対するかなり良い答えです。

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

ICUは、「業界標準を厳密に追跡する完全なポータブルUnicodeライブラリ」です。文字列比較の特定の問題については、Collat​​ionオブジェクトが必要な処理を実行します。

Mozillaプロジェクトは、2012年半ばにFirefoxの国際化にICUを採用しました。ここでは、ビルドシステムの問題やデータファイルのサイズなど、エンジニアリングに関する議論を追跡できます。

• 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ライブラリを使用したくない場合は、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;
}

ソース文字列を他の文字列とより頻繁に比較する必要がある場合、1つのエレガントな解決策は正規表現を使用することです。

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でテスト済み）で2つの文字列を比較する簡単な方法は、_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比較を行うことです。すべての大文字と小文字はASCIIテーブルで32ビット異なります。この情報を使用すると、次のようになります...

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