Как преобразовать std :: string в нижний регистр?

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

Адаптировано из Не очень часто задаваемые вопросы:

#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 действительно плохи с точки зрения производительности. Я протестировал их unordered_map на STL, и он был в среднем в 3 раза медленнее (в лучшем случае 2, в худшем - в 10 раз). Также этот алгоритм выглядит слишком заниженным.

Разница настолько велика, что я уверен, что любое добавление, которое вам нужно будет сделать для tolower, чтобы сделать его равным boost "для ваших нужд", будет намного быстрее, чем boost.

Я проводил эти тесты на 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, поэтому мне не нужно тестировать его на моей машине.

Если строка содержит символы UTF-8 за пределами диапазона ASCII, то boost :: algorithm :: 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;
}

Альтернативой Boost является POCO (pocoproject.org).

POCO предлагает два варианта:

1. Первый вариант делает копию без изменения исходной строки.
2. Второй вариант заменяет исходную строку на место. Версии «на месте» всегда имеют в названии «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);

Используя диапазон для цикла 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);
}

Есть способ преобразовать верхний регистр в нижний регистр БЕЗ выполнения тестов if, и это довольно просто. Функция / макрос 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;
}

Этот подход, в то же время, позволит вам переназначить любых других персонажей, которые вы хотите изменить.

У этого подхода есть одно огромное преимущество при работе на современных процессорах: нет необходимости делать предсказание ветвления, поскольку нет тестов if, содержащих ветвление. Это сохраняет логику прогнозирования ветвлений ЦП для других циклов и предотвращает остановку конвейера.

Некоторые здесь могут признать этот подход тем же самым, что использовался для преобразования EBCDIC в ASCII.

tl; dr

Используйте Библиотека ICU. Если вы этого не сделаете, ваша процедура преобразования будет молча прервана в случаях, о которых вы, вероятно, даже не подозреваете.

Сначала вы должны ответить на вопрос: каков кодирование вашего std::string? Это ISO-8859-1? Или, может быть, ISO-8859-8? Или кодовая страница Windows 1252? Знает ли об этом все, что вы используете для преобразования верхнего регистра в нижний? (Или это плохо для символов по 0x7f?)

Если вы используете UTF-8 (единственный разумный выбор среди 8-битных кодировок) с std::string в качестве контейнера, вы уже обманываете себя, если считаете, что все еще контролируете ситуацию. Вы сохраняете последовательность многобайтовых символов в контейнере, который не знает о концепции многобайтовых символов, и ни одна из операций, которые вы можете с ним выполнять! Даже такая простая вещь, как .substr(), может привести к недействительным (под) строкам, потому что вы разбиваете их посередине многобайтовой последовательности.

Как только вы попробуете что-то вроде std::toupper( 'ß' ) или std::tolower( 'Σ' ) в кодировке Любые, у вас будут проблемы. Поскольку 1) стандарт всегда работает только с одним символом за раз, поэтому он просто не может превратить ß в SS, что было бы правильным. И 2) стандарт всегда работает только с одним символом за раз, поэтому он не может решить, находится ли Σ в середине слова (где σ будет правильным) или в конце (ς). Другим примером может быть std::tolower( 'I' ), который должен давать разные результаты в зависимости от региона - практически везде, где вы ожидаете i, но в Турции ı (LATIN SMALL LETTER DOTLESS I) - правильный ответ (который, опять же, больше одного байта в UTF-8 кодировка).

Таким образом, преобразование регистра Любые, которое работает с символом за раз, или, что еще хуже, байт за раз, нарушено конструктивно. Сюда входят все варианты std::, существующие в настоящее время.

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

Итак, то, что вы ищете В самом деле, - это строковый класс, способный со всем этим правильно справиться, и это нет любой из вариантов std::basic_string<>.

(Примечание C++ 11: std::u16string и std::u32string являются лучше, но все еще не идеальны. C++ 20 принес std::u8string, но все, что они делают, это указывает кодирование. Во многих других отношениях они по-прежнему игнорируют механизмы Unicode, такие как нормализация, сопоставление , ...)

Хотя Boost выглядит хорош, с точки зрения API, Boost.Locale в основном является оболочкой для ICU. Если Boost - это составлен с поддержкой ICU ... если это не так, Boost.Locale ограничивается поддержкой локали, скомпилированной для стандартной библиотеки.

И поверьте мне, получающий Boost для компиляции с ICU иногда может быть настоящей проблемой. (Для Windows нет предварительно скомпилированных двоичных файлов, включающих ICU, поэтому вам придется поставлять их вместе с вашим приложением, а который открывает совершенно новую банку червей ...)

Так что лично я бы рекомендовал получить полную поддержку 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> не может вам этого дать.

Я пробовал std :: transform, все, что я получаю, - это отвратительная ошибка компиляции stl criptic, которую могут понять только друиды 200-летней давности (не могут преобразовать из flibidi flabidi flu)

это отлично работает и может быть легко изменено

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

На платформах 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 );
}

Самый простой способ преобразовать строку в loweercase, не беспокоясь о пространстве имен 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++ правильно сделает это за вас. Вот пример, извлеченный из справочная страница 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";
}

Вот макросъемка, если вам нужно что-то простое:

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

Другой подход, использующий цикл на основе диапазона со ссылочной переменной

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

cout<<test<<endl;

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

Фрагмент кода

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

Искать to_lower_case в 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 на основе диапазона типа
for (range_declaration:range_expression)loop_statement:

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

2. range_expression: test
   Диапазон в данном случае - символы строки test.

Символы строки test доступны в качестве ссылки внутри идентификатора цикла for c.

Это может быть еще одна простая версия для преобразования верхнего регистра в нижний и наоборот. Я использовал версию сообщества 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;
}

Примечание: если есть специальные символы, их нужно обрабатывать с помощью проверки условий.

Is there an alternative which works 100% of the time?

Нет

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

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

Получив ответы на эти вопросы, вы можете приступить к поиску решения, которое соответствует вашим потребностям. Не существует универсального решения, подходящего для всех и везде!

В C++ нет методов tolower или toupper, реализованных для std::string, но он доступен для 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;
}

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

Поскольку ни в одном из ответов не упоминается предстоящая библиотека Ranges, которая доступна в стандартной библиотеке с 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, в котором говорится:

Like all other functions from <cctype>, the behavior of std::tolower is undefined if the argument's value is neither representable as unsigned char nor equal to EOF. To use these functions safely with plain chars (or signed chars), the argument should first be converted to unsigned char:

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

Similarly, they should not be directly used with standard algorithms when the iterator's value type is char or signed char. Instead, convert the value to unsigned char first:

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

Попробуйте эту функцию :)

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;

}

Я написал эту простую вспомогательную функцию:

#include <locale> // tolower

string to_lower(string s) {        
    for(char &c : s)
        c = tolower(c);
    return s;
}

Использование:

string s = "TEST";
cout << to_lower("HELLO WORLD"); // output: "hello word"
cout << to_lower(s); // won't change the original variable.