Wie konvertiere ich std :: string in Kleinbuchstaben?

Ich möchte a std::stringin Kleinbuchstaben umwandeln . Ich bin mir der Funktion bewusst tolower(), aber in der Vergangenheit hatte ich Probleme mit dieser Funktion und sie ist sowieso kaum ideal, da die Verwendung mit a std::stringdas Durchlaufen jedes Zeichens erfordern würde.

Gibt es eine Alternative, die 100% der Zeit funktioniert?

Angepasst an nicht so häufig gestellte Fragen :

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

Du wirst wirklich nicht davonkommen, ohne jeden Charakter zu durchlaufen. Es gibt keine Möglichkeit festzustellen, ob das Zeichen sonst in Klein- oder Großbuchstaben geschrieben ist.

Wenn Sie es wirklich hassen tolower(), finden Sie hier eine spezielle ASCII-Alternative, die Sie nicht empfehlen:

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

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

Beachten Sie, dass tolower()nur eine Ersetzung pro Einzelbytezeichen möglich ist, was für viele Skripte nicht geeignet ist, insbesondere wenn eine Mehrbyte-Codierung wie UTF-8 verwendet wird.

Boost bietet hierfür einen String-Algorithmus :

#include <boost/algorithm/string.hpp>

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

Oder für Nicht-In-Place :

#include <boost/algorithm/string.hpp>

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

tl; dr

Verwenden Sie die ICU-Bibliothek . Wenn Sie dies nicht tun, wird Ihre Konvertierungsroutine in Fällen, in denen Sie wahrscheinlich gar nicht wissen, dass sie existieren, stillschweigend unterbrochen.

Zuerst müssen Sie eine Frage beantworten: Wie lautet die Kodierung Ihrer std::string? Ist es ISO-8859-1? Oder vielleicht ISO-8859-8? Oder Windows Codepage 1252? Weiß das, was auch immer Sie zum Konvertieren von Groß- und Kleinbuchstaben verwenden? (Oder scheitert es kläglich für Charaktere vorbei 0x7f?)

Wenn Sie UTF-8 (die einzig vernünftige Wahl unter den 8-Bit-Codierungen) mit std::stringals Container verwenden, täuschen Sie sich bereits in der Annahme, dass Sie immer noch die Kontrolle über die Dinge haben, da Sie eine Multibyte-Zeichenfolge in einem Container speichern das ist sich des Multibyte-Konzepts nicht bewusst. Sogar etwas so Einfaches wie .substr()eine tickende Zeitbombe. (Da das Aufteilen einer Multibyte-Sequenz zu einer ungültigen (Unter-) Zeichenfolge führt.)

Und sobald Sie etwas versuchen std::toupper( 'ß' ), in irgendeiner Codierung, sind Sie in großen Schwierigkeiten. (Weil es mit der Standardbibliothek, die nur ein Ergebniszeichen liefern kann , das "SS"hier nicht benötigt wird , einfach nicht "richtig" ist.) [1] Ein anderes Beispiel wäre std::tolower( 'I' ), das je nach Gebietsschema unterschiedliche Ergebnisse liefern sollte . In Deutschland 'i'wäre das richtig; In der Türkei ist 'ı'(LATIN SMALL LETTER DOTLESS I) das erwartete Ergebnis (das wiederum mehr als ein Byte in der UTF-8-Codierung beträgt). Ein weiteres Beispiel ist das griechische Sigma , Groß- '∑'und Kleinschreibung 'σ'... außer am Ende eines Wortes, wo es sich befindet 'ς'.

Also, jeder Fall Konvertierung , die auf einem Zeichen in einer Zeit arbeitet, oder noch schlimmer, ein Byte zu einem Zeitpunkt, wird durch Design gebrochen.

Dann gibt es den Punkt , dass die Standard - Bibliothek, für das, was es ist dazu in der Lage ist abhängig davon , welche Lokalisationen werden unterstützt auf der Maschine Ihre Software auf läuft ... und was tun Sie , wenn es nicht ist?

Also , was Sie wirklich suchen, ist ein String - Klasse , die mit all dies zu tun richtig fähig ist, und das ist nicht eine der std::basic_string<>Varianten .

(C ++ 11 Hinweis: std::u16stringund std::u32stringsind besser , aber immer noch nicht perfekt. C ++ 20 gebracht std::u8string, aber alles, was Sie tun, ist die Codierung anzugeben. In vielerlei Hinsicht bleiben sie immer noch unwissend über Unicode-Mechanik, wie Normalisierung, Kollatierung, .. .)

Während Boost in Bezug auf die API gut aussieht , ist Boost.Locale im Grunde ein Wrapper um die Intensivstation . Wenn Boost mit ICU-Unterstützung kompiliert wird, ist Boost.Locale auf die für die Standardbibliothek kompilierte Gebietsschema-Unterstützung beschränkt.

Und glauben Sie mich, immer Boost zu kompilieren mit ICU manchmal einen echten Schmerzen sein kann. (Es gibt keine vorkompilierten Binärdateien für Windows, daher müssten Sie sie zusammen mit Ihrer Anwendung bereitstellen, und das öffnet eine ganz neue Dose Würmer ...)

Daher würde ich persönlich empfehlen, die volle Unicode-Unterstützung direkt aus dem Maul des Pferdes zu erhalten und die Intensivbibliothek direkt zu nutzen:

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

Kompilieren (in diesem Beispiel mit G ++):

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

Das gibt:

ὀδυσσεύς

Beachten Sie, dass die Σ <-> σ-Konvertierung in der Mitte des Wortes und die Σ <-> ς-Konvertierung am Ende des Wortes. Keine <algorithm>basierende Lösung kann Ihnen das geben.

[1] 2017 entschied der Rat für deutsche Rechtschreibung, dass "" "U + 1E9E LATIN CAPITAL LETTER SHARP S offiziell als Option neben der traditionellen" SS "-Konvertierung verwendet werden kann, um Unklarheiten zu vermeiden, z. B. in Pässen (bei denen Namen groß geschrieben werden) ). Mein schönes Beispiel, das durch die Entscheidung des Komitees überholt wurde ...

Bei Verwendung einer bereichsbasierten for-Schleife von C ++ 11 wäre ein einfacherer Code:

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

Wenn die Zeichenfolge UTF-8-Zeichen außerhalb des ASCII-Bereichs enthält, konvertiert boost :: algorithm :: to_lower diese nicht. Verwenden Sie besser boost :: locale :: to_lower, wenn UTF-8 beteiligt ist. Siehe http://www.boost.org/doc/libs/1_51_0/libs/locale/doc/html/conversions.html

Dies ist eine Folge der Antwort von Stefan Mai: Wenn Sie das Ergebnis der Konvertierung in eine andere Zeichenfolge einfügen möchten, müssen Sie den Speicherplatz vor dem Aufruf vorab zuweisen std::transform. Da STL transformierte Zeichen im Zieliterator speichert (bei jeder Iteration der Schleife inkrementiert), wird die Größe der Zielzeichenfolge nicht automatisch geändert, und Sie riskieren ein Stomping des Speichers.

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

Ein anderer Ansatz, der eine auf einem Bereich basierende Schleife mit Referenzvariable verwendet

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

cout<<test<<endl;

Soweit ich sehe, sind Boost-Bibliotheken in Bezug auf die Leistung wirklich schlecht. Ich habe ihre unordered_map auf STL getestet und sie war durchschnittlich dreimal langsamer (bester Fall 2, schlechtester zehnmal). Auch dieser Algorithmus sieht zu niedrig aus.

Der Unterschied ist so groß, dass ich mir sicher bin, dass jede Ergänzung, die Sie tun müssen, tolowerum den Boost "für Ihre Bedürfnisse" gleichzusetzen, viel schneller als der Boost sein wird.

Ich habe diese Tests auf einem Amazon EC2 durchgeführt, daher variierte die Leistung während des Tests, aber Sie haben immer noch die Idee.

./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 machte es so:

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

Quelle:

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

Ich denke, ich sollte die Tests auf einem dedizierten Computer durchführen, aber ich werde diesen EC2 verwenden, damit ich ihn nicht wirklich auf meinem Computer testen muss.

Der einfachste Weg, einen String in Kleinbuchstaben umzuwandeln, ohne sich um den Standard-Namespace zu kümmern, ist der folgende

1: Zeichenfolge mit / ohne Leerzeichen

#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: Zeichenfolge ohne Leerzeichen

#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()aus der Standard-C ++ - Lokalisierungsbibliothek erledigt dies korrekt für Sie. Hier ist ein Beispiel, das aus der unteren Referenzseite extrahiert wurde

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

Eine Alternative zu Boost ist POCO (pocoproject.org).

POCO bietet zwei Varianten:

1. Die erste Variante erstellt eine Kopie, ohne die ursprüngliche Zeichenfolge zu ändern.
2. Die zweite Variante ändert die ursprüngliche Zeichenfolge.
   "In Place" -Versionen haben immer "InPlace" im Namen.
   

Beide Versionen werden unten gezeigt:

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

Es gibt eine Möglichkeit, Großbuchstaben in Kleinbuchstaben umzuwandeln, OHNE Tests durchzuführen , und dies ist ziemlich einfach. Die Verwendung von clocale.h durch die Funktion / das Makro von isupper () sollte sich um Probleme in Bezug auf Ihren Standort kümmern. Wenn nicht, können Sie das UtoL [] jederzeit nach Herzenslust anpassen.

Da die Zeichen von C wirklich nur 8-Bit-Ints sind (wobei die breiten Zeichensätze im Moment ignoriert werden), können Sie ein 256-Byte-Array erstellen, das einen alternativen Zeichensatz enthält, und in der Konvertierungsfunktion die Zeichen in Ihrer Zeichenfolge als Indizes für die Zeichen verwenden Konvertierungsarray.

Geben Sie den Array-Mitgliedern in Großbuchstaben anstelle einer 1-zu-1-Zuordnung die BYTE-Int-Werte für die Kleinbuchstaben. Hier finden Sie möglicherweise islower () und isupper () .

Der Code sieht so aus ...

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

Dieser Ansatz ermöglicht es Ihnen gleichzeitig, alle anderen Zeichen, die Sie ändern möchten, neu zuzuordnen.

Dieser Ansatz hat einen großen Vorteil, wenn er auf modernen Prozessoren ausgeführt wird. Es ist nicht erforderlich, eine Verzweigungsvorhersage durchzuführen, da es keine If-Tests gibt, die eine Verzweigung umfassen. Dies speichert die Verzweigungsvorhersagelogik der CPU für andere Schleifen und verhindert tendenziell ein Abwürgen der Pipeline.

Einige hier erkennen diesen Ansatz möglicherweise als denselben an, der zum Konvertieren von EBCDIC in ASCII verwendet wird.

Da in keiner der Antworten die bevorstehende Ranges-Bibliothek erwähnt wurde, die seit C ++ 20 in der Standardbibliothek verfügbar ist und derzeit separat auf GitHub als verfügbar ist range-v3, möchte ich eine Möglichkeit hinzufügen, diese Konvertierung mit ihr durchzuführen.

So ändern Sie die Zeichenfolge an Ort und Stelle:

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

So generieren Sie eine neue Zeichenfolge:

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

(Vergessen Sie nicht #include <cctype>und die erforderlichen Ranges-Header.)

Hinweis: Die Verwendung unsigned charals Argument für das Lambda ist von cppreference inspiriert , in dem es heißt:

Wie bei allen anderen Funktionen von <cctype>ist das Verhalten von std::tolowerundefiniert, wenn der Wert des Arguments weder als unsigned charnoch gleich darstellbar ist EOF. Um diese Funktionen sicher mit einfachen chars (oder signed chars) zu verwenden, sollte das Argument zuerst konvertiert werden in unsigned char:

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

Ebenso sollten sie nicht direkt mit Standardalgorithmen verwendet werden, wenn der Werttyp des Iterators charoder ist signed char. Konvertieren Sie stattdessen den Wert in unsigned charfirst:

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

Meine eigenen Vorlagenfunktionen, die Groß- / Kleinschreibung ausführen.

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

Hier ist eine Makrotechnik, wenn Sie etwas Einfaches wollen:

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

Beachten Sie jedoch, dass der Kommentar von @ AndreasSpindler zu dieser Antwort immer noch eine wichtige Überlegung ist, wenn Sie an etwas arbeiten, das nicht nur aus ASCII-Zeichen besteht.

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

Für weitere Informationen: http://www.cplusplus.com/reference/locale/tolower/

Gibt es eine Alternative, die 100% der Zeit funktioniert?

Nein

Es gibt mehrere Fragen, die Sie sich stellen müssen, bevor Sie eine Kleinbuchstabenmethode auswählen.

1. Wie ist die Zeichenfolge codiert? einfaches ASCII? UTF-8? irgendeine Form der erweiterten ASCII-Legacy-Codierung?
2. Was meinst du überhaupt mit Kleinbuchstaben? Die Regeln für die Fallzuordnung variieren zwischen den Sprachen! Möchten Sie etwas, das im Gebietsschema des Benutzers lokalisiert ist? Möchten Sie etwas, das sich auf allen Systemen, auf denen Ihre Software ausgeführt wird, konsistent verhält? Möchten Sie nur ASCII-Zeichen in Kleinbuchstaben schreiben und alles andere durchlaufen?
3. Welche Bibliotheken stehen zur Verfügung?

Sobald Sie Antworten auf diese Fragen haben, können Sie nach einer Lösung suchen, die Ihren Anforderungen entspricht. Es gibt keine Einheitsgröße, die für alle überall funktioniert!

Probieren Sie diese Funktion aus :)

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

Auf Microsoft-Plattformen können Sie die strlwrFunktionsfamilie verwenden: 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 );
}

Code-Auszug

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

Verwenden Sie fplus :: to_lower_case ().

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

Suchen Sie nach 'to_lower_case' unter http://www.editgym.com/fplus-api-search/ )

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

Kopieren, da die Antwort nicht verbessert werden durfte. Danke SO

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

Erläuterung:

for(auto& c : test)ist eine bereichsbasierte for-Schleife der Art :
for (range_declaration:range_expression)loop_statement

1. range_declaration: auto& c
   Hier wird der Auto- Bezeichner für den automatischen Typabzug verwendet. Der Typ wird also vom Variableninitialisierer abgezogen.

2. range_expression: test
   Der Bereich in diesem Fall sind die Zeichen der Zeichenfolge test.

Die Zeichen der Zeichenfolge teststehen als Referenz innerhalb der for-Schleife durch c.

In C ++ sind keine Tolower- oder Toupper-Methoden für Zeichenfolgen implementiert, sie sind jedoch für char verfügbar. Man kann jedes Zeichen einer Zeichenfolge leicht lesen, in die gewünschte Groß- und Kleinschreibung konvertieren und wieder in eine Zeichenfolge einfügen. Ein Beispielcode ohne Verwendung einer Bibliothek eines Drittanbieters:

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

Für zeichenbasierte Operationen an Zeichenfolgen: Für jedes Zeichen in Zeichenfolgen

Dies könnte eine weitere einfache Version sein, um Großbuchstaben in Kleinbuchstaben umzuwandeln und umgekehrt. Ich habe die VS2017-Community-Version verwendet, um diesen Quellcode zu kompilieren.

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

Hinweis: Wenn Sonderzeichen vorhanden sind, müssen diese mithilfe der Bedingungsprüfung behandelt werden.

Ich habe versucht, std :: transform, alles was ich bekomme ist ein abscheulicher stl criptic Kompilierungsfehler, den nur Druiden von vor 200 Jahren verstehen können (kann nicht von zu Flibidi Flabidi Grippe konvertieren)

Dies funktioniert gut und kann leicht angepasst werden

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