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

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

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

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

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

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

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

所以我想到的是:

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

的提振。String库有很多算法来做不区分大小写的比较等等。

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

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

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