Come convertire std :: string in lettere minuscole?

Voglio convertire un std::stringin minuscolo. Sono a conoscenza della funzione tolower(), tuttavia in passato ho avuto problemi con questa funzione e non è certo l'ideale in quanto l'uso con un std::stringrichiede l'iterazione su ogni personaggio.

Esiste un'alternativa che funziona il 100% delle volte?

Adattato da domande non così frequenti :

#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); });

Non riuscirai davvero a scappare senza ripetere ogni personaggio. Non c'è modo di sapere se il personaggio è minuscolo o maiuscolo altrimenti.

Se davvero odi tolower(), ecco un'alternativa specializzata solo per ASCII che non ti consiglio di usare:

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

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

Tenere presente che è tolower()possibile eseguire solo una sostituzione per singolo byte di caratteri, che non è adatta per molti script, soprattutto se si utilizza una codifica multibyte come UTF-8.

Boost fornisce un algoritmo di stringa per questo :

#include <boost/algorithm/string.hpp>

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

Oppure, per non sul posto :

#include <boost/algorithm/string.hpp>

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

tl; dr

Utilizzare la libreria ICU . In caso contrario, la routine di conversione si interromperà silenziosamente in casi che probabilmente non si conoscono.

Per prima cosa devi rispondere a una domanda: qual è la tua codificastd::string ? È ISO-8859-1? O forse ISO-8859-8? O Windows Codepage 1252? Qualunque cosa tu stia usando per convertire maiuscole in minuscole lo sa? (O fallisce miseramente per i personaggi finiti 0x7f?)

Se stai usando UTF-8 (l'unica scelta sana tra le codifiche a 8 bit) con std::stringcome contenitore, stai già ingannando te stesso nel credere di avere ancora il controllo delle cose, perché stai memorizzando una sequenza di caratteri multibyte in un contenitore che non è a conoscenza del concetto multibyte. Anche qualcosa di semplice come .substr()una bomba a orologeria. (Perché la divisione di una sequenza multibyte comporterà una stringa (sotto) non valida.)

E non appena provi qualcosa del genere std::toupper( 'ß' ), in qualsiasi codifica, sei in guai seri. (Perché semplicemente non è possibile fare questo "giusto" con la libreria standard, che può fornire solo un carattere risultato, non il "SS"necessario qui.) [1] Un altro esempio potrebbe essere std::tolower( 'I' ), che dovrebbe produrre risultati diversi a seconda delle impostazioni locali . In Germania, 'i'sarebbe corretto; in Turchia, 'ı'(LATIN SMALL LOTTER DOTLESS I) è il risultato atteso (che, di nuovo, è più di un byte nella codifica UTF-8). Ancora un altro esempio è il greco Sigma , maiuscolo '∑', minuscolo 'σ'... tranne alla fine di una parola, dove si trova 'ς'.

Pertanto, qualsiasi conversione di caso che funziona su un personaggio alla volta, o peggio, su un byte alla volta, viene interrotta in base alla progettazione.

Quindi c'è il punto che la libreria standard, per quello che è in grado di fare, dipende da quali impostazioni locali sono supportate sulla macchina su cui è in esecuzione il software ... e cosa fai se non lo è?

Quindi quello che stai veramente cercando è una classe di stringhe in grado di gestire correttamente tutto ciò e che non sia una delle std::basic_string<>varianti .

(Nota C ++ 11: std::u16stringe std::u32stringsono migliori , ma ancora non perfetti. C ++ 20 ha portato std::u8string, ma tutto ciò che fa è specificare la codifica. Per molti altri aspetti rimangono ancora ignoranti della meccanica Unicode, come la normalizzazione, le regole di confronto, .. .)

Mentre Boost sembra bello, per quanto riguarda le API, Boost.Locale è fondamentalmente un wrapper per ICU . Se Boost è compilato con il supporto ICU ... in caso contrario, Boost.Locale è limitato al supporto locale compilato per la libreria standard.

E mi creda, ottenendo Boost di compilare con terapia intensiva può essere un vero e proprio dolore a volte. (Non ci sono file binari precompilati per Windows, quindi dovresti fornirli insieme alla tua applicazione e questo aprirà una nuova lattina di worm ...)

Quindi personalmente consiglierei di ottenere il pieno supporto Unicode direttamente dalla bocca del cavallo e di usare direttamente la libreria ICU :

#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;
}

Compila (con G ++ in questo esempio):

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

Questo da:

ὀδυσσεύς

Nota che la conversione Σ <-> σ nel mezzo della parola e la conversione Σ <-> ς alla fine della parola. Nessuna <algorithm>soluzione di base può darti questo.

[1] Nel 2017, il Consiglio per l'ortografia tedesca ha stabilito che "ẞ" U + 1E9E LATTER CAPITAL LARTER SHARP S potrebbe essere utilizzato ufficialmente, come opzione accanto alla tradizionale conversione "SS" per evitare ambiguità, ad esempio nei passaporti (in cui i nomi sono scritti in maiuscolo ). Il mio bellissimo esempio, reso obsoleto dalla decisione della commissione ...

Utilizzando range-based per loop di C ++ 11 un codice più semplice sarebbe:

#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);
}

Se la stringa contiene caratteri UTF-8 al di fuori dell'intervallo ASCII, allora boost :: algoritmo :: to_lower non li convertirà. Meglio usare boost :: locale :: to_lower quando è coinvolto UTF-8. Vedi http://www.boost.org/doc/libs/1_51_0/libs/locale/doc/html/conversions.html

Questo è un seguito alla risposta di Stefan Mai: se si desidera posizionare il risultato della conversione in un'altra stringa, è necessario pre-allocare il suo spazio di archiviazione prima di chiamare std::transform. Poiché STL memorizza i caratteri trasformati nell'iteratore di destinazione (incrementandolo ad ogni iterazione del ciclo), la stringa di destinazione non verrà ridimensionata automaticamente e si rischia il calpestamento della 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;
}

Un altro approccio che utilizza range basato su loop con variabile di riferimento

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

cout<<test<<endl;

Per quanto vedo le librerie Boost sono davvero pessime dal punto di vista delle prestazioni. Ho testato il loro unordered_map su STL ed è stato in media 3 volte più lento (nel migliore dei casi 2, il peggio è stato di 10 volte). Anche questo algoritmo sembra troppo basso.

La differenza è così grande che sono sicuro che qualunque aggiunta tu debba fare tolowerper renderlo uguale a potenziare "per le tue esigenze" sarà molto più veloce di potenziare.

Ho eseguito questi test su un Amazon EC2, quindi le prestazioni sono state diverse durante il test, ma hai comunque avuto l'idea.

./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 reso così:

./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

Fonte:

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();

Immagino che dovrei fare i test su una macchina dedicata, ma userò questo EC2, quindi non ho davvero bisogno di testarlo sulla mia macchina.

Il modo più semplice per convertire la stringa in minuscolo senza preoccuparsi dello spazio dei nomi standard è il seguente

1: stringa con / senza spazi

#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: stringa senza spazi

#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()dalla libreria di localizzazione C ++ standard lo farà correttamente per te. Ecco un esempio estratto dalla pagina di riferimento 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";
}

Un'alternativa a Boost è POCO (pocoproject.org).

POCO offre due varianti:

1. La prima variante crea una copia senza alterare la stringa originale.
2. La seconda variante modifica la stringa originale in posizione.
   Le versioni "In Place" hanno sempre "InPlace" nel nome.
   

Entrambe le versioni sono illustrate di seguito:

#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);

C'è un modo per convertire maiuscole in minuscole SENZA eseguire test ed è piuttosto semplice. L'uso della funzione / macro di clocale.h da parte della funzione isupper () dovrebbe occuparsi dei problemi relativi alla tua posizione, ma in caso contrario, puoi sempre modificare l'UtoL [] in base al contenuto del tuo cuore.

Dato che i caratteri di C sono in realtà solo in 8 bit (ignorando per ora i set di caratteri di grandi dimensioni) è possibile creare un array di 256 byte contenente un set di caratteri alternativo e nella funzione di conversione utilizzare i caratteri nella stringa come pedice nel array di conversione.

Invece di un mapping 1-per-1, tuttavia, assegnare ai membri dell'array maiuscoli i valori int BYTE per i caratteri minuscoli. Puoi trovare islower () e isupper () utili qui.

Il codice è simile al seguente ...

#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;
}

Questo approccio, allo stesso tempo, ti permetterà di rimappare qualsiasi altro personaggio che desideri cambiare.

Questo approccio ha un enorme vantaggio quando si esegue su processori moderni, non è necessario eseguire la previsione di diramazione in quanto non esistono test per la ramificazione. Ciò consente di risparmiare la logica di predizione della diramazione della CPU per altri loop e tende a prevenire blocchi della pipeline.

Alcuni qui potrebbero riconoscere questo approccio come lo stesso usato per convertire EBCDIC in ASCII.

Dal momento che nessuna delle risposte menzionava la prossima libreria Ranges, che è disponibile nella libreria standard dal C ++ 20 e attualmente disponibile separatamente su GitHub come range-v3, vorrei aggiungere un modo per eseguire questa conversione utilizzandola.

Per modificare la stringa sul posto:

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

Per generare una nuova stringa:

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

(Non dimenticare di #include <cctype>e le intestazioni Ranges richieste.)

Nota: l'uso di unsigned charcome argomento per la lambda è ispirato da cppreference , che afferma:

Come tutte le altre funzioni di <cctype>, il comportamento di std::tolowernon è definito se il valore dell'argomento non è né rappresentabile unsigned charné uguale EOF. Per usare queste funzioni in modo sicuro con semplici chars (o signed chars), l'argomento dovrebbe prima essere convertito in unsigned char:

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

Allo stesso modo, non dovrebbero essere usati direttamente con algoritmi standard quando il tipo di valore dell'iteratore è charo signed char. Invece, converti il ​​valore in unsigned charprimo:

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;
}

Le mie funzioni di template che eseguono maiuscole / minuscole.

#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);
}

Ecco una tecnica macro se vuoi qualcosa di semplice:

#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)

Tuttavia, nota che il commento di @ AndreasSpindler su questa risposta è ancora una considerazione importante, tuttavia, se stai lavorando su qualcosa che non è solo caratteri 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;
}

Per maggiori informazioni: http://www.cplusplus.com/reference/locale/tolower/

Esiste un'alternativa che funziona il 100% delle volte?

No

Esistono diverse domande che è necessario porsi prima di scegliere un metodo di lettere minuscole.

1. Come viene codificata la stringa? semplice ASCII? UTF-8? qualche forma di codifica legacy ASCII estesa?
2. Cosa intendi con minuscolo comunque? Le regole di mappatura dei casi variano tra le lingue! Vuoi qualcosa che sia localizzato nelle impostazioni locali degli utenti? vuoi qualcosa che si comporti in modo coerente su tutti i sistemi su cui gira il tuo software? Vuoi solo minuscoli caratteri ASCII e passare attraverso tutto il resto?
3. Quali librerie sono disponibili?

Una volta che hai le risposte a queste domande, puoi iniziare a cercare una soluzione adatta alle tue esigenze. Non esiste una taglia unica che vada bene per tutti ovunque!

Prova questa funzione :)

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;
}

Su piattaforme Microsoft puoi utilizzare la strlwrfamiglia di funzioni: 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 );
}

Snippet di codice

#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;
}

Usa fplus :: to_lower_case ().

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

Cerca 'to_lower_case' in http://www.editgym.com/fplus-api-search/ )

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

Copia perché non è stato consentito per migliorare la risposta. Grazie mille

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

Spiegazione:

for(auto& c : test)è un range-based per loop del tipo :
for (range_declaration:range_expression)loop_statement

1. range_declaration: auto& c
   Qui l' identificatore automatico viene utilizzato per la detrazione automatica del tipo. Quindi il tipo viene dedotto dall'inizializzatore delle variabili.

2. range_expression: test
   L'intervallo in questo caso sono i caratteri della stringa test.

I caratteri della stringa testsono disponibili come riferimento all'interno dell'identificatore del ciclo for c.

C ++ non ha implementato metodi tolower o toupper per stringa, ma è disponibile per char. Si può facilmente leggere ogni carattere di stringa, convertirlo nel caso richiesto e rimetterlo in stringa. Un codice di esempio senza utilizzare alcuna libreria di terze parti:

#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;
}

Per operazioni basate sui caratteri su stringa: per ogni carattere nella stringa

Questa potrebbe essere un'altra versione semplice per convertire maiuscole in minuscole e viceversa. Ho usato la versione della community VS2017 per compilare questo codice sorgente.

#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: se sono presenti caratteri speciali, è necessario gestirli mediante il controllo delle condizioni.

Ho provato std :: transform, tutto quello che ottengo è un abominevole errore di compilazione criptic stl che solo i druidi di 200 anni fa possono capire (non riesco a convertire da influenza di flabidi ai flibidi)

funziona benissimo e può essere facilmente modificato

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;
}