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
}
부스트의 문제는 부스트와 연계하여 부스트에 의존해야 한다는 것입니다.경우에 따라서는 쉽지 않습니다(예: Android).
char_traits를 사용하는 것은 대소문자를 구분하지 않는다는 것을 의미합니다.대소문자를 구분하지 않는 것은 보통입니다.
이것으로 충분합니다.그것은 상당히 효율적일 것이다.하지만 유니코드 같은 건 다루지 않아요
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 버전(★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★#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 사용: C++20std::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);
}
standard준 of char_traits 「 「 」 「 」를해 주세요.std::string는 사실 for의 typedef입니다.std::basic_string<char> 구체적으로 말하면, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , .std::basic_string<char, std::char_traits<char> > . 。char_traits, 등을 .type 、 、 、 、 、 、 、 type type type type type 。.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;
자세한 내용은 The Week 29의 Guru에 있습니다.
POSIX 시스템에 있는 경우 strcasecmp를 사용할 수 있습니다.그러나 이 기능은 표준 C의 일부가 아니며 Windows에서도 사용할 수 없습니다.그러면 로케일이 POSIX인 경우 8비트 문자를 대소문자를 구분하지 않습니다.로케일이 POSIX가 아닌 경우 결과는 정의되지 않습니다(따라서 현지화된 비교를 실행할 수도 있고 그렇지 않을 수도 있습니다).와이드 문자 대응은 사용할 수 없습니다.
그렇지 않으면 많은 C 라이브러리 구현이 stricmp() 및 strnicmp() 함수를 가지고 있습니다.Windows 의 Visual C++ 는, ANSI 표준의 일부가 아니기 때문에, 이러한 모든 것을 밑줄로 프리픽스 해 이름을 변경합니다.따라서 이 시스템에서는 _stricmp 또는 _strnicmp 라고 부릅니다.일부 라이브러리에는 와이드 문자 또는 멀티바이트 등가 기능이 있습니다(일반적으로 wcsicmp, mbcsicmp 등).
C와 C++는 모두 국제화 문제에 대해 잘 모르기 때문에 서드파티 라이브러리를 사용하는 것 외에는 이 문제에 대한 좋은 해결책이 없습니다.C/C++용 강력한 라이브러리가 필요한 경우 IBM ICU(International Components for Unicode)를 확인하십시오.ICU는 Windows 및 Unix 시스템용입니다.
멍청한 대소문자를 구분하지 않는 비교를 말하는 건가요, 아니면 완전한 정규화된 Unicode 비교를 말하는 건가요?
dumb 비교에서는 동일할 수 있지만 2진수가 같지 않은 문자열은 검출되지 않습니다.
예:
U212B (ANGSTROM SIGN)
U0041 (LATIN CAPITAL LETTER A) + U030A (COMBINING RING ABOVE)
U00C5 (LATIN CAPITAL LETTER A WITH RING ABOVE).
모두 동일하지만 바이너리 표현도 다릅니다.
즉, 특히 한글, 태국어 및 기타 아시아 언어를 지원할 계획이라면 Unicode Normalization은 필수입니다.
또한 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;
- 기본 - 기본 문자만 비교하고 악센트 및 대소문자는 무시합니다.예를 들어 "facade"와 "facade"는 동일합니다.
- 보조 - 대소문자는 무시하되 억양을 고려합니다."facade"와 "facade"는 다르지만 "facade"와 "facade"는 동일하다.
- 세 번째 - 대소문자와 악센트를 모두 고려하십시오. "전면"과 "전면"은 다릅니다.구두점을 무시합니다.
- 4단계 - 대문자, 억양 및 구두점을 모두 고려합니다.단어들은 유니코드 표현에서 동일해야 합니다.
- 4진수와 동일하지만 코드 포인트도 비교합니다.
유니코드 버전이 아닌 다른 버전에서는 다음과 같은 작업을 수행하는 것이 우선이었습니다.
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;
}
하시면 됩니다.strcasecmp UNIX의 stricmp를 클릭합니다.
지금까지 언급되지 않은 것은 stl 문자열을 이러한 메서드와 함께 사용하는 경우 이 정보는 문자열 클래스에서 이미 사용 가능하기 때문에 먼저 두 문자열의 길이를 비교하는 것이 편리하다는 것입니다.이렇게 하면 비교하는 두 문자열의 길이가 처음부터 같지 않은 경우 비용이 많이 드는 문자열 비교를 방지할 수 있습니다.
모든 투고에서 좋은 답변을 얻으려고 합니다.이것 편집하는 것을 도와주세요.
이 방법은 문자열을 변환하고 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 라이브러리 밖으로 나가야 합니다.서드파티 라이브러리의 하나로 IBM ICU(International Components for Unicode)가 있습니다.
또, boost::iquals는, 이러한 종류의 비교를 실시하기 위한 꽤 좋은 유틸리티가 됩니다.
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와이드 차용.
짧고 멋있다.확장 표준 C lib 이외의 의존관계는 없습니다.
strcasecmp(str1.c_str(), str2.c_str()) == 0
true를 반환한다.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
다음을 참조해 주세요.
// 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;
}
Unicode를 지원하는 Visual C++ 문자열 함수:http://msdn.microsoft.com/en-us/library/cc194799.aspx
아마 찾으시는 건_wcsnicmp
고로strcmp() ★★★★★★★★★★★★★★★★★」stricmp()는 늘 터미네이터에 도달할 때까지 처리되기 때문에 버퍼 오버플로의 영향을 받기 쉽습니다. _strncmp()및 를 참조해 주세요.
더 부스트문자열 라이브러리에는 대소문자를 구분하지 않는 비교 등을 수행하기 위한 알고리즘이 많이 있습니다.
자신의 것을 실장할 수도 있지만, 이미 실장했을 때에 굳이 신경 쓸 필요는 없습니다.
기본적인 대소문자를 구분하지 않는 문자열 비교 요구에 대해서는 외부 라이브러리를 사용하지 않는 것이 좋습니다.또한 다른 모든 문자열과 호환되지 않는 대소문자를 구분하지 않는 특성을 가진 별도의 문자열 클래스는 원하지 않습니다.
그래서 제가 생각해낸 건,
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의 오버로드가 있는 단순한 함수입니다.표준 이외의 것을 사용하지 않기 때문에 어떤 플랫폼에서도 문제가 없습니다.
등식 비교에서는 가변 길이 인코딩이나 유니코드 정규화 등의 문제는 고려되지 않지만 basic_string은 제가 알고 있는 것을 지원하지 않으며 일반적으로는 문제가 되지 않습니다.
보다 고도의 텍스트 사전 조작이 필요한 경우 Boost와 같은 서드파티 라이브러리를 사용하면 됩니다.이것은 예상대로입니다.
이 하려면 Boost를 하여 C 포인터를 수 .c_str() and and를 합니다.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:: 문자열을 생성하기 위해 std::basic_string과 함께 사용할 char_traits 버전을 작성했습니다.
바꿔 말하면, 저는 이런 걸 하고 싶었어요.
std::string a = "Hello, World!";
std::string b = "hello, world!";
assert( a == b );
...std:: 문자열로 처리할 수 없습니다.새로운 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;
, 엔 '일단' '일단' '일단'을한 변종이 .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베이스 스트링
Unicode 라이브러리용 International Components를 사용해 본 경험이 있습니다.Unicode 라이브러리는 매우 강력하며 변환, 로케일 지원, 날짜 및 시간 렌더링, 케이스 매핑(원하지 않는 것 같음), 대/소문자를 구분하지 않는 대조(및 기타) 등의 방법을 제공합니다.라이브러리의 C++ 버전만 사용했는데 Java 버전도 있는 것 같습니다.
@Coincoin에서 언급하는 정규화된 비교를 실행하는 방법이 있으며 로케일(및 이것은 엄밀하게 동등하지 않은 정렬 예)도 고려할 수 있습니다.예를 들어, 전통적으로 스페인어(스페인에서는 "ll"은 "l"과 "m" 사이에 정렬되므로 "lll" < 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보다 먼저 온다. 그래서 사과는 공보다 먼저 온다.
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 를 참조해 주세요.
어떤 방법을 선택하시든, 만약 그 방법이 다음 방법을 사용하는 것을 포함한다면 참고하시기 바랍니다.strcmp다음과 같은 답변이 있습니다.
strcmp는 일반적으로 Unicode 데이터에서는 동작하지 않습니다.일반적으로 utf-8과 같은 바이트 기반 Unicode 인코딩에서는 동작하지 않습니다.strcmp는 바이트 단위 비교만 하고 utf-8로 인코딩된 Unicode 코드 포인트는 1바이트를 초과할 수 있습니다.유니코드 대소문자strcmpbyte-based encoding으로 인코딩된 문자열에 U+00FF 미만의 코드 포인트만 포함되어 있는 경우 바이트당 비교로 충분합니다.
2013년 초 현재 IBM이 관리하는 ICU 프로젝트는 이에 대한 매우 좋은 해답입니다.
ICU는 "업계 표준을 면밀히 추적하는 완전한 휴대용 Unicode 라이브러리"입니다.문자열 비교의 특정 문제에 대해서는 Collation 객체가 원하는 작업을 수행합니다.
Mozilla Project는 2012년 중반 Firefox의 국제화를 위해 ICU를 채택했습니다.여기서 빌드 시스템 및 데이터 파일 크기 문제를 포함한 엔지니어링 논의를 추적할 수 있습니다.
- https://groups.google.com/forum/ #!topic/mozilla.dev.platform/sVPS2sKODw
- 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;
}
소스 문자열을 다른 문자열과 자주 비교해야 하는 경우 regex를 사용하는 것이 좋습니다.
std::wstring first = L"Test";
std::wstring second = L"TEST";
std::wregex pattern(first, std::wregex::icase);
bool isEqual = std::regex_match(second, pattern);
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
}
}
언급URL : https://stackoverflow.com/questions/11635/case-insensitive-string-comparison-in-c
'programing' 카테고리의 다른 글
| Xcode 6 Beta 4에서 앱을 실행할 때 "MyApp.app" 파일을 볼 수 있는 권한이 없기 때문에 열 수 없습니다. (0) | 2023.04.24 |
|---|---|
| SQL Server에서의 왼쪽 조인과 왼쪽 외부 조인의 비교 (0) | 2023.04.19 |
| Windows에서 Node.js에서 hello.js 파일을 실행하는 방법 (0) | 2023.04.19 |
| WPF 키보드숏컷 (0) | 2023.04.19 |
| 앱 간의 차이점구성 및 웹.설정? (0) | 2023.04.19 |