C++中不区分大小写的字符串比较

增强的问题在于你必须链接并依赖于提升.在某些情况下并不容易(例如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;
}

更新:Bonus C++ 14 version(#include ):

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()函数.Windows上的Visual C++通过在前面添加下划线来重命名所有这些,因为它们不是ANSI标准的一部分,因此在该系统上它们被称为_stricmp或_strnicmp.某些库也可能具有宽字符或多字节等效函数(通常命名为例如wcsicmp,mbcsicmp等).

C和C++都基本上不了解国际化问题,因此除了使用第三方库之外,没有好的解决方案.如果您需要一个强大的C/C++库,请查看IBM ICU(Unicode的国际组件).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规范化应该是强制性的读取,特别是如果您计划支持Hangul,Thaï和其他亚洲语言.

此外,IBM还获得了大多数优化的Unicode算法专利,并将其公之于众.他们还维护一个实现:IBM ICU

在字符串的情况下,boost :: iequals不兼容utf-8.您可以使用boost :: locale.

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

主要 - 忽略重音和字符大小写,仅比较基本字母.例如"facade"和"Façade"是相同的.

次要 - 忽略字符大小写但考虑重音."立面"和"立面"不同,但"外墙"和"立面"是相同的.

大学 - 考虑案例和口音:"外墙"和"外观"是不同的.忽略标点符号.

第四纪 - 考虑所有案例,重音和标点符号.在Unicode表示方面,单词必须相同.

相同 - 作为四元组,但也比较代码点.

我对非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或stricmpWindows上使用.

到目前为止还没有提到的一件事是,如果你使用这些方法的stl字符串,首先比较两个字符串的长度是有用的,因为这个信息已经在字符串类中可用了.如果您比较的两个字符串首先不是相同的长度,这可能会阻止进行昂贵的字符串比较.

支持unicode的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()更便携,因为stricmp()实际上不是std库的一部分,但只是由大多数编译器供应商实现.

为了获得真正的Unicode友好实现,你必须走出std库.一个好的第三方库是IBM ICU(Unicode的国际组件)

另外boost :: iequals为进行这种比较提供了相当好的实用工具.

仅供参考,strcmp()并且stricmp()容易受到缓冲区溢出的影响,因为它们只是处理直到它们达到空终止符.使用_strncmp()和更安全_strnicmp().

该Boost.String图书馆有很多算法做案例insenstive比较等.

你可以实现自己的,但为什么它已经完成了呢？

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

如果你不能使用boost,你可以在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); });
}

一个简单的函数,一个用于char的重载,另一个用于whar_t.不使用任何非标准的东西,所以在任何平台上都应该没问题.

相等比较不会考虑可变长度编码和Unicode规范化等问题,但是basic_string不支持我所知道的并且通常不是问题.

如果需要对文本进行更复杂的词典编辑操作,那么您只需使用Boost等第三方库即可.

// lexicographical_compare example
#include   // std::cout, std::boolalpha
#include   // std::lexicographical_compare
#include   // std::tolower

// a case-insensitive comparison function:
bool mycomp (char c1, char c2) {
    return std::tolower(c1)

演示

        

16> kyb..：
简短又好看.没有其他依赖,而不是扩展 std C lib.

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


如果且相等则返回true.
可能不存在,可能有类似物,等等.str1str2strcasecmpstricmpstrcmpi

示例代码:

#include 
#include 
#include  //For strcasecmp(). Also could be found in 

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

输出:

true
true
true
true
true

        
奇怪的是,C++ std :: string没有ignore-case比较方法. 

17> Andrew Grant..：
假设你正在寻找一种方法而不是已经存在的魔法函数,坦率地说没有更好的方法.我们都可以使用有限字符集的巧妙技巧编写代码片段,但在某一天结束时,您必须转换字符.

这种转换的最佳方法是在比较之前这样做.这使您在编码方案时具有很大的灵活性,您的实际比较运算符应该是无知的.

您当然可以在自己的字符串函数或类后面"隐藏"此转换,但您仍需要在比较之前转换字符串.

        

18> John Dibling..：
我编写了一个不区分大小写的char_traits版本,用于std :: basic_string,以便在使用内置的std :: basic_string成员函数进行比较,搜索等时生成一个不区分大小写的std :: 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 > noCaseString;

            A typedef is declared below which simplifies this use for chars:

                typedef std::basic_string > istring;

    --- */

    template
    struct char_traits_nocase : public std::char_traits
    {
        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
    struct char_traits_nocase : public std::char_traits
    {
        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 > istring;
    typedef std::basic_string > iwstring;

        

19> DavidS..：
这样做不使用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 
}