tolower used by transform

[qazmlp]

I was using the following code to convert the string to
lowercase.

string foo = "Some Mixed Case Text";
transform(foo.b egin(), foo.end(), foo.begin(), tolower);

I thought the above code is portable.

But, the following page has a different view on this:

http://lists.debian.org/debian-gcc/2002/debian-gcc-200204/msg00092.html

Can anybody comment on it ?
Also, I would like to know whether tolower template or function will be used
in the above code.
transform(foo.b egin(), foo.end(), foo.begin(), tolower);

[Sergei Matusevich]

Re: tolower used by transform

qazmlp1209@redi ffmail.com (qazmlp) wrote in message news:<db9bbf31. 0307220630.5fbf d142@posting.go ogle.com>...
[color=blue]
> string foo = "Some Mixed Case Text";
> transform(foo.b egin(), foo.end(), foo.begin(), tolower);
>
> I thought the above code is portable.
>
> But, the following page has a different view on this:
> http://lists.debian.org/debian-gcc/2.../msg00092.html[/color]

Well that's a damn good question!

The problem is that most implementations of the standard C <ctype.h>
header define functions like toupper/tolower/etc as macros. To make it
work in STL algorithms, you have to include <cctype> header instead of
<ctype.h>. At least on my PC (Debian/gcc 3.3), <cctype> undefines all
tolower/etc macros and pulls ::tolower/::toupper/etc functions into
std namespace, so that your sample will work fine.

However, in general it is recommended to drop old C functions in favor
of new standard library functionality. In this particular case, you
may want use the ctype locale facet, i.e.

#include <locale>

// ..............

std::locale loc;
char s[] = "Test String";
std::use_facet< std::ctype<char > >( loc ).tolower( s, s + sizeof(s)
);

Too bad it does not work for std::string, i.e the following code will
not compile:

std::locale loc;
string s = "Test String";
std::use_facet< std::ctype<char > >( loc ).tolower( s.begin(),
s.end() );

because std::ctype::tol ower() definition has only two variants:

char_type tolower(char_ty pe __c) const;
const char_type* tolower(char_ty pe* __lo, const char_type* __hi)
const;

This leads me to the following piece of code:

std::transform( s.begin(), s.end(), s.begin(),
std::bind1st( std::mem_fun( &std::ctype<cha r>::tolower ),
&std::use_facet < std::ctype<char > >( loc ) ) );

Nice, eh? :-)

Now it's truly C++, but I am not sure if I want to use such thing
instead of good old tolower() from <cctype>. Can anyone suggest a
better solution?

PS. <locale> header also defines a standalone std::tolower() function
that takes locale as a second parameter, but I don't know if it can be
used in transform, because it is a template/inline function, i.e.
std::bind2nd and std::ptr_fun do not work with it.

PPS. It would be REALLY great to hear other opinions on this subject!

Thanks,
Sergei.

--
Sergei Matusevich,
Brainbench MVP for C++

http://www.brainbench.com

[tom_usenet]

Re: tolower used by transform

On 22 Jul 2003 19:01:15 -0700, motus2@yahoo.co m (Sergei Matusevich)
wrote:
[color=blue]
>qazmlp1209@red iffmail.com (qazmlp) wrote in message news:<db9bbf31. 0307220630.5fbf d142@posting.go ogle.com>...
>[color=green]
>> string foo = "Some Mixed Case Text";
>> transform(foo.b egin(), foo.end(), foo.begin(), tolower);
>>
>> I thought the above code is portable.
>>
>> But, the following page has a different view on this:
>> http://lists.debian.org/debian-gcc/2.../msg00092.html[/color]
>
>Well that's a damn good question!
>
>The problem is that most implementations of the standard C <ctype.h>
>header define functions like toupper/tolower/etc as macros. To make it
>work in STL algorithms, you have to include <cctype> header instead of
><ctype.h>. At least on my PC (Debian/gcc 3.3), <cctype> undefines all
>tolower/etc macros and pulls ::tolower/::toupper/etc functions into
>std namespace, so that your sample will work fine.[/color]

I'm not sure a conforming C++ implementation can have macro versions
of the ctype.h headers. Most versions I have seen have #ifdef __cpp__
or similar, using inline functions for the C++ version and macros for
the C one.
[color=blue]
>However, in general it is recommended to drop old C functions in favor
>of new standard library functionality. In this particular case, you
>may want use the ctype locale facet, i.e.
>
> #include <locale>
>
> // ..............
>
> std::locale loc;
> char s[] = "Test String";
> std::use_facet< std::ctype<char > >( loc ).tolower( s, s + sizeof(s)
>);
>
>Too bad it does not work for std::string, i.e the following code will
>not compile:
>
> std::locale loc;
> string s = "Test String";
> std::use_facet< std::ctype<char > >( loc ).tolower( s.begin(),
>s.end() );
>
>because std::ctype::tol ower() definition has only two variants:
>
> char_type tolower(char_ty pe __c) const;
> const char_type* tolower(char_ty pe* __lo, const char_type* __hi)
>const;
>
>This leads me to the following piece of code:
>
> std::transform( s.begin(), s.end(), s.begin(),
> std::bind1st( std::mem_fun( &std::ctype<cha r>::tolower ),
> &std::use_facet < std::ctype<char > >( loc ) ) );
>
>Nice, eh? :-)[/color]

tolower is overloaded so you can't take its address as you are trying
above, since you don't say which overload you want. You'd need
something like:

static_cast<cha r(std::ctype<ch ar>::*)(char) const>(
&std::ctype<cha r>::tolower)
[color=blue]
>
>Now it's truly C++, but I am not sure if I want to use such thing
>instead of good old tolower() from <cctype>. Can anyone suggest a
>better solution?[/color]

Converting a string to lower case can involve changing the length of
the string in some languages, and a general solution is going to be
quite complicated and involve complex heuristics. In english though,
in place modification is of course possible, and it is best to just
write a couple of functions that operate on strings. There are various
implementation possibilities, the simplest being an explicit loop.
[color=blue]
>PS. <locale> header also defines a standalone std::tolower() function
>that takes locale as a second parameter, but I don't know if it can be
>used in transform, because it is a template/inline function, i.e.
>std::bind2nd and std::ptr_fun do not work with it.[/color]

Just because it is template and inline doesn't mean bind2nd won't work
(you just need to cast to choose the correct instantiation). However,
because it takes the locale argument by reference, it won't work since
bind2nd will attempt to form a reference to reference argument, which
is currently illegal.

Tom

[Sergei Matusevich]

Re: tolower used by transform

Thank you Tom for a great posting!

tom_usenet@hotm ail.com (tom_usenet) wrote in message news:<3f1e4bf1. 85479812@news.e asynet.co.uk>.. .
[color=blue][color=green][color=darkred]
> >> string foo = "Some Mixed Case Text";
> >> transform(foo.b egin(), foo.end(), foo.begin(), tolower);[/color][/color][/color]

[...]
[color=blue][color=green]
> > std::transform( s.begin(), s.end(), s.begin(),
> > std::bind1st( std::mem_fun( &std::ctype<cha r>::tolower ),
> > &std::use_facet < std::ctype<char > >( loc ) ) );[/color][/color]
[color=blue]
> tolower is overloaded so you can't take its address as you are trying
> above, since you don't say which overload you want. You'd need
> something like:
>
> static_cast<cha r(std::ctype<ch ar>::*)(char) const>(
> &std::ctype<cha r>::tolower)[/color]

Not sure about other implementations of the standard library, but in
my gcc 3.3.1 tolower is non-virtual and it delegates all functionality
to the protected virtual do_tolower method. Therefore, taking address
of the tolower method is absolutely OK, I'm just not sure about its
portability [now after your posting :))].

[...]
[color=blue]
> Converting a string to lower case can involve changing the length of
> the string in some languages, and a general solution is going to be
> quite complicated and involve complex heuristics. In english though,
> in place modification is of course possible, and it is best to just
> write a couple of functions that operate on strings. There are various
> implementation possibilities, the simplest being an explicit loop.[/color]

Good point! But then, as far as I understand, tolower from the
standard library is not a general solution because it's an "one char
in - one char out" implementation. From the other hand, I don't know
any locales that may require such a sophisticated case conversion
procedures.. :)

But the question remains open - what is the best (generic and
portable) way to do toupper/tolower conversion for an std::string (or
std::wstring or any std::basic_stri ng incarnation) in C++? Is there
any? :))

Thank you,
Sergei.

--
Sergei Matusevich,
Brainbench MVP for C++

http://www.brainbench.com