372

在 C++ 中进行不区分大小写的字符串比较而不将字符串转换为全部大写或全部小写的最佳方法是什么？

请说明这些方法是否对 Unicode 友好以及它们的可移植性。

4

30 回答 30

325

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
}
于 2008-11-24T21:03:58.740 回答
122

利用标准char_traits。回想一下，astd::string实际上是 的类型std::basic_string<char>定义，或者更明确地说，std::basic_string<char, std::char_traits<char> >。该char_traits类型描述了字符如何比较、它们如何复制、它们如何转换等。您需要做的就是在 上键入一个新字符串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 周的 Guru 上。

于 2010-05-22T01:36:53.010 回答
111

boost的问题在于你必须与boost链接并依赖boost。在某些情况下并不容易（例如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);
                      });
}

更新：C++20 版本使用std::ranges：

#include <ranges>
#include <algorithm>
#include <string>

bool iequals(const std::string_view& lhs, const std::string_view& rhs) {
    auto to_lower{ std::ranges::views::transform(std::tolower) };
    return std::ranges::equal(lhs | to_lower, rhs | to_lower);
}
于 2010-11-07T21:49:17.233 回答
60

如果您在 POSIX 系统上，则可以使用strcasecmp。但是，此函数不是标准 C 的一部分，在 Windows 上也不可用。只要语言环境是 POSIX，这将对 8 位字符执行不区分大小写的比较。如果语言环境不是 POSIX，则结果未定义（因此它可能会进行本地化比较，也可能不会）。没有等效的宽字符。

如果做不到这一点，大量历史 C 库实现都具有函数 stricmp() 和 strnicmp()。Windows 上的 Visual C++ 通过在它们前面加上下划线来重命名所有这些，因为它们不是 ANSI 标准的一部分，因此在该系统上它们被称为_stricmp 或 _strnicmp。一些库还可能具有宽字符或多字节等效函数（通常命名为例如 wcsicmp、mbcsicmp 等）。

C 和 C++ 在很大程度上都对国际化问题一无所知，所以除了使用第三方库外，没有很好的解决方案。如果您需要一个健壮的 C/C++ 库，请查看IBM ICU（Unicode 国际组件） 。ICU 适用于 Windows 和 Unix 系统。

于 2008-08-14T20:46:03.803 回答
55

您是在谈论不区分大小写的愚蠢比较还是完全规范化的 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

于 2008-08-14T20:31:35.300 回答
32

我对非 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(static_cast<unsigned char>(*c1)) != tolower(static_cast<unsigned char>(*c2))) {
            return false;
        }
    }
    return true;
}
于 2008-08-26T11:51:28.737 回答
32

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

comparator<char,collator_base::secondary> cmpr;
cout << (cmpr(str1, str2) ? "str1 < str2" : "str1 >= str2") << endl;
  • 主要的——忽略重音和字符大小写，只比较基本字母。例如，“facade”和“Façade”是相同的。
  • 次要的——忽略字符大小写但考虑重音。“立面”和“立面”是不同的，但“立面”和“立面”是相同的。
  • 第三——考虑大小写和重音：“Façade”和“façade”是不同的。忽略标点符号。
  • Quaternary - 考虑所有大小写、重音符号和标点符号。就 Unicode 表示而言，这些词必须相同。
  • 相同 - 作为四元，但也比较代码点。
于 2012-04-26T08:51:29.660 回答
26

您可以strcasecmp在 Unix 或stricmpWindows 上使用。

到目前为止还没有提到的一件事是，如果您将 stl 字符串与这些方法一起使用，首先比较两个字符串的长度很有用，因为您已经可以在字符串类中获得这些信息。如果您要比较的两个字符串一开始的长度甚至不同，这可以防止进行代价高昂的字符串比较。

于 2008-12-02T00:51:17.953 回答
15

我正在尝试从所有帖子中拼凑出一个好的答案，所以请帮我编辑一下：

这是一种执行此操作的方法，虽然它确实转换了字符串，并且对 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也为进行这种比较提供了相当好的实用程序。

于 2008-08-14T20:35:17.180 回答
14

支持 unicode 的 Visual C++ 字符串函数：http: //msdn.microsoft.com/en-us/library/cc194799.aspx

您可能正在寻找的那个是_wcsnicmp

于 2008-08-14T20:11:48.070 回答
13

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

演示

于 2015-09-16T21:54:51.137 回答
13 
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宽字符。

于 2017-04-05T09:18:49.980 回答
12

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

于 2008-08-14T20:29:24.867 回答
12

简短而美好。除了扩展的标准 C 库之外，没有其他依赖项。

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

如果和相等 则返回真。可能不存在，可能有类似物,等。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
于 2016-09-30T15:51:56.657 回答
11

Boost.String库有很多算法可以进行不区分大小写的比较等等。

您可以实现自己的，但既然已经完成了，为什么还要麻烦呢？

于 2010-05-22T00:57:43.227 回答
9

对于我基本的不区分大小写的字符串比较需求，我不希望使用外部库，也不希望使用与所有其他字符串不兼容的不区分大小写特征的单独字符串类。

所以我想出的是：

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 这样的第三方库，这是意料之中的。

于 2013-06-26T21:29:22.863 回答
9

在不使用 Boost 的情况下执行此操作可以通过使用c_str()和使用获取 C 字符串指针来完成strcasecmp：

std::string str1 ="aBcD";
std::string str2 = "AbCd";;
if (strcasecmp(str1.c_str(), str2.c_str()) == 0)
{
    //case insensitive equal 
}
于 2016-01-12T09:08:49.330 回答
6

假设您正在寻找一种方法而不是已经存在的魔术功能，坦率地说，没有更好的方法。我们都可以为有限的字符集编写带有巧妙技巧的代码片段，但在一天结束时，您必须转换字符。

这种转换的最佳方法是在比较之前进行。当涉及到编码方案时，这为您提供了很大的灵活性，您的实际比较运算符应该不知道。

您当然可以在您自己的字符串函数或类后面“隐藏”这种转换，但您仍然需要在比较之前转换字符串。

于 2008-08-14T20:10:37.807 回答
6

我编写了一个不区分大小写的 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<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;
于 2008-11-17T23:32:10.440 回答
4

我在使用Unicode 库的国际组件方面有很好的经验——它们非常强大，并提供了转换方法、语言环境支持、日期和时间渲染、大小写映射（您似乎不想要）和排序规则，其中包括不区分大小写和重音的比较（等等）。我只使用了 C++ 版本的库，但它们似乎也有 Java 版本。

存在执行@Coincoin 所指的标准化比较的方法，甚至可以考虑语言环境 - 例如（这是一个排序示例，不是严格相等），传统上在西班牙语中（在西班牙），字母组合“ll”在“l”和“m”，所以“lz”<“ll”<“ma”。

于 2008-08-14T20:29:47.707 回答
4

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

输出

苹果和苹果是一样的

a在b之前，所以apple在ball之前

于 2013-07-25T18:47:35.253 回答
3

迟到了，但这是一个使用 的变体，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基于字符串。

于 2015-09-29T00:25:21.060 回答
2

只需说明您最终选择的任何方法，如果该方法恰好包括使用strcmp一些答案建议的方法：

strcmp通常不适用于 Unicode 数据。一般来说，它甚至不适用于基于字节的 Unicode 编码，例如 utf-8，因为strcmp只能进行逐字节比较，而 utf-8 编码的 Unicode 代码点可能占用超过 1 个字节。唯一正确处理的特定 Unicode 情况strcmp是，当使用基于字节的编码编码的字符串仅包含低于 U+00FF 的代码点时——那么逐字节比较就足够了。

于 2008-11-25T07:26:28.140 回答
2

截至 2013 年初，由 IBM 维护的 ICU 项目是一个很好的答案。

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

ICU 是一个“完整的、可移植的 Unicode 库，密切跟踪行业标准”。对于字符串比较的具体问题，Collat​​ion 对象为所欲为。

Mozilla 项目于 2012 年年中在 Firefox 中采用 ICU 进行国际化；您可以在此处跟踪工程讨论，包括构建系统和数据文件大小的问题：

于 2013-04-01T17:58:52.253 回答
2

看起来上面的解决方案没有使用 compare 方法并再次实现 total 所以这是我的解决方案，希望它对你有用（它工作正常）。

#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;
}
于 2017-08-26T19:57:43.683 回答
2

在 C++ 中比较两个字符串（针对 Windows 测试）的一种简单方法是使用_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

于 2018-04-18T09:33:57.343 回答
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;
}
于 2018-04-26T21:40:34.990 回答
0

如果您必须更频繁地将源字符串与其他字符串进行比较，那么一种优雅的解决方案是使用正则表达式。

std::wstring first = L"Test";
std::wstring second = L"TEST";

std::wregex pattern(first, std::wregex::icase);
bool isEqual = std::regex_match(second, pattern);
于 2015-03-06T13:55:25.730 回答
-1 
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;
        }
      }
}

这可能会变得更有效率，但这是一个笨重的版本，它的所有部分都是裸露的。

不是那么便携，但适用于我电脑上的任何东西（不知道，我是图片而不是文字）

于 2015-03-05T02:40:46.587 回答
-4

比较仅小写和大写字符不同的字符串的一种简单方法是进行 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
    }
}
于 2015-05-12T14:17:42.140 回答