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

假设您正在寻找一个方法，而不是一个已经存在的神奇函数，坦率地说，没有更好的方法。对于有限的字符集，我们都可以使用聪明的技巧编写代码片段，但在一天结束时，你必须转换字符。

这种转换的最佳方法是在比较之前进行转换。当涉及到编码方案时，这为您提供了很大的灵活性，而实际的比较操作符应该忽略这一点。

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

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

你要找的可能是_wcsnicmp

供你参考，strcmp()和stricmp()很容易受到缓冲区溢出的影响，因为它们一直处理到遇到空结束符为止。使用_strncmp()和_strnicmp()更安全。

我有很好的使用Unicode库的国际组件的经验-它们非常强大，并提供了转换、区域支持、日期和时间呈现、大小写映射(你似乎不想要)和排序的方法，其中包括大小写和重音不敏感的比较(以及更多)。我只使用了c++版本的库，但它们似乎也有Java版本。

方法可以执行标准化的比较，如@Coincoin所提到的，甚至可以解释地区-例如(这是一个排序的例子，不是严格的相等)，传统的西班牙语(在西班牙)，字母组合“ll”在“l”和“m”之间排序，所以“lz”<“我”& lt;“马”。

你说的是一个愚蠢的不区分大小写的比较还是一个完全标准化的Unicode比较?

哑比较不会找到可能相同但二进制不相等的字符串。

例子:

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

都是等价的，但它们也有不同的二进制表示。

也就是说，Unicode正常化应该是必读的，特别是如果你计划支持韩文，Thaï和其他亚洲语言。

此外，IBM几乎为大多数优化的Unicode算法申请了专利，并将它们公开提供。它们还维护一个实现:IBM ICU

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

这里有一个这样做的方法，虽然它转换字符串，并不是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还提供了一个相当好的实用程序来进行这种比较。

如果你在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版本，我的第一个想法是这样做的:

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

我写了一个不区分大小写的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;

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
}

对于你最终选择的任何方法，如果该方法恰好包括一些答案所建议的strcmp的使用，请注意:

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

你可以在Unix上使用strcasecmp，或者在Windows上使用stricmp。

到目前为止还没有提到的一件事是，如果您使用这些方法使用stl字符串，首先比较两个字符串的长度是有用的，因为这个信息已经在string类中提供给您了。如果您正在比较的两个字符串的长度一开始就不相同，这可以防止进行代价高昂的字符串比较。

提振。字符串库有很多算法用于进行不区分大小写的比较等等。

您可以实现自己的，但如果已经完成了，为什么还要麻烦呢?

利用标准char_traits。回想一下，std::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名上。

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

boost::iequals在string的情况下不兼容utf-8。 你可以使用boost::语言环境.

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

• Primary—忽略重音和字符大小写，只比较基本字母。例如，“facade”和“Façade”是相同的。
• 其次——忽略字符大小写，但要考虑口音。“facade”和“façade”不同，“Façade”和“façade”相同。
• 第三级——考虑大小写和重音:“Façade”和“façade”是不同的。忽略标点符号。
• 第四位——考虑所有的大小写、重音和标点符号。这些单词在Unicode表示方面必须相同。
• 相同——作为四进制，但也比较代码点。

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

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

ICU是一个“完整的、可移植的Unicode库，密切跟踪行业标准”。对于字符串比较的特定问题，Collation对象将执行您想要的操作。

2012年年中，Mozilla项目在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(构建系统)

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

所以我想到的是:

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这样的第三方库，这是可以预料到的。

只使用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之前，所以苹果在球之前

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

这可能会更有效，但这是一个笨重的版本，所有的比特都是空的。

不是所有的便携，但工作得很好，在我的电脑上(不知道，我是图片而不是文字)

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

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


std::wregex pattern(first, std::wregex::icase);
bool isEqual = std::regex_match(second, pattern);

比较只有小写字符和大写字符不同的字符串的一个简单方法是进行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
}
}

看到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::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的字符串。

不使用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
}

又短又漂亮。没有其他依赖，除了扩展 std C 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

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。

看起来以上的解决方案没有使用比较方法和实现总数，所以这里是我的解决方案，希望它为你工作(它的工作很好)。

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

在c++中比较两个字符串的一个简单方法是使用_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

如果你不想使用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;
}