Muss ich in unsigned char umwandeln, bevor ich toupper(), tolower() usw. aufrufe?

Vor einiger Zeit schrieb jemand mit hohem Ansehen hier auf Stack Overflow in einem Kommentar, dass es notwendig sei, a zu casten char-Argument zu unsigned char vor dem Anruf std::toupper und std::tolower (und ähnliche Funktionen).

Andererseits erwähnt Bjarne Stroustrup die Notwendigkeit dazu nicht die Programmiersprache C++. Er benutzt nur toupper wie

string name = "Niels Stroustrup";

void m3() {
  string s = name.substr(6,10);  // s = "Stroustr up"
  name.replace(0,5,"nicholas");  // name becomes "nicholas Stroustrup"
  name[0] = toupper(name[0]);   // name becomes "Nicholas Stroustrup"
}

(Zitiert aus besagtem Buch, 4. Auflage.)

Die Referenz sagt, dass die Eingabe darstellbar sein muss als unsigned char. Für mich klingt das so, als würde es für alle gelten char seit char und unsigned char haben die gleiche Größe.

Ist diese Besetzung also unnötig oder war Stroustrup nachlässig?

Bearbeiten: Die libstdc++ Handbuch erwähnt, dass das Eingabezeichen aus dem stammen muss grundlegender Quellzeichensatz, wirft aber nicht. Ich denke, dies wird durch die Antwort von @Keith Thompson abgedeckt, sie alle haben eine positive Darstellung als signed char und unsigned char?

Ja, das Argument dazu toupper umgewandelt werden muss unsigned char um das Risiko eines undefinierten Verhaltens zu vermeiden.

Die Typen char, signed charund unsigned char sind drei verschiedene Arten. char hat die gleiche Reichweite und Darstellung wie entweder signed char oder unsigned char. (Einfach char ist sehr häufig vorzeichenbehaftet und kann Werte im Bereich von -128 bis +127 darstellen.)

Die toupper Funktion dauert ein int Argument und gibt ein zurück int Ergebnis. Zitat der C-Norm, Abschnitt 7.4 Absatz 1:

In allen Fällen ist das Argument ein intderen Wert als darstellbar sein soll unsigned char oder soll gleich dem Wert des Makros sein EOF . Wenn das Argument einen anderen Wert hat, ist das Verhalten undefiniert.

(C++ enthält den größten Teil der C-Standardbibliothek und verschiebt seine Definition auf den C-Standard.)

Die [] Indizierungsoperator ein std::string gibt einen Verweis auf zurück char. Wenn klar char ein signierter Typ ist, und wenn der Wert von name[0] zufällig negativ ist, dann der Ausdruck

toupper(name[0])

hat undefiniertes Verhalten.

Die Sprache garantiert das, wenn auch schlicht char vorzeichenbehaftet ist, haben alle Mitglieder des grundlegenden Zeichensatzes nicht-negative Werte, so dass die Initialisierung gegeben ist

string name = "Niels Stroustrup";

das Programm riskiert kein undefiniertes Verhalten. Aber ja, im Allgemeinen a char Wert übergeben toupper (oder zu einer der in deklarierten Funktionen <cctype> / <ctype.h>) konvertiert werden muss unsigned charsodass die implizite Konvertierung in int ergibt keinen negativen Wert und verursacht kein undefiniertes Verhalten.

Die <ctype.h> Funktionen werden üblicherweise unter Verwendung einer Nachschlagetabelle implementiert. Etwas wie:

// assume plain char is signed
char c = -2;
c = toupper(c); // undefined behavior

kann außerhalb der Grenzen dieser Tabelle indizieren.

Beachten Sie, dass die Konvertierung in unsigned:

char c = -2;
c = toupper((unsigned)c); // undefined behavior

vermeidet das Problem nicht. Wenn int ist 32 Bit, die Konvertierung der char Wert -2 zu unsigned Erträge 4294967294. Diese wird dann implizit in konvertiert int (der Parametertyp), die wahrscheinlich Erträge -2.

toupper kann implementiert werden, damit es sich bei negativen Werten vernünftig verhält (alle Werte von akzeptieren CHAR_MIN zu UCHAR_MAX), aber es ist nicht erforderlich. Außerdem sind die Funktionen in <ctype.h> müssen ein Argument mit dem Wert akzeptieren EOFwas typisch ist -1.

Der C++-Standard nimmt Anpassungen an einigen Funktionen der C-Standardbibliothek vor. Zum Beispiel, strchr und mehrere andere Funktionen werden durch überladene Versionen ersetzt, die erzwingen const Richtigkeit. Für die in deklarierten Funktionen gibt es keine derartigen Anpassungen <cctype>.

Die Referenz bezieht sich auf das Wertwesen darstellbar als ein unsigned charnicht dazu Sein ein unsigned char. Das heißt, das Verhalten ist undefiniert, wenn der tatsächliche Wert nicht zwischen 0 und liegt UCHAR_MAX (normalerweise 255). (Oder EOFwas im Grunde der Grund ist, warum es dauert int anstelle einer char.)

In C, toupper (und viele andere Funktionen) übernehmen ints, obwohl Sie erwarten würden, dass sie nehmen charS. Zusätzlich, char ist auf einigen Plattformen signiert und auf anderen unsigniert.

Der Ratschlag zu werfen unsigned char vor dem Anruf toupper ist richtig für C. Ich glaube nicht, dass es in C++ benötigt wird, vorausgesetzt, Sie übergeben es an int das ist in Reichweite. Ich kann nichts Bestimmtes darüber finden, ob es in C++ benötigt wird.

Wenn Sie das Problem umgehen möchten, verwenden Sie die toupper definiert in <locale>. Es ist eine Vorlage und akzeptiert jeden akzeptablen Zeichentyp. Sie müssen es auch bestehen a std::locale. Wenn Sie keine Ahnung haben, welches Gebietsschema Sie wählen sollen, verwenden Sie std::locale("")das das bevorzugte Gebietsschema des Benutzers sein soll:

#include <algorithm>
#include <iostream>
#include <iterator>
#include <locale>
#include <string>

int main()
{
    std::string name("Bjarne Stroustrup");
    std::string uppercase;

    std::locale loc("");

    std::transform(name.begin(), name.end(), std::back_inserter(uppercase),
                   [&loc](char c) { return std::toupper(c, loc); });

    std::cout << name << '\n' << uppercase << '\n';
    return 0;
}

Leider war Stroustrup nachlässig 🙁
Und ja, lateinische Buchstabencodes sollten nicht negativ sein (und es ist kein Cast erforderlich) …
Einige Implementierungen funktionieren korrekt ohne Umwandlung in unsigned char …
Erfahrungsgemäß kann es einige Stunden dauern, die Ursache für einen Segfault eines solchen Toppers zu finden (wenn bekannt ist, dass ein Segfault vorhanden ist) …
Und es gibt auch isupper, islower etc

Anstatt das Argument als unsigned char umzuwandeln, können Sie die Funktion umwandeln. Sie müssen einbeziehen funktionell Header. Hier ist ein Beispielcode:

#include <string>
#include <algorithm>
#include <functional>
#include <locale>
#include <iostream>

int main()
{
    typedef unsigned char BYTE; // just in case

    std::string name("Daniel Brühl"); // used this name for its non-ascii character!

    std::transform(name.begin(), name.end(), name.begin(),
            (std::function<int(BYTE)>)::toupper);

    std::cout << "uppercase name: " << name << '\n';
    return 0;
}

Die Ausgabe ist:

uppercase name: DANIEL BRüHL

Wie erwartet hat toupper keine Auswirkungen auf Nicht-ASCII-Zeichen. Aber dieses Casting ist vorteilhaft, um unerwartetes Verhalten zu vermeiden.