Which tolower in C++?

Given string foo, I've written answers on how to use cctype's tolower to convert the characters to lowercase

transform(cbegin(foo), cend(foo), begin(foo), static_cast<int (*)(int)>(tolower))

But I've begun to consider locale's tolower, which could be used like this:

use_facet<ctype<char>>(cout.getloc()).tolower(data(foo), next(data(foo), foo.size()));
  • Is there a reason to prefer one of these over the other?
  • Does their functionality differ at all?
  • I mean other than the fact that tolower accepts and returns an int which I assume is just some antiquated C stuff?


  • It should be noted that the language designers were aware of cctype's tolower when locale's tolower was created. It improved in 2 primary ways:

    1. As is mentioned in progressive_overload's answer the locale version allowed the use of the facet ctype, even a user modified one, without requiring the shuffling in of a new LC_CTYPE in via setlocale and the restoration of the previous LC_CTYPE
    2. From section[dcl.type.simple]3:

    It is implementation-defined whether objects of char type are represented as signed or unsigned quantities. The signed specifier forces char objects to be signed

    Which creates an the potential for undefined behavior with the cctype version of tolower's if it's argument:

    Is not representable as unsigned char and does not equal EOF

    So there is an additional input and output static_cast required by the cctype version of tolower yielding:

    transform(cbegin(foo), cend(foo), begin(foo), [](const unsigned char i){ return tolower(i); });

    Since the locale version operates directly on chars there is no need for a type conversion.

    So if you don't need to perform the conversion in a different facet ctype it simply becomes a style question of whether you prefer the transform with a lambda required by the cctype version, or whether you prefer the locale version's:

    use_facet<ctype<char>>(cout.getloc()).tolower(data(foo), next(data(foo), size(foo)));