By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
446,231 Members | 1,333 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 446,231 IT Pros & Developers. It's quick & easy.

Lowercase std::string compare?

P: n/a
Is there any builtin lowercase std::string compare? Right now I'm doing
this:

if ( _stricmp( AmmoTypeText.c_str(), "GunBullet" ) == 0 )
AmmoType = Item_Ammo_GunBullet;

Is there anything the standard library to do this? I'm not interested in
Boost until it becomes part of the standard.
May 11 '06 #1
Share this Question
Share on Google+
4 Replies


P: n/a

Jim Langston wrote:
Is there any builtin lowercase std::string compare? Right now I'm doing
this:

if ( _stricmp( AmmoTypeText.c_str(), "GunBullet" ) == 0 )
AmmoType = Item_Ammo_GunBullet;

Is there anything the standard library to do this? I'm not interested in
Boost until it becomes part of the standard.


I usually do it like:

string tmp = strToCompare;
transform(tmp.begin(), tmp.end(), tolower);
if(tmp == "gunbullet")
{
//more codes...
}

Which I agree is probably not the most efficient solution. I'd be happy
to know how I can improve that.

May 11 '06 #2

P: n/a
Jim Langston wrote:
Is there any builtin lowercase std::string compare? Right now I'm doing
this:

if ( _stricmp( AmmoTypeText.c_str(), "GunBullet" ) == 0 )
AmmoType = Item_Ammo_GunBullet;

Is there anything the standard library to do this? I'm not interested in
Boost until it becomes part of the standard.


Unfortunately, std::string lacks case insensitive compare.
Case-insensitive operations are locale dependant, and therefore require
a more complex functionality then the one described above.See:

http://www.gotw.ca/gotw/029.htm and
http://gcc.gnu.org/onlinedocs/libstd...ngs/howto.html

Assuming you limit yourself to single-byte (char) ASCII characters and
you don't change LOCALE settings, _stricmp is fine. If you do need
locale depend functions, take a look at the Strinx library:

http://strinx.sourceforge.net/strinx...ith-std-locale
which provides a set of locale-dependant functions for strings.

Good luck,
SS.

May 11 '06 #3

P: n/a

shablool wrote:
Unfortunately, std::string lacks case insensitive compare.
Case-insensitive operations are locale dependant, and therefore require
a more complex functionality then the one described above.See:


Actually it's the char_traits that performs the comparison, not the
std::basic_string class.

You can use a specific char_traits in your strings to do such
comparisons.

transforming the whole string looks wrong algorithmically, as it means
you have "worst case scenario" on every string, i.e. the slowest result
of the comparison is either when the strings match or they differ on
the last character, in which case you need N comparisons, but a lot of
the time the comparison will fail on the first character. By
transforming the entire string to lowercase (or uppercase) your
algorithm will be O(N) every time (well you will be performing an
action on every character).

It would be therefore better to provide a single-character comparison
and use that.

I would like to see a case-insensitive comparison function in <locale>
which is where I think it belongs. There isn't one, although you can
write one based on the toupper that lives in locale. You can do it
based on single-character comparison (call the locale toupper or
tolower on both and compare them) and then you can do another one for a
sequence (std::compare with your predicate).

Difficult to know what header it should be in - it is both an algorithm
and locale based. You wouldn't want to put it in <algortihm> because it
has then has a dependency on <locale>. You could do it the other way if
you rewrite the compare and not use std::compare. The other alternative
would be to give it its own header so you only include what you use.

May 11 '06 #4

P: n/a
Relying on char_traits to implement a case insensitive string is wrong.
See: http://lafstern.org/matt/col2_new.pdf

Here is an implementation (from the Strinx library) which uses
std::locale, but not char_traits (although there is an assumption that
there exists operator== for CharT, which is obviously true for built-in
types char and wchar_t):

#include <locale>

// Case-insensitive compare of the first n characters of s1 and s2,
// using std::locale.
// Note: s1 and s2 are not necessarily null terminated strings.
template <typename CharT>
int icompare(const CharT* s1, const CharT* s2, size_type n, const
std::locale& loc)
{
const std::ctype<CharT>& facet = std::use_facet<std::ctype<CharT>
(loc);

const CharT* end = s1+n;
for (const CharT *p = s1, *q = s2; p != end; ++p, ++q)
{
const CharT c1 = *p;
const CharT c2 = *q;
if ( !(c1 == c2) && !(facet.toupper(c1) == facet.toupper(c2)) )
{
return (int(c1 < c2) - int(c2 < c1));
}
}
return 0;
}

May 11 '06 #5

This discussion thread is closed

Replies have been disabled for this discussion.