Jak przekonwertować std :: string na małe litery?

Chcę przekonwertować std::stringna małe litery. Zdaję sobie sprawę z tej funkcji tolower(), jednak w przeszłości miałem problemy z tą funkcją i nie jest ona idealna, ponieważ używa się jej zstd::string wymagałoby iteracji nad każdą postacią.

Czy istnieje alternatywa, która działa w 100% przypadków?

Na podstawie niezbyt często zadawanych pytań :

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

Naprawdę nie uciekniesz bez iteracji po każdej postaci. Nie ma sposobu, aby dowiedzieć się, czy postać jest pisana małymi lub dużymi literami.

Jeśli naprawdę nie cierpisz tolower(), oto specjalistyczna alternatywa tylko dla ASCII, której nie polecam używać:

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

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

Należy pamiętać, że tolower()może to zrobić tylko substytucja na jeden bajt, co jest niewłaściwe dla wielu skryptów, zwłaszcza jeśli używa się kodowania wielobajtowego, takiego jak UTF-8.

Zwiększenie zapewnia algorytm łańcuchowy do tego :

#include <boost/algorithm/string.hpp>

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

Lub w przypadku braku miejsca :

#include <boost/algorithm/string.hpp>

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

tl; dr

Użyj biblioteki ICU . Jeśli tego nie zrobisz, procedura konwersji po cichu załamie się na przypadkach, o których prawdopodobnie nawet nie wiesz.

Najpierw musisz odpowiedzieć na pytanie: jakie jest twoje kodowaniestd::string ? Czy to jest ISO-8859-1? A może ISO-8859-8? Lub Windows Codepage 1252? Czy to, czego używasz do konwersji wielkich i małych liter, wie o tym? (A może źle to kończy się w przypadku postaci 0x7f?)

Jeśli używasz UTF-8 (jedyny rozsądny wybór wśród kodowań 8-bitowych) z std::stringjako kontenerem, już oszukujesz siebie, aby uwierzyć, że nadal kontrolujesz rzeczy, ponieważ przechowujesz wielobajtową sekwencję znaków w kontenerze który nie zna koncepcji wielobajtowej. Nawet coś tak prostego jak .substr()tykająca kula czasowa. (Ponieważ podział sekwencji wielobajtowej spowoduje niepoprawny (pod-) ciąg znaków.)

I gdy tylko spróbujesz czegoś takiego std::toupper( 'ß' ), w jakimkolwiek kodowaniu, będziesz miał poważne kłopoty. (Ponieważ po prostu nie jest możliwe zrobienie tego „dobrze” ze standardową biblioteką, która może dostarczyć tylko jeden znak wyniku, a nie "SS"tutaj potrzebny.) [1] Innym przykładem byłby std::tolower( 'I' )inny wynik, w zależności od ustawień regionalnych . W Niemczech 'i'byłoby poprawne; w Turcji 'ı'(LATIN SMALL LETTER DOTLESS I) to oczekiwany wynik (który w kodowaniu UTF-8 to więcej niż jeden bajt). Jeszcze innym przykładem jest język grecki Sigma , wielkie litery '∑', małe litery 'σ'... z wyjątkiem końca słowa, gdzie jest 'ς'.

Więc, każda konwersja przypadku, która działa na znak na raz lub, co gorsza, bajt na raz, jest zepsuta przez projekt.

To jest sens, że standardowa biblioteka, po co to , zależnie od obsługiwanych ustawień narodowych, zależy od jest w stanie zrobić na komputerze, na którym działa twoje oprogramowanie ... i co robisz, jeśli nie jest?

Tak więc naprawdę szukasz klasy ciągów, która jest w stanie poradzić sobie z tym wszystkim poprawnie i nie jest to żaden z std::basic_string<>wariantów .

(Uwaga C ++ 11: std::u16stringi std::u32stringsą lepsze , ale wciąż nie są idealne. Przyniesiono C ++ 20std::u8string , ale wszystko to określa kodowanie. Pod wieloma innymi względami nadal nie znają mechaniki Unicode, takiej jak normalizacja, zestawianie, .. .)

Podczas gdy Boost wygląda ładnie, pod względem API, Boost.Locale jest zasadniczo otoczeniem ICU .Jeśli Boost jest skompilowany z obsługą ICU ... jeśli nie jest, Boost.Locale jest ograniczony do obsługi ustawień regionalnych skompilowanej dla standardowej biblioteki.

I uwierz mi że kompilacja Boosta na OIOM-ie może czasem być prawdziwym bólem. (Nie ma wstępnie skompilowanych plików binarnych dla systemu Windows, więc musisz je dostarczyć razem z aplikacją, a to otwiera zupełnie nową puszkę robaków ...)

Więc osobiście poleciłbym uzyskanie pełnego wsparcia Unicode prosto z pyska konia i korzystanie z OIOM biblioteki :

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

Skompiluj (z G ++ w tym przykładzie):

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

To daje:

ὀδυσσεύς

Zauważ, że konwersja Σ <-> σ w środku słowa, a konwersja Σ <-> ς na końcu słowa. Nie<algorithm> rozwiązanie nie może tego zapewnić.

[1] W 2017 r. Rada Ortografii Niemieckiej orzekła, że ​​„ẞ” U + 1E9E LATIN CAPITAL LETTER SHARP S może być oficjalnie używany jako opcja obok tradycyjnej konwersji „SS”, aby uniknąć dwuznaczności, np. W paszportach (gdzie nazwy są pisane wielkimi literami ). Mój piękny przykład, który stał się nieaktualny decyzją komisji ...

Korzystając z pętli C ++ 11 opartej na zakresie, prostszym kodem byłoby:

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

Jeśli ciąg zawiera znaki UTF-8 spoza zakresu ASCII, wówczas boost :: algorytm :: to_lower nie przekształci ich. Lepiej użyj boost :: locale :: to_lower, gdy zaangażowany jest UTF-8. Zobacz http://www.boost.org/doc/libs/1_51_0/libs/locale/doc/html/conversions.html

Jest to kontynuacja odpowiedzi Stefana Mai: jeśli chcesz umieścić wynik konwersji w innym ciągu, musisz wcześniej przydzielić miejsce do przechowywania przed wywołaniem std::transform. Ponieważ STL przechowuje przekształcone znaki w docelowym iteratorze (zwiększając go przy każdej iteracji pętli), ciąg docelowy nie zostanie automatycznie zmieniony, a Ty ryzykujesz tupanie pamięci.

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

Inne podejście wykorzystujące zakres oparty na pętli ze zmienną odniesienia

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

cout<<test<<endl;

O ile mi wiadomo, biblioteki Boost są naprawdę kiepskie pod względem wydajności. Przetestowałem ich nieuporządkowaną mapę do STL i była średnio 3 razy wolniejsza (najlepszy przypadek 2, najgorszy był 10 razy). Również ten algorytm wygląda zbyt nisko.

Różnica jest tak duża, że ​​jestem pewien, że jakikolwiek dodatek, który musisz zrobić, toloweraby zrównoważyć zwiększenie „na twoje potrzeby”, będzie znacznie szybszy niż doładowanie.

Zrobiłem te testy na Amazon EC2, dlatego wydajność była różna podczas testu, ale nadal masz pomysł.

./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 zrobiło to tak:

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

Źródło:

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

Chyba powinienem przejść testy na dedykowanym komputerze, ale będę używać tego EC2, więc tak naprawdę nie muszę go testować na moim komputerze.

Najprostszym sposobem na konwersję łańcucha znaków na małą literę bez zawracania sobie głowy standardową przestrzenią nazw jest następująca

1: ciąg znaków z / bez spacji

#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: ciąg bez spacji

#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()ze standardowej biblioteki lokalizacji C ++ zrobi to za Ciebie poprawnie. Oto przykład wyodrębniony ze strony referencyjnej 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";
}

Alternatywą dla Boost jest POCO (pocoproject.org).

POCO oferuje dwa warianty:

1. Pierwszy wariant tworzy kopię bez zmiany oryginalnego ciągu.
2. Drugi wariant zmienia oryginalny ciąg znaków na miejscu.
   Wersje „In Place” zawsze mają w nazwie nazwę „InPlace”.
   

Obie wersje pokazano poniżej:

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

Istnieje sposób na konwersję wielkich liter na małe BEZ wykonywania testów , i jest to dość proste. Korzystanie z funkcji clocale.h przez funkcję isupper () / makro powinno zająć się problemami związanymi z twoją lokalizacją, ale jeśli nie, zawsze możesz dostosować UtoL [] do treści twojego serca.

Biorąc pod uwagę, że znaki C są w rzeczywistości 8-bitowymi liczbami całkowitymi (w tej chwili ignorując szerokie zestawy znaków), możesz utworzyć 256-bajtową tablicę zawierającą alternatywny zestaw znaków, aw funkcji konwersji użyj znaków w łańcuchu jako indeksów dolnych do tablica konwersji.

Zamiast mapowania 1 do 1, należy podać elementom tablicy wielkimi literami wartości BYTE int dla małych liter. Przydatne mogą być tutaj islower () i isupper () .

Kod wygląda następująco ...

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

Takie podejście pozwoli jednocześnie na ponowne mapowanie dowolnych znaków, które chcesz zmienić.

Podejście to ma jedną ogromną zaletę w przypadku uruchamiania na nowoczesnych procesorach - nie ma potrzeby przewidywania rozgałęzień, ponieważ nie ma testów obejmujących rozgałęzienia. To oszczędza logikę przewidywania gałęzi CPU dla innych pętli i ma tendencję do zapobiegania utknięciu rurociągu.

Niektórzy tutaj mogą uznać to podejście za takie samo, jak w przypadku konwersji EBCDIC na ASCII.

Ponieważ żadna z odpowiedzi nie wspomniała o nadchodzącej bibliotece Ranges, która jest dostępna w bibliotece standardowej od C ++ 20 i obecnie jest osobno dostępna w GitHub as range-v3, chciałbym dodać sposób przeprowadzenia tej konwersji przy użyciu tej biblioteki .

Aby zmodyfikować ciąg w miejscu:

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

Aby wygenerować nowy ciąg:

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

(Nie zapomnij o #include <cctype>wymaganych nagłówkach zakresów.)

Uwaga: użycie unsigned charargumentu do lambda jest zainspirowane cppreferencją , która stwierdza:

Podobnie jak wszystkie inne funkcje z <cctype>, zachowanie nie std::tolowerjest zdefiniowane, jeśli wartość argumentu nie jest ani reprezentowalna, unsigned charani równa EOF. Aby bezpiecznie korzystać z tych funkcji w przypadku zwykłych charznaków ( signed chars), argument należy najpierw przekonwertować na unsigned char:

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

Podobnie nie należy ich używać bezpośrednio ze standardowymi algorytmami, gdy typem wartości iteratora jest charlub signed char. Zamiast tego przekonwertuj wartość na unsigned charpierwszą:

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

Moje własne funkcje szablonu, które wykonują wielkie / małe litery.

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

Oto technika makro, jeśli chcesz czegoś prostego:

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

Należy jednak pamiętać, że komentarz @ AndreasSpindler do tej odpowiedzi nadal jest ważnym czynnikiem, jeśli pracujesz nad czymś, co nie jest tylko znakami 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;
}

Aby uzyskać więcej informacji: http://www.cplusplus.com/reference/locale/tolower/

Czy istnieje alternatywa, która działa w 100% przypadków?

Nie

Jest kilka pytań, które musisz sobie zadać przed wybraniem metody o małej obudowie.

1. Jak kodowany jest ciąg? zwykły ASCII? UTF-8? jakaś forma rozszerzonego starszego kodowania ASCII?
2. Co i tak rozumiesz przez małe litery? Reguły mapowania przypadków różnią się w zależności od języka! Czy chcesz coś zlokalizowanego w lokalizacji użytkownika? chcesz czegoś, co zachowuje się spójnie na wszystkich systemach, na których działa twoje oprogramowanie? Czy chcesz po prostu pisać małe znaki ASCII i przechodzić przez wszystko inne?
3. Jakie biblioteki są dostępne?

Po uzyskaniu odpowiedzi na te pytania możesz zacząć szukać rozwiązania, które odpowiada Twoim potrzebom. Nie ma jednego uniwersalnego rozmiaru, który pasowałby do wszystkich na całym świecie!

Wypróbuj tę funkcję :)

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

Na platformach Microsoft można korzystać z strlwrrodziny funkcji: 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 );
}

Fragment kodu

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

Użyj fplus :: to_lower_case ().

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

Wyszukaj „to_lower_case” w http://www.editgym.com/fplus-api-search/ )

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

Skopiuj, ponieważ zabroniono poprawiania odpowiedzi. Dziękuję

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

Wyjaśnienie:

for(auto& c : test)jest tego rodzaju opartą na zakresie pętlą :
for (range_declaration:range_expression)loop_statement

1. range_declaration: W auto& c
   tym przypadku automatyczny specyfikator służy do automatycznego odliczania typu. Zatem typ jest odejmowany od inicjalizatora zmiennych.

2. range_expression: test
   Zakres w tym przypadku to znaki ciągu test.

Znaki ciągu testsą dostępne jako odniesienie wewnątrz pętli for poprzez identyfikator c.

C ++ nie ma zaimplementowanych dla łańcucha znaków metod tolower ani toupper, ale jest dostępny dla char. Można łatwo odczytać każdy znak ciągu, przekształcić go w wymaganą wielkość liter i umieścić z powrotem w ciągu. Przykładowy kod bez użycia biblioteki innej firmy:

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

Dla operacji na łańcuchach opartych na znakach : Dla każdego znaku w łańcuchu

Może to być kolejna prosta wersja do konwersji wielkich liter na małe i odwrotnie. Użyłem wersji społeczności VS2017 do skompilowania tego kodu źródłowego.

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

Uwaga: jeśli są znaki specjalne, należy je traktować za pomocą funkcji sprawdzania warunków.

Próbowałem std :: transform, wszystko, co dostaję, to obrzydliwy błąd kompilacji stl striptiz, który mogą zrozumieć tylko druidzi sprzed 200 lat (nie można przekonwertować z grypy na flibidi flabidi)

działa to dobrze i można je łatwo dostosować

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