¿Cómo convertir std :: string a minúsculas?

Quiero convertir un std::stringa minúscula. Soy consciente de la función tolower(), sin embargo, en el pasado he tenido problemas con esta función y de todos modos no es lo ideal, ya que usarla con std::stringrequeriría iterar sobre cada carácter.

¿Existe alguna alternativa que funcione el 100% del tiempo?

Adaptado de preguntas no tan frecuentes :

#include <algorithm>
#include <cctype>
#include <string>

std::string data = "Abc";
std::transform(data.begin(), data.end(), data.begin(),
    [](unsigned char c){ return std::tolower(c); });

Realmente no vas a escapar sin recorrer cada personaje. No hay forma de saber si el carácter es minúscula o mayúscula.

Si realmente odias tolower(), aquí hay una alternativa ASCII especializada que no recomiendo que uses:

char asciitolower(char in) {
    if (in <= 'Z' && in >= 'A')
        return in - ('Z' - 'z');
    return in;
}

std::transform(data.begin(), data.end(), data.begin(), asciitolower);

Tenga en cuenta que tolower()solo puede realizar una sustitución por carácter de un solo byte, lo que no es adecuado para muchos scripts, especialmente si se utiliza una codificación de varios bytes como UTF-8.

Boost proporciona un algoritmo de cadena para esto :

#include <boost/algorithm/string.hpp>

std::string str = "HELLO, WORLD!";
boost::algorithm::to_lower(str); // modifies str

O, para no estar en el lugar :

#include <boost/algorithm/string.hpp>

const std::string str = "HELLO, WORLD!";
const std::string lower_str = boost::algorithm::to_lower_copy(str);

tl; dr

Use la biblioteca de la UCI . Si no lo hace, su rutina de conversión se interrumpirá silenciosamente en casos de los que probablemente ni siquiera esté al tanto.

Primero tienes que responder una pregunta: ¿Cuál es la codificación de tu std::string? ¿Es ISO-8859-1? O tal vez ISO-8859-8? ¿O la página de códigos de Windows 1252? ¿Lo que sea que esté usando para convertir mayúsculas a minúsculas lo sabe? (¿O falla miserablemente para los personajes 0x7f?)

Si está utilizando UTF-8 (la única opción sensata entre las codificaciones de 8 bits) std::stringcomo contenedor, ya se está engañando a sí mismo al creer que todavía tiene el control de las cosas, porque está almacenando una secuencia de caracteres multibyte en un contenedor que no conoce el concepto multibyte. Incluso algo tan simple como .substr()una bomba de relojería. (Debido a que dividir una secuencia multibyte dará como resultado una (sub) cadena no válida).

Y tan pronto como intente algo como std::toupper( 'ß' ), en cualquier codificación, estará en serios problemas. (Debido a que simplemente no es posible hacer esto "correctamente" con la biblioteca estándar, que solo puede entregar un carácter de resultado, no el "SS"necesario aquí.) [1] Otro ejemplo sería std::tolower( 'I' ), que debería producir resultados diferentes dependiendo de la configuración regional . En Alemania, 'i'sería correcto; en Turquía, 'ı'(LETRA PEQUEÑA LATINA DOTLESS I) es el resultado esperado (que, nuevamente, es más de un byte en la codificación UTF-8). Otro ejemplo es el Sigma griego , mayúsculas '∑', minúsculas 'σ'... excepto al final de una palabra, donde está 'ς'.

Entonces, cualquier conversión de caso que funcione en un personaje a la vez, o peor, un byte a la vez, se rompe por diseño.

Luego está el punto de que la biblioteca estándar, por lo que es capaz de hacer, depende de qué configuraciones regionales sean compatibles con la máquina en la que se está ejecutando su software ... ¿y qué hace si no lo es?

Entonces, lo que realmente está buscando es una clase de cadena que sea capaz de lidiar con todo esto correctamente, y esa no es ninguna de las std::basic_string<>variantes .

(Nota de C ++ 11: std::u16stringy std::u32stringson mejores , pero aún no son perfectos. C ++ 20 traído std::u8string, pero todo lo que hacen es especificar la codificación. En muchos otros aspectos, siguen ignorando la mecánica Unicode, como la normalización, la clasificación, ... .)

Mientras que Boost se ve bien, API sabia, Boost.Locale es básicamente un contenedor alrededor de la UCI . Si Boost se compila con soporte de ICU ... si no es así, Boost.Locale se limita al soporte de entorno local compilado para la biblioteca estándar.

Y créanme, hacer que Boost compile con UCI puede ser un verdadero dolor a veces. (No hay binarios precompilados para Windows, por lo que tendría que proporcionarlos junto con su aplicación, y eso abre una nueva lata de gusanos ...)

Entonces, personalmente, recomendaría obtener soporte completo de Unicode directamente de la boca del caballo y usar la biblioteca de la UCI directamente:

#include <unicode/unistr.h>
#include <unicode/ustream.h>
#include <unicode/locid.h>

#include <iostream>

int main()
{
    /*                          "Odysseus" */
    char const * someString = u8"ΟΔΥΣΣΕΥΣ";
    icu::UnicodeString someUString( someString, "UTF-8" );
    // Setting the locale explicitly here for completeness.
    // Usually you would use the user-specified system locale,
    // which *does* make a difference (see ı vs. i above).
    std::cout << someUString.toLower( "el_GR" ) << "\n";
    std::cout << someUString.toUpper( "el_GR" ) << "\n";
    return 0;
}

Compilar (con G ++ en este ejemplo):

g++ -Wall example.cpp -licuuc -licuio

Esto da:

ὀδυσσεύς

Tenga en cuenta que la conversión Σ <-> σ en el medio de la palabra, y la conversión Σ <-> ς al final de la palabra. Ninguna <algorithm>solución basada en eso puede darte eso.

[1] En 2017, el Consejo de Ortografía Alemana dictaminó que "ẞ" U + 1E9E LATIN CAPITAL LETTER SHARP S podría usarse oficialmente, como una opción junto a la conversión tradicional "SS" para evitar la ambigüedad, por ejemplo, en pasaportes (donde los nombres están en mayúscula) ) Mi hermoso ejemplo, que quedó obsoleto por decisión del comité ...

Usando el rango para el ciclo de C ++ 11, un código más simple sería:

#include <iostream>       // std::cout
#include <string>         // std::string
#include <locale>         // std::locale, std::tolower

int main ()
{
  std::locale loc;
  std::string str="Test String.\n";

 for(auto elem : str)
    std::cout << std::tolower(elem,loc);
}

Si la cadena contiene caracteres UTF-8 fuera del rango ASCII, entonces boost :: algoritm :: to_lower no los convertirá. Mejor use boost :: locale :: to_lower cuando UTF-8 esté involucrado. Ver http://www.boost.org/doc/libs/1_51_0/libs/locale/doc/html/conversions.html

Este es un seguimiento de la respuesta de Stefan Mai: si desea colocar el resultado de la conversión en otra cadena, debe preasignar su espacio de almacenamiento antes de llamar std::transform. Dado que STL almacena los caracteres transformados en el iterador de destino (incrementándolo en cada iteración del bucle), la cadena de destino no se redimensionará automáticamente y corre el riesgo de pisotear la memoria.

#include <string>
#include <algorithm>
#include <iostream>

int main (int argc, char* argv[])
{
  std::string sourceString = "Abc";
  std::string destinationString;

  // Allocate the destination space
  destinationString.resize(sourceString.size());

  // Convert the source string to lower case
  // storing the result in destination string
  std::transform(sourceString.begin(),
                 sourceString.end(),
                 destinationString.begin(),
                 ::tolower);

  // Output the result of the conversion
  std::cout << sourceString
            << " -> "
            << destinationString
            << std::endl;
}

Otro enfoque que utiliza el rango basado para el bucle con la variable de referencia

string test = "Hello World";
for(auto& c : test)
{
   c = tolower(c);
}

cout<<test<<endl;

Por lo que veo, las bibliotecas de Boost son realmente malas en cuanto al rendimiento. He probado su unordered_map a STL y fue un promedio 3 veces más lento (el mejor caso 2, el peor fue 10 veces). Además, este algoritmo parece demasiado bajo.

La diferencia es tan grande que estoy seguro de que cualquier adición que necesite hacer para tolowerigualar el impulso "para sus necesidades" será mucho más rápido que el impulso.

He realizado estas pruebas en un Amazon EC2, por lo tanto, el rendimiento varió durante la prueba, pero aún se entiende.

./test
Elapsed time: 12365milliseconds
Elapsed time: 1640milliseconds
./test
Elapsed time: 26978milliseconds
Elapsed time: 1646milliseconds
./test
Elapsed time: 6957milliseconds
Elapsed time: 1634milliseconds
./test
Elapsed time: 23177milliseconds
Elapsed time: 2421milliseconds
./test
Elapsed time: 17342milliseconds
Elapsed time: 14132milliseconds
./test
Elapsed time: 7355milliseconds
Elapsed time: 1645milliseconds

-O2 lo hizo así:

./test
Elapsed time: 3769milliseconds
Elapsed time: 565milliseconds
./test
Elapsed time: 3815milliseconds
Elapsed time: 565milliseconds
./test
Elapsed time: 3643milliseconds
Elapsed time: 566milliseconds
./test
Elapsed time: 22018milliseconds
Elapsed time: 566milliseconds
./test
Elapsed time: 3845milliseconds
Elapsed time: 569milliseconds

Fuente:

string str;
bench.start();
for(long long i=0;i<1000000;i++)
{
    str="DSFZKMdskfdsjfsdfJDASFNSDJFXCKVdnjsafnjsdfjdnjasnJDNASFDJDSFSDNJjdsanjfsdnfjJNFSDJFSD";
    boost::algorithm::to_lower(str);
}
bench.end();

bench.start();
for(long long i=0;i<1000000;i++)
{
    str="DSFZKMdskfdsjfsdfJDASFNSDJFXCKVdnjsafnjsdfjdnjasnJDNASFDJDSFSDNJjdsanjfsdnfjJNFSDJFSD";
    for(unsigned short loop=0;loop < str.size();loop++)
    {
        str[loop]=tolower(str[loop]);
    }
}
bench.end();

Supongo que debería hacer las pruebas en una máquina dedicada, pero usaré este EC2, así que realmente no necesito probarlo en mi máquina.

La manera más simple de convertir cadenas en minúsculas sin preocuparse por el espacio de nombres estándar es la siguiente

1: cadena con / sin espacios

#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main(){
    string str;
    getline(cin,str);
//------------function to convert string into lowercase---------------
    transform(str.begin(), str.end(), str.begin(), ::tolower);
//--------------------------------------------------------------------
    cout<<str;
    return 0;
}

2: cadena sin espacios

#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main(){
    string str;
    cin>>str;
//------------function to convert string into lowercase---------------
    transform(str.begin(), str.end(), str.begin(), ::tolower);
//--------------------------------------------------------------------
    cout<<str;
    return 0;
}

std::ctype::tolower()de la biblioteca estándar de localización de C ++ lo hará correctamente por usted. Aquí hay un ejemplo extraído de la página de referencia de tolower

#include <locale>
#include <iostream>

int main () {
  std::locale::global(std::locale("en_US.utf8"));
  std::wcout.imbue(std::locale());
  std::wcout << "In US English UTF-8 locale:\n";
  auto& f = std::use_facet<std::ctype<wchar_t>>(std::locale());
  std::wstring str = L"HELLo, wORLD!";
  std::wcout << "Lowercase form of the string '" << str << "' is ";
  f.tolower(&str[0], &str[0] + str.size());
  std::wcout << "'" << str << "'\n";
}

Una alternativa a Boost es POCO (pocoproject.org).

POCO ofrece dos variantes:

1. La primera variante hace una copia sin alterar la cadena original.
2. La segunda variante cambia la cadena original en su lugar.
   Las versiones "In Place" siempre tienen "InPlace" en el nombre.
   

Ambas versiones se muestran a continuación:

#include "Poco/String.h"
using namespace Poco;

std::string hello("Stack Overflow!");

// Copies "STACK OVERFLOW!" into 'newString' without altering 'hello.'
std::string newString(toUpper(hello));

// Changes newString in-place to read "stack overflow!"
toLowerInPlace(newString);

Hay una manera de convertir mayúsculas a minúsculas SIN hacer pruebas if , y es bastante sencillo. El uso de la función isupper () / macro de clocale.h debería solucionar los problemas relacionados con su ubicación, pero si no, siempre puede modificar la UtoL [] al contenido de su corazón.

Dado que los caracteres de C son solo entradas de 8 bits (ignorando los juegos de caracteres anchos por el momento), puede crear una matriz de 256 bytes que contenga un conjunto alternativo de caracteres, y en la función de conversión use los caracteres en su cadena como subíndices en el matriz de conversión

Sin embargo, en lugar de una asignación 1 por 1, proporcione a los miembros de la matriz en mayúsculas los valores BYTE int para los caracteres en minúsculas. Puede encontrar islower () e isupper () útiles aquí.

El código se ve así ...

#include <clocale>
static char UtoL[256];
// ----------------------------------------------------------------------------
void InitUtoLMap()  {
    for (int i = 0; i < sizeof(UtoL); i++)  {
        if (isupper(i)) {
            UtoL[i] = (char)(i + 32);
        }   else    {
            UtoL[i] = i;
        }
    }
}
// ----------------------------------------------------------------------------
char *LowerStr(char *szMyStr) {
    char *p = szMyStr;
    // do conversion in-place so as not to require a destination buffer
    while (*p) {        // szMyStr must be null-terminated
        *p = UtoL[*p];  
        p++;
    }
    return szMyStr;
}
// ----------------------------------------------------------------------------
int main() {
    time_t start;
    char *Lowered, Upper[128];
    InitUtoLMap();
    strcpy(Upper, "Every GOOD boy does FINE!");

    Lowered = LowerStr(Upper);
    return 0;
}

Este enfoque, al mismo tiempo, le permitirá reasignar cualquier otro personaje que desee cambiar.

Este enfoque tiene una gran ventaja cuando se ejecuta en procesadores modernos, no hay necesidad de hacer predicciones de ramificación ya que no hay pruebas de ramificación. Esto guarda la lógica de predicción de bifurcación de la CPU para otros bucles y tiende a evitar paradas de canalización.

Algunos aquí pueden reconocer este enfoque como el mismo utilizado para convertir EBCDIC a ASCII.

Como ninguna de las respuestas mencionó la próxima biblioteca de Rangos, que está disponible en la biblioteca estándar desde C ++ 20, y actualmente está disponible por separado en GitHub como range-v3, me gustaría agregar una forma de realizar esta conversión usándola.

Para modificar la cadena en el lugar:

str |= action::transform([](unsigned char c){ return std::tolower(c); });

Para generar una nueva cadena:

auto new_string = original_string
    | view::transform([](unsigned char c){ return std::tolower(c); });

(No olvide #include <cctype>y los encabezados de Rangos requeridos).

Nota: el uso de unsigned charcomo argumento para la lambda está inspirado en cppreference , que establece:

Como todas las demás funciones de <cctype>, el comportamiento de std::tolowerno está definido si el valor del argumento no es representable unsigned charni es igual a EOF. Para usar estas funciones de forma segura con chars (o signed chars) sin formato , el argumento primero debe convertirse a unsigned char:

char my_tolower(char ch)
{
    return static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
}

Del mismo modo, no deben usarse directamente con algoritmos estándar cuando el tipo de valor del iterador es charo signed char. En su lugar, convierta el valor a unsigned charprimero:

std::string str_tolower(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), 
                // static_cast<int(*)(int)>(std::tolower)         // wrong
                // [](int c){ return std::tolower(c); }           // wrong
                // [](char c){ return std::tolower(c); }          // wrong
                   [](unsigned char c){ return std::tolower(c); } // correct
                  );
    return s;
}

Mis propias funciones de plantilla que realizan mayúsculas / minúsculas.

#include <string>
#include <algorithm>

//
//  Lowercases string
//
template <typename T>
std::basic_string<T> lowercase(const std::basic_string<T>& s)
{
    std::basic_string<T> s2 = s;
    std::transform(s2.begin(), s2.end(), s2.begin(), tolower);
    return std::move(s2);
}

//
// Uppercases string
//
template <typename T>
std::basic_string<T> uppercase(const std::basic_string<T>& s)
{
    std::basic_string<T> s2 = s;
    std::transform(s2.begin(), s2.end(), s2.begin(), toupper);
    return std::move(s2);
}

Aquí hay una técnica de macro si quieres algo simple:

#define STRTOLOWER(x) std::transform (x.begin(), x.end(), x.begin(), ::tolower)
#define STRTOUPPER(x) std::transform (x.begin(), x.end(), x.begin(), ::toupper)
#define STRTOUCFIRST(x) std::transform (x.begin(), x.begin()+1, x.begin(),  ::toupper); std::transform (x.begin()+1, x.end(),   x.begin()+1,::tolower)

Sin embargo, tenga en cuenta que el comentario de @ AndreasSpindler sobre esta respuesta sigue siendo una consideración importante, sin embargo, si está trabajando en algo que no son solo caracteres ASCII.

// tolower example (C++)
#include <iostream>       // std::cout
#include <string>         // std::string
#include <locale>         // std::locale, std::tolower

int main ()
{
  std::locale loc;
  std::string str="Test String.\n";
  for (std::string::size_type i=0; i<str.length(); ++i)
    std::cout << std::tolower(str[i],loc);
  return 0;
}

Para más información: http://www.cplusplus.com/reference/locale/tolower/

¿Existe alguna alternativa que funcione el 100% del tiempo?

No

Hay varias preguntas que debe hacerse antes de elegir un método en minúsculas.

1. ¿Cómo se codifica la cadena? ASCII simple? UTF-8? alguna forma de codificación heredada ASCII extendida?
2. ¿Qué quieres decir con minúscula de todos modos? ¡Las reglas de mapeo de casos varían entre idiomas! ¿Desea algo que esté localizado en la configuración regional de los usuarios? ¿Desea algo que se comporte de manera consistente en todos los sistemas en los que se ejecuta su software? ¿Solo quieres minúsculas caracteres ASCII y pasar por todo lo demás?
3. ¿Qué bibliotecas hay disponibles?

Una vez que tenga respuestas a esas preguntas, puede comenzar a buscar una solución que se adapte a sus necesidades. ¡No hay una talla única que funcione para todos en todas partes!

Prueba esta función :)

string toLowerCase(string str) {
    int str_len = str.length();
    string final_str = "";
    for(int i=0; i<str_len; i++) {
        char character = str[i];
        if(character>=65 && character<=92) {
            final_str += (character+32);
        } else {
            final_str += character;
        }
    }
    return final_str;
}

En las plataformas de Microsoft puede usar la strlwrfamilia de funciones: http://msdn.microsoft.com/en-us/library/hkxwh33z.aspx

// crt_strlwr.c
// compile with: /W3
// This program uses _strlwr and _strupr to create
// uppercase and lowercase copies of a mixed-case string.
#include <string.h>
#include <stdio.h>

int main( void )
{
   char string[100] = "The String to End All Strings!";
   char * copy1 = _strdup( string ); // make two copies
   char * copy2 = _strdup( string );

   _strlwr( copy1 ); // C4996
   _strupr( copy2 ); // C4996

   printf( "Mixed: %s\n", string );
   printf( "Lower: %s\n", copy1 );
   printf( "Upper: %s\n", copy2 );

   free( copy1 );
   free( copy2 );
}

Fragmento de código

#include<bits/stdc++.h>
using namespace std;


int main ()
{
    ios::sync_with_stdio(false);

    string str="String Convert\n";

    for(int i=0; i<str.size(); i++)
    {
      str[i] = tolower(str[i]);
    }
    cout<<str<<endl;

    return 0;
}

Use fplus :: to_lower_case ().

(fplus: https://github.com/Dobiasd/FunctionalPlus .

Busque 'to_lower_case' en http://www.editgym.com/fplus-api-search/ )

fplus::to_lower_case(std::string("ABC")) == std::string("abc");

Copie porque no se permitió mejorar la respuesta. Gracias

string test = "Hello World";
for(auto& c : test)
{
   c = tolower(c);
}

Explicación:

for(auto& c : test)es un bucle basado en rango del tipo :
for (range_declaration:range_expression)loop_statement

1. range_declaration: auto& c
   Aquí se utiliza el especificador automático para la deducción automática de tipo. Entonces el tipo se deduce del inicializador de variables.

2. range_expression: test
   El rango en este caso son los caracteres de la cadena test.

Los caracteres de la cadena testestán disponibles como referencia dentro del identificador de bucle for c.

C ++ no tiene implementados los métodos tolower o toupper para string, pero está disponible para char. Uno puede leer fácilmente cada carácter de cadena, convertirlo en el caso requerido y volver a colocarlo en cadena. Un código de muestra sin usar ninguna biblioteca de terceros:

#include<iostream>

int main(){
  std::string str = std::string("How IS The Josh");
  for(char &ch : str){
    ch = std::tolower(ch);
  }
  std::cout<<str<<std::endl;
  return 0;
}

Para operación basada en caracteres en cadena: para cada carácter en cadena

Esta podría ser otra versión simple para convertir mayúsculas a minúsculas y viceversa. Usé la versión de comunidad VS2017 para compilar este código fuente.

#include <iostream>
#include <string>
using namespace std;

int main()
{
    std::string _input = "lowercasetouppercase";
#if 0
    // My idea is to use the ascii value to convert
    char upperA = 'A';
    char lowerA = 'a';

    cout << (int)upperA << endl; // ASCII value of 'A' -> 65
    cout << (int)lowerA << endl; // ASCII value of 'a' -> 97
    // 97-65 = 32; // Difference of ASCII value of upper and lower a
#endif // 0

    cout << "Input String = " << _input.c_str() << endl;
    for (int i = 0; i < _input.length(); ++i)
    {
        _input[i] -= 32; // To convert lower to upper
#if 0
        _input[i] += 32; // To convert upper to lower
#endif // 0
    }
    cout << "Output String = " << _input.c_str() << endl;

    return 0;
}

Nota: si hay caracteres especiales, entonces deben manejarse utilizando la verificación de condición.

Intenté std :: transform, todo lo que obtengo es un error abominable de compilación stl criptic que solo los druidas de hace 200 años pueden entender (no se puede convertir en gripe flibidi flabidi)

esto funciona bien y se puede ajustar fácilmente

string LowerCase(string s)
{
    int dif='a'-'A';
    for(int i=0;i<s.length();i++)
    {
        if((s[i]>='A')&&(s[i]<='Z'))
            s[i]+=dif;
    }
   return s;
}

string UpperCase(string s)
{
   int dif='a'-'A';
    for(int i=0;i<s.length();i++)
    {
        if((s[i]>='a')&&(s[i]<='z'))
            s[i]-=dif;
    }
   return s;
}