Як перетворити std :: string в малі регістри?

Я хочу перетворити std::stringна малі регістри. Я знаю про цю функцію tolower(), проте в минулому у мене виникли проблеми з цією функцією, і навряд чи це ідеально, оскільки використання з std::stringзнаряддям вимагає повторення кожного символу.

Чи існує альтернатива, яка працює 100% часу?

Адаптовано з не так часто заданих питань :

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

Ви насправді не збираєтеся тікати, не перебираючи кожного персонажа. Немає способу дізнатися, чи є символ символом малого чи великого регістру.

Якщо ви справді ненавидите tolower(), ось спеціалізована альтернатива лише ASCII, яку я не рекомендую вам використовувати:

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

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

Будьте в курсі, що tolower()можна робити лише заміну на один байт символів, що погано підходить для багатьох сценаріїв, особливо якщо використовується багатобайтове кодування на зразок UTF-8.

Boost забезпечує рядковий алгоритм для цього :

#include <boost/algorithm/string.hpp>

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

Або для не на місці :

#include <boost/algorithm/string.hpp>

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

тл; д-р

Використовуйте бібліотеку ICU . Якщо ви цього не зробите, ваша конвертаційна процедура буде мовчки порушуватися на випадки, про які ви, мабуть, не знаєте навіть існуючих.

По- перше , ви повинні відповісти на питання: Що таке кодування з ваших std::string? Це ISO-8859-1? А може, ISO-8859-8? Або кодова сторінка Windows 1252? Чи знає те, що ви використовуєте для перетворення верхніх у малі регістри? (Або це невдало провалюється для персонажів 0x7f?)

Якщо ви використовуєте UTF-8 (єдиний розумний вибір серед 8-бітових кодувань) з std::string якості контейнера, ви вже обманюєте себе, вважаючи, що ви все ще контролюєте речі, оскільки ви зберігаєте багатобайтову послідовність символів у контейнері що не знає багатобайтової концепції. Навіть щось таке просте, як .substr()це тимбол. (Тому що розщеплення багатобайтової послідовності призведе до недійсного (під-) рядка.)

І як тільки ви спробуєте щось подібне std::toupper( 'ß' ), у будь-якому кодуванні ви потрапляєте у глибокі проблеми. (Тому що це неможливо зробити "правильно" зі стандартною бібліотекою, яка може надати лише один результат результату, не "SS"потрібний тут.) [1] Ще один приклад std::tolower( 'I' ), який повинен давати різні результати залежно від локальної локації . У Німеччині 'i'було б правильно; в Туреччині, 'ı'(LATIN SMALL LETTER DOTLESS I) - очікуваний результат (який, знову ж таки, більше кодує один байт у кодуванні UTF-8). Ще один приклад - грецька сигма , великі '∑', малі регістри 'σ'... за винятком кінця слова, де вона знаходиться'ς' .

Отже, будь-яке перетворення випадків, яке працює на персонаж за раз, або, що ще гірше, байт за один раз, порушується дизайном.

Тоді існує точка , що стандартна бібліотека, для чого він це здатний робити, в залежності від локалі , які підтримуються на машині ваше програмне забезпечення працює на ... і що робити , якщо це не так ?

Тож те, що ви насправді шукаєте, це клас струн, який здатний правильно впоратися з усім цим, і це не будь-який з std::basic_string<>варіантів .

(C ++ 11 Примітка: std::u16stringі std::u32stringце краще ., Але все ще не досконалі C ++ 20 принісstd::u8string , але все це потрібно вказати на кодування. У багатьох інших аспектах вони все ще залишаються незнаними щодо механіки Unicode, як нормалізація, порівняння ... .)

Хоча Boost виглядає добре, API мудрий, Boost.Locale - це в основному обгортка навколо ICU . Якщо Boost компілюється з підтримкою ICU ... якщо це не так, Boost.Locale обмежений підтримкою локальної мови, зібраною для стандартної бібліотеки.

І повірте, отримувати підштовхування компілювати з ICU може бути реальною болю іноді. (Для Windows немає попередньо складених бінарних файлів, тому вам доведеться постачати їх разом зі своїм додатком, і це відкриє цілу нову банку черв'яків ...)

Тож особисто я рекомендував би отримати повну підтримку Unicode прямо з вуст коня та безпосередньо користуватися бібліотекою 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;
}

Компілюйте (із G ++ у цьому прикладі):

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

Це дає:

ὀδυσσεύς

Зауважте, що конверсія Σ <-> σ в середині слова, а конверсія Σ <-> ς в кінці слова. Жодне <algorithm>рішення, яке не базується на цьому, не може вам цього дати.

[1] У 2017 році Рада з німецької ортографії вирішила, що "ẞ" U + 1E9E LATIN CAPITAL LETTER SHARP S може бути використаний офіційно, як варіант поруч із традиційним перетворенням "SS", щоб уникнути неоднозначності, наприклад, у паспортах (де імена з великої літери ). Мій гарний приклад, застарілий рішенням комітету ...

Використовуючи діапазон для циклу C ++ 11, більш простим кодом буде:

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

Якщо рядок містить символи UTF-8 за межами діапазону ASCII, тоді boost :: алгоритм :: to_lower не перетворить їх. Краще використовувати boost :: locale :: to_lower, коли бере участь UTF-8. Див. Http://www.boost.org/doc/libs/1_51_0/libs/locale/doc/html/conversions.html

Це відповідь на відповідь Стефана Май: якщо ви хочете помістити результат перетворення в інший рядок, перед закликом потрібно заздалегідь виділити його місце для зберігання std::transform. Оскільки STL зберігає перетворені символи в ітераторі призначення (збільшуючи його при кожній ітерації циклу), рядок призначення не буде змінено автоматично, і ви ризикуєте заглушити пам'ять.

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

Інший підхід, що використовує діапазон, заснований на циклі з перемінною змінною

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

cout<<test<<endl;

Наскільки я бачу, бібліотеки Boost справді погані. Я перевірив їхню невпорядковану карту на STL, і вона була в середньому в 3 рази повільніше (найкращий випадок 2, гірший - у 10 разів). Також цей алгоритм виглядає занадто низьким.

Різниця настільки велика, що я впевнений, що будь-яке доповнення, яке вам потрібно буде зробити, tolowerщоб зробити його рівним для підвищення "для ваших потреб", буде набагато швидшим, ніж підвищення.

Я робив ці тести на Amazon EC2, тому продуктивність відрізнялась під час тесту, але ви все одно отримуєте думку.

./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 зробив це так:

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

Джерело:

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

Я думаю, що я повинен проводити тести на спеціальній машині, але я буду використовувати цей EC2, тому мені не потрібно тестувати його на своїй машині.

Найпростіший спосіб перетворити рядок у низький розмір, не турбуючись про std-простір імен, полягає в наступному

1: рядок з пробілами та без них

#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: рядок без пробілів

#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()зі стандартної бібліотеки локалізації C ++ це правильно зробить для вас. Ось приклад, витягнутий із довідкової сторінки на толовер

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

Альтернативою Boost є POCO (pocoproject.org).

POCO пропонує два варіанти:

1. Перший варіант робить копію, не змінюючи початковий рядок.
2. Другий варіант змінює початковий рядок на місці.
   У версіях "In Place" завжди в назві є "InPlace".
   

Обидві версії демонструються нижче:

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

Існує спосіб перетворити верхній регістр на нижній БЕЗ виконання, якщо тести , і це досить прямо. Функція isupper () / використання макросу clocale.h має вирішити проблеми, пов’язані з вашим місцезнаходженням, але якщо ні, ви завжди можете налаштувати UtoL [] на вміст вашого серця.

Враховуючи, що символи C - це справді лише 8-бітні вставки (ігноруючи широкі набори символів на даний момент), ви можете створити масив 256 байтів, що містить альтернативний набір символів, а в функції перетворення використовувати символи у рядку як підписки на масив перетворення.

Замість того, щоб зіставити 1 для 1, дайте членам масиву верхнього регістру значення BYTE int для малих символів. Тут ви можете знайти корисні islower () та isupper () .

Код виглядає приблизно так ...

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

Такий підхід одночасно дозволить перезавантажувати будь-які інші символи, які ви хочете змінити.

Цей підхід має одну величезну перевагу при роботі на сучасних процесорах, немає необхідності робити передбачення гілок, оскільки немає тестів, що містять розгалуження. Це зберігає логіку передбачення гілки процесора для інших циклів і, як правило, запобігає зупинці конвеєра.

Деякі тут можуть розпізнати цей підхід як той самий, що використовується для перетворення EBCDIC в ASCII.

Оскільки жодна з відповідей не згадала про майбутню бібліотеку діапазонів, яка доступна в стандартній бібліотеці з C ++ 20, і наразі окремо доступна в GitHub якrange-v3 я хотів би додати спосіб виконати це перетворення , використовуючи його.

Щоб змінити рядок на місці:

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

Щоб створити новий рядок:

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

(Не забувай #include <cctype> і необхідні заголовки діапазонів.)

Примітка: використання unsigned charаргументу лямбда в якості аргументу натхнене cppreference , який говорить:

Як і всі інші функції <cctype>, поведінка std::tolowerне визначена, якщо значення аргументу не є ні представним, unsigned charні рівним EOF. Щоб безпечно використовувати ці функції з простими chars (або signed chars), аргумент спочатку слід перетворити на unsigned char:

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

Аналогічно, вони не повинні безпосередньо використовуватися зі стандартними алгоритмами, коли типом значення ітератора є charабо signed char. Натомість перетворіть значення на unsigned charперше:

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

Мій власний шаблон функції, який виконує великі та малі регістри.

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

Ось макро-техніка, якщо ви хочете щось просте:

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

Однак зауважте, що коментар @ AndreasSpindler до цієї відповіді все ще є важливим питанням, однак, якщо ви працюєте над тим, що не є лише символами 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;
}

Для отримання додаткової інформації: http://www.cplusplus.com/reference/locale/tolower/

Чи існує альтернатива, яка працює 100% часу?

Ні

Є кілька питань, які потрібно задати собі перед тим, як вибрати метод нижнього корпусу.

1. Як кодується рядок? звичайний ASCII? UTF-8? якась форма розширеного кодування спадщини ASCII?
2. Що ти маєш на увазі під великим регістром? Правила картографічного відображення залежать від мов! Ви хочете щось, що локалізується на мові користувачів? Ви хочете щось, що поводиться послідовно у всіх системах, на яких працює ваше програмне забезпечення? Ви просто хочете прописати рядки ASCII символів і пройти все інше?
3. Які бібліотеки доступні?

Коли ви отримаєте відповіді на ці питання, ви можете почати шукати рішення, яке відповідає вашим потребам. Немає розміру, який відповідає всім, що працює для всіх скрізь!

Спробуйте цю функцію :)

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

На платформах microsoft ви можете використовувати strlwrсімейство функцій: 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 );
}

Знімок коду

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

Використовуйте fplus :: to_lower_case ().

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

Шукайте "to_lower_case" на веб-сайті http://www.editgym.com/fplus-api-search/ )

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

Скопіюйте, оскільки відповідь заборонено покращувати. Дякую ТАК

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

Пояснення:

for(auto& c : test)- це діапазон для циклу такого типу :
for (range_declaration:range_expression)loop_statement

1. range_declaration: auto& c
   Тут автоматичний специфікатор використовується для автоматичного виведення типу. Отже тип вилучається з ініціалізатора змінних.

2. range_expression: test
   Діапазон у цьому випадку - це символи рядка test.

Символи рядка testдоступні в якості посилання всередині циклу for for identifier c.

У C ++ немає методів толлера або таппер, що реалізуються для рядкових, але він доступний для char. Можна легко прочитати кожну таблицю рядка, перетворити її в потрібний регістр і повернути її в рядок. Зразок коду без використання будь-якої сторонньої бібліотеки:

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

Для символьної операції на рядку: для кожного символу в рядку

Це може бути ще одна проста версія, щоб перетворити великі регістри в малі і навпаки. Я використовував версію спільноти VS2017 для складання цього вихідного коду.

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

Примітка: якщо є спеціальні символи, їх потрібно обробляти за допомогою перевірки стану.

Я спробував std :: transform, все, що я отримую, - це гидка stl криптична помилка компіляції, яку можуть зрозуміти лише друїди з 200 років тому (не можуть перетворитись на флібіді-флабіді-грип)

це прекрасно працює і його можна легко налаштувати

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