C ++에서 대소 문자를 구분하지 않는 문자열 비교
문자열을 모두 대문자 또는 소문자로 변환하지 않고 C ++에서 대소 문자를 구분하지 않는 문자열 비교를 수행하는 가장 좋은 방법은 무엇입니까?
메소드가 유니 코드에 친숙한 지, 얼마나 이식성이 좋은지 알려주십시오.
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
}
표준을 활용하십시오 char_traits. a std::string는 실제로에 대한 typedef std::basic_string<char>또는 더 명확하게 는 typedef입니다 std::basic_string<char, std::char_traits<char> >. 이 char_traits유형은 문자를 비교하는 방법, 복사 방법, 캐스트 방법 등을 설명합니다. 새 문자열을 typedef하고 대소 문자를 구분하지 않는 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에 있습니다.
부스트의 문제점은 부스트와 연결하고 이에 의존해야한다는 것입니다. 어떤 경우에는 쉽지 않습니다 (예 : 안드로이드).
그리고 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 ++ 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);
});
}
POSIX 시스템 인 경우 strcasecmp 를 사용할 수 있습니다 . 그러나이 기능은 표준 C의 일부가 아니며 Windows에서도 사용할 수 없습니다. 로케일이 POSIX 인 경우 8 비트 문자를 대소 문자를 구분하지 않고 비교합니다. 로케일이 POSIX가 아닌 경우 결과가 정의되지 않으므로 지역화 된 비교를 수행하거나 수행하지 않을 수 있습니다. 넓은 문자를 사용할 수 없습니다.
실패한 수많은 역사적인 C 라이브러리 구현에는 stricmp () 및 strnicmp () 함수가 있습니다. Windows의 Visual C ++는 ANSI 표준의 일부가 아니기 때문에 밑줄로 접두어를 붙여 이러한 이름을 모두 바꿨습니다 . 따라서이 시스템에서는 _stricmp 또는 _strnicmp 라고 합니다. 일부 라이브러리에는 와이드 문자 또는 멀티 바이트 등가 함수 (일반적으로 이름이 wcsicmp, mbcsicmp 등)가있을 수도 있습니다.
C 및 C ++는 모두 국제화 문제에 대해 거의 무지하므로 타사 라이브러리를 사용하는 것 외에는이 문제에 대한 좋은 해결책이 없습니다. 확인 IBM ICU (유니 코드에 대한 국제 구성 요소) 은 C / C에 대한 강력한 라이브러리를 필요로하는 경우 ++. ICU는 Windows 및 Unix 시스템 용입니다.
대소 문자를 구분하지 않는 비교 또는 전체 정규화 된 유니 코드 비교에 대해 이야기하고 있습니까?
벙어리 비교는 같지만 이진 같지 않은 문자열을 찾지 않습니다.
예:
U212B (ANGSTROM SIGN)
U0041 (LATIN CAPITAL LETTER A) + U030A (COMBINING RING ABOVE)
U00C5 (LATIN CAPITAL LETTER A WITH RING ABOVE).
모두 동일하지만 서로 다른 이진 표현이 있습니다.
즉, 한글, 태국 및 기타 아시아 언어를 지원할 계획이라면 유니 코드 정규화 를 반드시 읽어야합니다.
또한 IBM은 특허를받은 가장 최적화 된 유니 코드 알고리즘을 공개하여 공개했습니다. 또한 구현을 유지 보수합니다. IBM ICU
boost :: iequals는 문자열의 경우 UTF-8과 호환되지 않습니다. boost :: locale을 사용할 수 있습니다 .
comparator<char,collator_base::secondary> cmpr;
cout << (cmpr(str1, str2) ? "str1 < str2" : "str1 >= str2") << endl;
- 기본-기본 문자 만 비교하여 악센트 및 대소 문자를 무시합니다. 예를 들어 "facade"와 "Façade"는 동일합니다.
- 보조-대소 문자를 무시하지만 악센트를 고려하십시오. "facade"와 "façade"는 다르지만 "Façade"와 "façade"는 동일합니다.
- 3 차-대소 문자와 악센트를 모두 고려하십시오. "Façade"와 "Fçade"는 다릅니다. 문장 부호를 무시하십시오.
- 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(*c1) != tolower(*c2)) {
return false;
}
}
return true;
}
strcasecmpUnix 또는 stricmpWindows에서 사용할 수 있습니다 .
지금까지 언급되지 않은 한 가지 방법은 이러한 방법으로 stl 문자열을 사용하는 경우이 정보가 문자열 클래스에서 이미 사용 가능하므로 두 문자열의 길이를 먼저 비교하는 것이 유용하다는 것입니다. 이렇게하면 비교하는 두 문자열의 길이가 동일하지 않은 경우 값 비싼 문자열 비교를 수행 할 수 없습니다.
유니 코드를 지원하는 Visual C ++ 문자열 함수 : http://msdn.microsoft.com/en-us/library/cc194799.aspx
아마 당신이 찾고있는 것은 _wcsnicmp
문자열 변환을 수행하지만 유니 코드에 적합하지는 않지만 이식 가능한 방법은 다음과 같습니다.
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 ()보다 이식성이 뛰어납니다.
진정한 유니 코드 친화적 인 구현을 얻으려면 std 라이브러리 외부로 이동해야합니다. 좋은 타사 라이브러리 중 하나는 IBM ICU (International Components for Unicode)입니다.
또한 boost :: iequals 는 이러한 종류의 비교를 수행하는 데 매우 유용한 유틸리티를 제공합니다.
Boost.String의 라이브러리 등의 경우-insenstive 비교를하고위한 알고리즘을 많이했다.
당신은 당신 자신을 구현할 수 있지만, 이미 완료되었을 때 왜 귀찮게합니까?
참고로, strcmp()그리고 stricmp()그들이 널 터미네이터를 칠 때까지 그냥 처리하기 때문에, 오버 플로우 버퍼에 취약하다. 그것은 사용하기 더 안전 _strncmp()하고 _strnicmp().
대소 문자를 구분하지 않는 기본 문자열 비교 요구 사항에 대해서는 외부 라이브러리를 사용하지 않고 다른 모든 문자열과 호환되지 않는 대소 문자를 구분하지 않는 별도의 문자열 클래스를 원하지 않습니다.
그래서 내가 생각해 낸 것은 이것입니다.
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와 같은 타사 라이브러리를 사용하면됩니다.
std::equal(str1.begin(), str1.end(), str2.begin(), [](auto a, auto b){return std::tolower(a)==std::tolower(b);})
부스트를 사용할 위치가 아닌 경우 C ++ 14에서 위 코드를 사용할 수 있습니다. std::towlower넓은 문자 에는 사용해야 합니다.
참조 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;
}
짧고 좋은. 확장 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
이미 존재하는 마술 함수가 아닌 방법을 찾고 있다고 가정하면 더 좋은 방법은 없습니다. 제한된 문자 집합에 대한 영리한 트릭을 사용하여 코드 스 니펫을 모두 작성할 수는 있지만 하루가 끝날 때 문자를 변환해야합니다.
이 변환에 가장 적합한 방법은 비교하기 전에 수행하는 것입니다. 이를 통해 실제 비교 연산자를 무시해야하는 인코딩 체계와 관련하여 상당한 유연성을 확보 할 수 있습니다.
물론이 변환을 자신의 문자열 함수 또는 클래스 뒤에 '숨길'수는 있지만 비교하기 전에 문자열을 변환해야합니다.
내장 std :: basic_string 멤버 함수를 사용하여 비교, 검색 등을 수행 할 때 대소 문자를 구분하지 않는 std :: string을 생성하기 위해 std :: basic_string과 함께 사용할 대소 문자를 구분하지 않는 char_traits 버전을 작성했습니다.
다시 말해, 나는 이런 식으로하고 싶었습니다.
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;
부스트를 사용하지 않고 이렇게는로 C 문자열 포인터를 얻어서 수행 할 수 있습니다 c_str()및 사용 strcasecmp:
std::string str1 ="aBcD";
std::string str2 = "AbCd";;
if (strcasecmp(str1.c_str(), str2.c_str()) == 0)
{
//case insensitive equal
}
유니 코드 라이브러리 용 국제 구성 요소를 사용해 본 경험이 있습니다.이 라이브러리 는 매우 강력하며 변환, 로케일 지원, 날짜 및 시간 렌더링, 케이스 맵핑 (원치 않는 것) 및 조합에 대한 메소드를 제공합니다 . 대소 문자를 구분하지 않고 대 / 소문자를 구분하지 않는 비교 등이 포함됩니다. 라이브러리의 C ++ 버전 만 사용했지만 Java 버전도있는 것으로 보입니다.
@Coincoin이 참조하는 정규화 비교를 수행하는 방법이 있으며, 예를 들어 스페인어 (스페인)에서 문자 조합 "ll"은 다음과 같이 정렬됩니다 (예 : 엄격하게 같지 않은 정렬 예). "l"및 "m"이므로 "lz"< "ll"< "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는 동일합니다
a는 b보다 먼저옵니다.
해당 방법 strcmp에 일부 답변에서 제안한 사용 방법이 포함 된 경우 마지막으로 선택한 방법에 대한 참고 사항 :
strcmp일반적으로 유니 코드 데이터에는 작동하지 않습니다. 일반적으로 strcmp바이트 당 바이트 비교 만 수행하고 utf-8로 인코딩 된 유니 코드 코드 포인트는 1 바이트를 초과 할 수 있으므로 utf-8과 같은 바이트 기반 유니 코드 인코딩으로는 작동하지 않습니다 . 유일한 특정 유니 코드의 경우 strcmp다음 바이트 당 바이트 비교가 충분하다 - 제대로 핸들은 바이트 기반 인코딩으로 인코딩 된 문자열 U + 00FF 아래에만 코드 포인트가 포함 된 경우입니다.
2013 년 초 현재 IBM이 유지 관리하는 ICU 프로젝트는 이에 대한 좋은 해답입니다.
ICU는 "업계 표준을 면밀히 추적하는 완벽한 휴대용 유니 코드 라이브러리"입니다. 문자열 비교의 특정 문제에 대해 Collation 객체는 원하는 것을 수행합니다.
Mozilla 프로젝트는 2012 년 중반 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 (빌드 시스템)
파티에 늦었지만 여기에를 사용 std::locale하여 터키어를 올바르게 처리 하는 변형이 있습니다 .
auto tolower = std::bind1st(
std::mem_fun(
&std::ctype<char>::tolower),
&std::use_facet<std::ctype<char> >(
std::locale()));
활성 로케일을 사용하여 문자를 소문자로 변환하는 functor를 제공하며 via std::transform를 사용하여 소문자 문자열을 생성 할 수 있습니다 .
std::string left = "fOo";
transform(left.begin(), left.end(), left.begin(), tolower);
이것은 또한 wchar_t기반 문자열 에서도 작동합니다 .
위의 솔루션은 비교 방법을 사용하지 않고 총계를 다시 구현하지 않는 것처럼 보이므로 여기에 내 솔루션이 있으며 그것이 효과가 있기를 바랍니다.
#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;
}
예를 들어 문자열 벡터가있는 경우 :
std::sort(std::begin(myvector), std::end(myvector), [](std::string const &a, std::string const &b)
{
return std::lexicographical_compare(std::begin(a), std::end(a), std::begin(b), std::end(b), [](std::string::value_type a, std::string::value_type b)
{
return std::tolower(a) < std::tolower(b); //case-insensitive
});
});
소스 문자열을 다른 문자열과 더 자주 비교 해야하는 경우 하나의 우아한 해결책은 정규식을 사용하는 것입니다.
std::wstring first = L"Test";
std::wstring second = L"TEST";
std::wregex pattern(first, std::wregex::icase);
bool isEqual = std::regex_match(second, pattern);
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
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;
}
}
}
이것은 아마도 훨씬 더 효율적으로 이루어질 수 있지만, 여기에는 모든 비트가 베어 진 부피가 큰 버전이 있습니다.
모든 휴대용은 아니지만 내 컴퓨터의 모든 항목과 잘 작동합니다 (아무도, 나는 말이 아닌 그림입니다)
참고 URL : https://stackoverflow.com/questions/11635/case-insensitive-string-comparison-in-c
'Programming' 카테고리의 다른 글
| 파이썬 객체가 문자열인지 확인하는 방법? (0) | 2020.02.26 |
|---|---|
| appcompat-v7 : 21.0.0 ': 주어진 이름과 일치하는 리소스를 찾을 수 없습니다 : attr'android : actionModeShareDrawable ' (0) | 2020.02.26 |
| Python으로 작성된 CSV 파일에는 각 행 사이에 빈 줄이 있습니다. (0) | 2020.02.26 |
| 오리진의 마스터 브랜치 파일 버전으로 되 돌리는 방법 (0) | 2020.02.26 |
| AngularJS UI 라우터 로그인 인증 (0) | 2020.02.26 |