QString Class

Dokumentation der Mitgliederfunktionen

Gibt eine Teilzeichenkette zurück, die die n äußersten linken Zeichen der Zeichenkette enthält.

Wenn Sie wissen, dass n nicht außerhalb der Grenzen liegen kann, verwenden Sie stattdessen first() in neuem Code, da dies schneller ist.

Die gesamte Zeichenkette wird zurückgegeben, wenn n größer oder gleich size() oder kleiner als Null ist.

Siehe auch first(), last(), startsWith(), chopped(), chop(), und truncate().

Gibt eine Teilzeichenkette zurück, die die n äußersten rechten Zeichen der Zeichenkette enthält.

Wenn Sie wissen, dass n nicht außerhalb der Grenzen liegen kann, verwenden Sie stattdessen last() in neuem Code, da dies schneller ist.

Die gesamte Zeichenkette wird zurückgegeben, wenn n größer oder gleich size() oder kleiner als Null ist.

Siehe auch endsWith(), last(), first(), sliced(), chopped(), chop(), truncate(), und slice().

Gibt eine Zeichenkette zurück, die n Zeichen dieser Zeichenkette enthält, beginnend mit dem angegebenen Index position.

Wenn Sie wissen, dass position und n nicht außerhalb der Grenzen liegen können, verwenden Sie stattdessen sliced() in neuem Code, da dies schneller ist.

Gibt eine Null-Zeichenkette zurück, wenn der Index position die Länge der Zeichenkette überschreitet. Wenn in der Zeichenkette ab dem angegebenen position weniger als n Zeichen verfügbar sind, oder wenn n -1 ist (Voreinstellung), gibt die Funktion alle Zeichen zurück, die ab dem angegebenen position verfügbar sind.

Siehe auch first(), last(), sliced(), chopped(), chop(), truncate(), und slice().

Gibt eine Zeichenkette zurück, die die ersten n Zeichen dieser Zeichenkette enthält.

QString x = "Pineapple";
QString y = x.first(4);      // y == "Pine"

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch last(), sliced(), startsWith(), chopped(), chop(), truncate(), und slice().

Gibt die Zeichenkette zurück, die die letzten n Zeichen dieser Zeichenkette enthält.

QString x = "Pineapple";
QString y = x.last(5);      // y == "apple"

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch first(), sliced(), endsWith(), chopped(), chop(), truncate(), und slice().

Gibt eine Zeichenkette zurück, die n Zeichen dieser Zeichenkette enthält, beginnend an der Position pos.

QString x = "Nine pineapples";
QString y = x.sliced(5, 4);            // y == "pine"
QString z = x.sliced(5);               // z == "pineapples"

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch first(), last(), chopped(), chop(), truncate(), und slice().

Dies ist eine überladene Funktion.

Gibt eine Zeichenkette zurück, die den Teil dieser Zeichenkette enthält, der an der Position pos beginnt und bis zu ihrem Ende reicht.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch first(), last(), chopped(), chop(), truncate(), und slice().

Gibt eine Zeichenkette zurück, die die size() - len äußersten linken Zeichen dieser Zeichenkette enthält.

Siehe auch endsWith(), first(), last(), sliced(), chop(), truncate(), und slice().

Sie gibt die maximale Anzahl von Elementen zurück, die die Zeichenkette theoretisch enthalten kann. In der Praxis kann die Anzahl viel kleiner sein, begrenzt durch den dem System zur Verfügung stehenden Speicher.

Diese Funktion wurde in Qt 6.8 eingeführt.

template <typename... Args> QString QString::arg(Args &&... args) const

Ersetzt alle Vorkommen von %N in dieser Zeichenfolge durch das entsprechende Argument aus args. Die Argumente sind nicht positionsabhängig: das erste der args ersetzt das %N durch das niedrigste N (alle), das zweite der args das %N durch das nächstniedrigere N usw.

Args kann aus allem bestehen, was sich implizit in QString, QStringView oder QLatin1StringView umwandeln lässt.

Darüber hinaus werden auch die folgenden Typen unterstützt: QChar, QLatin1Char.

Siehe auch QString::arg().

Teilt die Zeichenkette an allen Stellen, an denen sep vorkommt, in Teilzeichenketten auf und gibt eine "Lazy Sequence" dieser Zeichenketten zurück.

Äquivalent zu

return QStringTokenizer{std::forward<Needle>(sep), flags...};

mit dem Unterschied, dass es ohne die im Compiler aktivierte C++17 Class Template Argument Deduction (CTAD) funktioniert.

Siehe QStringTokenizer, um zu erfahren, wie sep und flags zusammenwirken, um das Ergebnis zu bilden.

QStringTokenizer result = sv.tokenize(sep);

(ohne Schablonenargumente) schreiben. Wenn Sie C++17 CTAD nicht verwenden können, dürfen Sie den Rückgabewert nur in auto Variablen speichern:

auto result = sv.tokenize(sep);

Das liegt daran, dass die Template-Argumente von QStringTokenizer eine sehr subtile Abhängigkeit von der spezifischen tokenize()-Überladung haben, von der sie zurückgegeben werden, und sie entsprechen normalerweise nicht dem Typ, der für das Trennzeichen verwendet wird.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch QStringTokenizer und qTokenize().

[constexpr noexcept] QString::QString()

Konstruiert eine Null-Zeichenkette. Null-Zeichenfolgen werden auch als leer betrachtet.

Siehe auch isEmpty(), isNull(), und Distinction Between Null and Empty Strings.

QString::QString(QChar ch)

Konstruiert eine Zeichenkette der Größe 1, die das Zeichen ch enthält.

QString::QString(QLatin1StringView str)

Konstruiert eine Kopie der Latin-1-Zeichenkette, die von str angezeigt wird.

Siehe auch fromLatin1().

QString::QString(const QByteArray &ba)

Konstruiert einen String, der mit dem Byte-Array ba initialisiert wird. Das angegebene Byte-Array wird mit fromUtf8() in Unicode konvertiert.

Sie können diesen Konstruktor deaktivieren, indem Sie QT_NO_CAST_FROM_ASCII definieren, wenn Sie Ihre Anwendungen kompilieren. Dies kann nützlich sein, wenn Sie z.B. sicherstellen wollen, dass alle für den Benutzer sichtbaren Zeichenketten QObject::tr() durchlaufen.

Siehe auch fromLatin1(), fromLocal8Bit(), und fromUtf8().

QString::QString(const char *str)

Konstruiert einen String, der mit der 8-Bit-Zeichenkette str initialisiert ist. Der angegebene const char-Zeiger wird mit der Funktion fromUtf8() in Unicode konvertiert.

Sie können diesen Konstruktor deaktivieren, indem Sie QT_NO_CAST_FROM_ASCII definieren, wenn Sie Ihre Anwendungen kompilieren. Dies kann nützlich sein, wenn Sie z.B. sicherstellen wollen, dass alle für den Benutzer sichtbaren Zeichenketten QObject::tr() durchlaufen.

Siehe auch fromLatin1(), fromLocal8Bit(), und fromUtf8().

[since 6.1] QString::QString(const char8_t *str)

Konstruiert einen String, der mit dem UTF-8-String str initialisiert ist. Der angegebene const char8_t Zeiger wird mit der Funktion fromUtf8() in Unicode konvertiert.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch fromLatin1(), fromLocal8Bit(), und fromUtf8().

[explicit] QString::QString(const QChar *unicode, qsizetype size = -1)

Konstruiert eine Zeichenkette, die mit den ersten size Zeichen des Arrays QChar unicode initialisiert wird.

Wenn unicode gleich 0 ist, wird eine Null-Zeichenkette erstellt.

Ist size negativ, wird angenommen, dass unicode auf ein \0'-abgeschlossenes Array zeigt und dessen Länge dynamisch bestimmt wird. Das abschließende Nullzeichen wird nicht als Teil des Strings betrachtet.

QString erstellt eine Tiefenkopie der Stringdaten. Die Unicodedaten werden unverändert kopiert und die Byte Order Mark wird beibehalten, falls vorhanden.

Siehe auch fromRawData().

QString::QString(qsizetype size, QChar ch)

Konstruiert eine Zeichenkette mit dem angegebenen size, wobei jedes Zeichen auf ch gesetzt wird.

Siehe auch fill().

[noexcept] QString::QString(const QString &other)

Konstruiert eine Kopie von other.

Dieser Vorgang benötigt konstante Zeit, da QString implizit gemeinsam genutzt wird. Das macht die Rückgabe eines QString aus einer Funktion sehr schnell. Wenn eine gemeinsam genutzte Instanz geändert wird, wird sie kopiert (copy-on-write), was lineare Zeit benötigt.

Siehe auch operator=().

[noexcept] QString::QString(QString &&other)

Move-konstruiert eine QString-Instanz, die auf das gleiche Objekt zeigt, auf das other gezeigt hat.

[noexcept] QString::~QString()

Zerstört die Zeichenkette.

QString &QString::append(const QString &str)

Hängt die Zeichenfolge str an das Ende dieser Zeichenfolge an.

Beispiel:

QString x = "free";
QString y = "dom";

x.append(y);
// x == "freedom"

Dies ist dasselbe wie die Funktion insert():

x.insert(x.size(), y);

Die Funktion append() ist in der Regel sehr schnell(konstante Zeit), da QString zusätzlichen Platz am Ende der Zeichenkette reserviert, so dass sie wachsen kann, ohne jedes Mal die gesamte Zeichenkette neu zu reservieren.

Siehe auch operator+=(), prepend(), und insert().

QString &QString::append(QChar ch)

Diese Funktion überlädt append().

Hängt das Zeichen ch an diese Zeichenkette an.

QString &QString::append(QLatin1StringView str)

Diese Funktion überlastet append().

Hängt die Latin-1-Zeichenkette, die von str angezeigt wird, an diese Zeichenkette an.

[since 6.0] QString &QString::append(QStringView v)

Diese Funktion überlädt append().

Hängt die angegebene String-Ansicht v an diesen String an und gibt das Ergebnis zurück.

Diese Funktion wurde in Qt 6.0 eingeführt.

[since 6.5] QString &QString::append(QUtf8StringView str)

Diese Funktion überlastet append().

Hängt die UTF-8-String-Ansicht str an diesen String an.

Diese Funktion wurde in Qt 6.5 eingeführt.

QString &QString::append(const QByteArray &ba)

Diese Funktion überlädt append().

Hängt das Byte-Array ba an diesen String an. Das angegebene Byte-Array wird mit der Funktion fromUtf8() in Unicode konvertiert.

Sie können diese Funktion deaktivieren, indem Sie QT_NO_CAST_FROM_ASCII definieren, wenn Sie Ihre Anwendungen kompilieren. Dies kann nützlich sein, wenn Sie z.B. sicherstellen wollen, dass alle für den Benutzer sichtbaren Strings durch QObject::tr() laufen.

QString &QString::append(const char *str)

Diese Funktion überlädt append().

Hängt die Zeichenkette str an diese Zeichenkette an. Der angegebene const char-Zeiger wird mit der Funktion fromUtf8() in Unicode konvertiert.

Sie können diese Funktion deaktivieren, indem Sie QT_NO_CAST_FROM_ASCII definieren, wenn Sie Ihre Anwendungen kompilieren. Dies kann nützlich sein, wenn Sie z.B. sicherstellen wollen, dass alle für den Benutzer sichtbaren Zeichenketten QObject::tr() durchlaufen.

QString &QString::append(const QChar *str, qsizetype len)

Diese Funktion überlastet append().

Hängt len Zeichen aus dem Array QChar str an diese Zeichenkette an.

QString QString::arg(const QString &a, int fieldWidth = 0, QChar fillChar = u' ') const

Gibt eine Kopie dieser Zeichenkette zurück, bei der die niedrigste nummerierte Platzmarkierung durch die Zeichenkette a ersetzt wird, d.h. %1, %2, ..., %99.

fieldWidth gibt an, wie viel Platz das Argument a mindestens einnehmen soll. Wenn a weniger Platz benötigt als fieldWidth, wird es mit dem Zeichen fillChar auf fieldWidth aufgefüllt. Ein positiver fieldWidth erzeugt rechtsbündigen Text. Ein negativer fieldWidth erzeugt linksbündigen Text.

Dieses Beispiel zeigt, wie eine Zeichenkette status erstellt werden kann, um den Fortschritt bei der Verarbeitung einer Liste von Dateien zu melden:

QString i;           // current file's number
QString total;       // number of files to process
QString fileName;    // current file's name

QString status = QString("Processing file %1 of %2: %3")
                .arg(i).arg(total).arg(fileName);

Zuerst ersetzt arg(i) %1 . Dann ersetzt arg(total) %2 . Schließlich ersetzt arg(fileName) %3 .

Ein Vorteil der Verwendung von arg() gegenüber asprintf() ist, dass sich die Reihenfolge der nummerierten Platzhalter ändern kann, wenn die Zeichenketten der Anwendung in andere Sprachen übersetzt werden, aber jeder arg() ersetzt immer noch den niedrigsten nummerierten, nicht ersetzten Platzhalter, unabhängig davon, wo er erscheint. Auch wenn die Ortsmarke %i mehr als einmal in der Zeichenkette vorkommt, ersetzt arg() alle.

Wenn keine unersetzte Platzmarke mehr vorhanden ist, wird eine Warnmeldung ausgegeben und das Ergebnis ist undefiniert. Die Nummern der Ortsmarken müssen im Bereich von 1 bis 99 liegen.

QString QString::arg(QChar a, int fieldWidth = 0, QChar fillChar = u' ') const

Diese Funktion überlastet arg().

QString QString::arg(QLatin1StringView a, int fieldWidth = 0, QChar fillChar = u' ') const

Dies ist eine überladene Funktion.

Gibt eine Kopie dieser Zeichenkette zurück, bei der der niedrigste Platzhalter durch die von a betrachtete Latin-1-Zeichenkette ersetzt wird, d.h. %1, %2, ..., %99.

fieldWidth gibt an, wie viel Platz a mindestens beanspruchen soll. Benötigt a weniger Platz als fieldWidth, wird es mit dem Zeichen fillChar auf fieldWidth aufgefüllt. Ein positiver fieldWidth erzeugt rechtsbündigen Text. Ein negativer fieldWidth erzeugt linksbündigen Text.

Ein Vorteil der Verwendung von arg() gegenüber asprintf() ist, dass sich die Reihenfolge der nummerierten Platzhalter ändern kann, wenn die Zeichenketten der Anwendung in andere Sprachen übersetzt werden, aber jeder arg() ersetzt immer noch den niedrigsten nummerierten, nicht ersetzten Platzhalter, egal wo er erscheint. Auch wenn die Platzhalter %i mehr als einmal in der Zeichenkette vorkommen, ersetzt arg() alle.

Wenn keine unersetzten Platzhalter übrig bleiben, wird eine Warnmeldung ausgegeben und das Ergebnis ist undefiniert. Die Nummern der Platzhalter müssen im Bereich von 1 bis 99 liegen.

QString QString::arg(QStringView a, int fieldWidth = 0, QChar fillChar = u' ') const

Dies ist eine überladene Funktion.

Gibt eine Kopie dieser Zeichenkette zurück, bei der die niedrigste Platzmarkierung durch die Zeichenkette a ersetzt wird, d.h. %1, %2, ..., %99.

fieldWidth gibt den minimalen Platz an, den a einnehmen soll. Benötigt a weniger Platz als fieldWidth, wird es mit dem Zeichen fillChar an fieldWidth aufgefüllt. Ein positiver fieldWidth erzeugt rechtsbündigen Text. Ein negativer fieldWidth erzeugt linksbündigen Text.

Dieses Beispiel zeigt, wie eine Zeichenkette status erstellt werden kann, um den Fortschritt bei der Verarbeitung einer Liste von Dateien zu melden:

int i;                // current file's number
int total;            // number of files to process
QStringView fileName; // current file's name

QString status = QString("Processing file %1 of %2: %3")
                .arg(i).arg(total).arg(fileName);

Zuerst ersetzt arg(i) %1 . Dann ersetzt arg(total) %2 . Schließlich ersetzt arg(fileName) %3 .

Ein Vorteil der Verwendung von arg() gegenüber asprintf() ist, dass sich die Reihenfolge der nummerierten Platzhalter ändern kann, wenn die Zeichenketten der Anwendung in andere Sprachen übersetzt werden, aber jeder arg() ersetzt immer noch den niedrigsten nummerierten, nicht ersetzten Platzhalter, egal, wo er erscheint. Auch wenn die Platzhalter %i mehr als einmal in der Zeichenkette vorkommen, ersetzt arg() alle.

Wenn keine unersetzten Platzhalter übrig bleiben, wird eine Warnmeldung ausgegeben und das Ergebnis ist undefiniert. Die Nummern der Platzhalter müssen im Bereich von 1 bis 99 liegen.

QString QString::arg(char a, int fieldWidth = 0, QChar fillChar = u' ') const

Diese Funktion überlastet arg().

Das Argument a wird als ein Latin-1-Zeichen interpretiert.

QString QString::arg(int a, int fieldWidth = 0, int base = 10, QChar fillChar = u' ') const

Diese Funktion überlastet arg().

Das Argument a wird in der Basis base ausgedrückt, die standardmäßig 10 ist und zwischen 2 und 36 liegen muss. Für andere Basen als 10 wird a als Ganzzahl ohne Vorzeichen behandelt.

fieldWidth gibt den minimalen Abstand an, um den a aufgefüllt und mit dem Zeichen fillChar gefüllt wird. Ein positiver Wert erzeugt rechtsbündigen Text; ein negativer Wert erzeugt linksbündigen Text.

Dem '%' kann ein 'L' folgen; in diesem Fall wird die Sequenz durch eine lokalisierte Darstellung von a ersetzt. Die Konvertierung verwendet das Standardgebietsschema, das durch QLocale::setDefault() festgelegt wurde. Wenn kein Standardgebietsschema angegeben wurde, wird das Systemgebietsschema verwendet. Das Flag 'L' wird ignoriert, wenn base nicht 10 ist.

QString str;
str = QString("Decimal 63 is %1 in hexadecimal")
        .arg(63, 0, 16);
// str == "Decimal 63 is 3f in hexadecimal"

QLocale::setDefault(QLocale(QLocale::English, QLocale::UnitedStates));
str = QString("%1 %L2 %L3")
        .arg(12345)
        .arg(12345)
        .arg(12345, 0, 16);
// str == "12345 12,345 3039"

Siehe auch Number Formats.

QString QString::arg(long a, int fieldWidth = 0, int base = 10, QChar fillChar = u' ') const

Diese Funktion überlastet arg().

fieldWidth gibt den Mindestabstand an, um den a aufgefüllt und mit dem Zeichen fillChar gefüllt wird. Ein positiver Wert erzeugt rechtsbündigen Text; ein negativer Wert erzeugt linksbündigen Text.

Das Argument a wird in der angegebenen base ausgedrückt, die standardmäßig 10 ist und zwischen 2 und 36 liegen muss.

Dem '%' kann ein 'L' folgen; in diesem Fall wird die Sequenz durch eine lokalisierte Darstellung von a ersetzt. Die Konvertierung verwendet das Standardgebietsschema. Das Standardgebietsschema wird aus den Gebietsschemaeinstellungen des Systems beim Starten der Anwendung ermittelt. Sie kann mit QLocale::setDefault() geändert werden. Das Flag 'L' wird ignoriert, wenn base nicht 10 ist.

QString str;
str = QString("Decimal 63 is %1 in hexadecimal")
        .arg(63, 0, 16);
// str == "Decimal 63 is 3f in hexadecimal"

QLocale::setDefault(QLocale(QLocale::English, QLocale::UnitedStates));
str = QString("%1 %L2 %L3")
        .arg(12345)
        .arg(12345)
        .arg(12345, 0, 16);
// str == "12345 12,345 3039"

Siehe auch Number Formats.

QString QString::arg(qlonglong a, int fieldWidth = 0, int base = 10, QChar fillChar = u' ') const

Diese Funktion überlastet arg().

fieldWidth gibt den Mindestabstand an, um den a aufgefüllt und mit dem Zeichen fillChar gefüllt wird. Ein positiver Wert erzeugt rechtsbündigen Text; ein negativer Wert erzeugt linksbündigen Text.

Das Argument base gibt die Basis an, die bei der Umwandlung der Ganzzahl a in eine Zeichenkette verwendet werden soll. Die Basis muss zwischen 2 und 36 liegen, wobei 8 oktale, 10 dezimale und 16 hexadezimale Zahlen ergibt.

Siehe auch Number Formats.

QString QString::arg(qulonglong a, int fieldWidth = 0, int base = 10, QChar fillChar = u' ') const

Diese Funktion überlastet arg().

fieldWidth gibt den Mindestabstand an, um den a aufgefüllt und mit dem Zeichen fillChar gefüllt wird. Ein positiver Wert erzeugt rechtsbündigen Text; ein negativer Wert erzeugt linksbündigen Text.

Das Argument base gibt die Basis an, die bei der Umwandlung der Ganzzahl a in eine Zeichenkette verwendet werden soll. base muss zwischen 2 und 36 liegen, wobei 8 oktale, 10 dezimale und 16 hexadezimale Zahlen ergibt.

Siehe auch Number Formats.

QString QString::arg(short a, int fieldWidth = 0, int base = 10, QChar fillChar = u' ') const

Diese Funktion überlastet arg().

fieldWidth gibt den Mindestabstand an, um den a aufgefüllt und mit dem Zeichen fillChar gefüllt wird. Ein positiver Wert erzeugt rechtsbündigen Text; ein negativer Wert erzeugt linksbündigen Text.

Das Argument base gibt die Basis an, die bei der Umwandlung der Ganzzahl a in eine Zeichenkette verwendet werden soll. Die Basis muss zwischen 2 und 36 liegen, wobei 8 oktale, 10 dezimale und 16 hexadezimale Zahlen ergibt.

Siehe auch Number Formats.

QString QString::arg(uint a, int fieldWidth = 0, int base = 10, QChar fillChar = u' ') const

Diese Funktion überlastet arg().

Das Argument base gibt die Basis an, die bei der Umwandlung der Ganzzahl a in eine Zeichenkette verwendet werden soll. Die Basis muss zwischen 2 und 36 liegen.

Siehe auch Number Formats.

QString QString::arg(ulong a, int fieldWidth = 0, int base = 10, QChar fillChar = u' ') const

Diese Funktion überlastet arg().

fieldWidth gibt den Mindestabstand an, um den a aufgefüllt und mit dem Zeichen fillChar gefüllt wird. Ein positiver Wert erzeugt rechtsbündigen Text; ein negativer Wert erzeugt linksbündigen Text.

Das Argument base gibt die Basis an, die bei der Konvertierung der Ganzzahl a in eine Zeichenkette verwendet werden soll. Die Basis muss zwischen 2 und 36 liegen, wobei 8 oktale, 10 dezimale und 16 hexadezimale Zahlen ergibt.

Siehe auch Number Formats.

QString QString::arg(ushort a, int fieldWidth = 0, int base = 10, QChar fillChar = u' ') const

Diese Funktion überlastet arg().

fieldWidth gibt den Mindestabstand an, um den a aufgefüllt und mit dem Zeichen fillChar gefüllt wird. Ein positiver Wert erzeugt rechtsbündigen Text; ein negativer Wert erzeugt linksbündigen Text.

Das Argument base gibt die Basis an, die bei der Umwandlung der Ganzzahl a in eine Zeichenkette verwendet werden soll. Die Basis muss zwischen 2 und 36 liegen, wobei 8 oktale, 10 dezimale und 16 hexadezimale Zahlen ergibt.

Siehe auch Number Formats.

QString QString::arg(double a, int fieldWidth = 0, char format = 'g', int precision = -1, QChar fillChar = u' ') const

Diese Funktion überlastet arg().

Das Argument a wird entsprechend den angegebenen format und precision formatiert. Siehe Floating-point Formats für Details.

fieldWidth gibt den minimalen Abstand an, um den a aufgefüllt und mit dem Zeichen fillChar gefüllt wird. Ein positiver Wert erzeugt rechtsbündigen Text; ein negativer Wert erzeugt linksbündigen Text.

double d = 12.34;
QString str = QString("delta: %1").arg(d, 0, 'E', 3);
// str == "delta: 1.234E+01"

Siehe auch QLocale::toString(), QLocale::FloatingPointPrecisionOption, und Number Formats.

[static] QString QString::asprintf(const char *cformat, ...)

Erstellt auf sichere Weise eine formatierte Zeichenkette aus der Formatzeichenkette cformat und einer beliebigen Liste von Argumenten.

Die Formatzeichenkette unterstützt die Konvertierungsspezifizierer, Längenmodifikatoren und Flags, die von printf() in der Standard-C++-Bibliothek bereitgestellt werden. Die Zeichenfolge cformat und die Argumente %s müssen in UTF-8 kodiert sein.

QString result;
QTextStream(&result) << "pi = " << 3.14;
// result == "pi = 3.14"

Für translations, insbesondere wenn die Zeichenkette mehr als eine Escape-Sequenz enthält, sollten Sie stattdessen die Funktion arg() verwenden. Dadurch kann die Reihenfolge der Ersetzungen vom Übersetzer gesteuert werden.

Siehe auch arg().

[since 6.6] QString &QString::assign(QAnyStringView v)

Ersetzt den Inhalt dieser Zeichenfolge durch eine Kopie von v und gibt einen Verweis auf diese Zeichenfolge zurück.

Die Größe dieser Zeichenkette entspricht der Größe von v, konvertiert nach UTF-16 wie bei v.toString(). Anders als QAnyStringView::toString() weist diese Funktion jedoch nur dann Speicher zu, wenn die geschätzte Größe die Kapazität dieses Strings übersteigt oder dieser String gemeinsam genutzt wird.

Diese Funktion wurde in Qt 6.6 eingeführt.

Siehe auch QAnyStringView::toString().

[since 6.6] template <typename InputIterator, QString::if_compatible_iterator<InputIterator> = true> QString &QString::assign(InputIterator first, InputIterator last)

Ersetzt den Inhalt dieser Zeichenkette durch eine Kopie der Elemente im Iteratorbereich [first, last) und gibt eine Referenz auf diese Zeichenkette zurück.

Die Größe dieser Zeichenkette entspricht der dekodierten Länge der Elemente im Bereich [first, last), die nicht mit der Länge des Bereichs selbst übereinstimmen muss, da diese Funktion den Eingabezeichensatz transparent in UTF-16 umkodiert.

Diese Funktion weist nur dann Speicher zu, wenn die Anzahl der Elemente im Bereich oder, bei nicht UTF-16-kodierten Eingaben, die maximal mögliche Größe der resultierenden Zeichenkette die Kapazität dieser Zeichenkette übersteigt, oder wenn diese Zeichenkette gemeinsam genutzt wird.

• QChar
• QLatin1Char
• char
• unsigned char
• signed char
• char8_t
• char16_t
• (auf Plattformen, wie z. B. Windows, wo es sich um einen 16-Bit-Typ handelt) wchar_t
• char32_t

Diese Funktion wurde in Qt 6.6 eingeführt.

[since 6.6] QString &QString::assign(qsizetype n, QChar c)

Ersetzt den Inhalt dieser Zeichenkette durch n Kopien von c und gibt einen Verweis auf diese Zeichenkette zurück.

Die Größe dieser Zeichenkette ist gleich n, die nicht negativ sein darf.

Diese Funktion weist nur dann Speicher zu, wenn n die Kapazität dieses Strings überschreitet oder dieser String gemeinsam genutzt wird.

Diese Funktion wurde in Qt 6.6 eingeführt.

Siehe auch fill().

const QChar QString::at(qsizetype position) const

Gibt das Zeichen am angegebenen Index position in der Zeichenkette zurück.

position muss eine gültige Indexposition in der Zeichenkette sein (d. h. 0 <= position < size()).

Siehe auch operator[]().

QChar &QString::back()

Gibt einen Verweis auf das letzte Zeichen in der Zeichenkette zurück. Dasselbe wie operator[](size() - 1).

Diese Funktion wird aus Gründen der STL-Kompatibilität bereitgestellt.

Siehe auch front(), at(), und operator[]().

QChar QString::back() const

Gibt das letzte Zeichen der Zeichenkette zurück. Dasselbe wie at(size() - 1).

Diese Funktion wird aus Gründen der STL-Kompatibilität bereitgestellt.

Siehe auch front(), at(), und operator[]().

QString::iterator QString::begin()

Gibt einen Iterator im STL-Stil zurück, der auf das erste Zeichen der Zeichenkette zeigt.

Siehe auch constBegin() und end().

QString::const_iterator QString::begin() const

Diese Funktion überlastet begin().

qsizetype QString::capacity() const

Gibt die maximale Anzahl von Zeichen zurück, die in der Zeichenkette gespeichert werden können, ohne eine Neuzuweisung zu erzwingen.

Der einzige Zweck dieser Funktion besteht darin, die Speichernutzung von QString fein abzustimmen. Im Allgemeinen werden Sie diese Funktion nur selten aufrufen müssen. Wenn Sie wissen wollen, wie viele Zeichen in der Zeichenkette enthalten sind, rufen Sie size() auf.

Siehe auch reserve() und squeeze().

QString::const_iterator QString::cbegin() const

Gibt einen const STL-artigen Iterator zurück, der auf das erste Zeichen in der Zeichenkette zeigt.

Siehe auch begin() und cend().

QString::const_iterator QString::cend() const

Gibt einen Iterator im Stil von const STL zurück, der direkt auf das letzte Zeichen in der Zeichenkette zeigt.

Siehe auch cbegin() und end().

void QString::chop(qsizetype n)

Entfernt n Zeichen vom Ende der Zeichenkette.

Wenn n größer oder gleich size() ist, ist das Ergebnis eine leere Zeichenkette; wenn n negativ ist, entspricht dies der Übergabe von Null.

Beispiel:

QString str("LOGOUT\r\n");
str.chop(2);
// str == "LOGOUT"

Wenn Sie Zeichen vom Anfang der Zeichenkette entfernen wollen, verwenden Sie stattdessen remove().

Siehe auch truncate(), resize(), remove(), und QStringView::chop().

void QString::clear()

Löscht den Inhalt der Zeichenkette und macht sie null.

Siehe auch resize() und isNull().

[static noexcept] int QString::compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Vergleicht die Zeichenkette s1 mit der Zeichenkette s2 und gibt eine negative Ganzzahl zurück, wenn s1 kleiner als s2 ist, eine positive Ganzzahl, wenn sie größer als s2 ist, und Null, wenn sie gleich sind.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Der Vergleich unter Berücksichtigung der Groß- und Kleinschreibung basiert ausschließlich auf den numerischen Unicode-Werten der Zeichen und ist sehr schnell, entspricht aber nicht den Erwartungen eines Menschen. Erwägen Sie die Sortierung von für den Benutzer sichtbaren Zeichenketten mit localeAwareCompare().

int x = QString::compare("aUtO", "AuTo", Qt::CaseInsensitive);  // x == 0
int y = QString::compare("auto", "Car", Qt::CaseSensitive);     // y > 0
int z = QString::compare("auto", "Car", Qt::CaseInsensitive);   // z < 0

Siehe auch operator==(), operator<(), operator>(), und Comparing Strings.

[noexcept] int QString::compare(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlädt compare().

Führt einen Vergleich von this mit ch durch, wobei die Groß- und Kleinschreibung beachtet wird cs.

[noexcept] int QString::compare(QLatin1StringView other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet compare().

Dasselbe wie compare(*this, other, cs).

[noexcept] int QString::compare(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlädt compare().

Führt einen Vergleich von this mit s durch, wobei die Groß- und Kleinschreibung beachtet wird cs.

[noexcept] int QString::compare(const QString &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet compare().

Vergleicht diese Zeichenkette lexikalisch mit der Zeichenkette other und gibt eine negative Ganzzahl zurück, wenn diese Zeichenkette kleiner als other ist, eine positive Ganzzahl, wenn sie größer als other ist, und Null, wenn sie gleich sind.

Dasselbe wie compare(*this, other, cs).

[static noexcept] int QString::compare(QLatin1StringView s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Diese Funktion überlädt compare().

Führt einen Vergleich zwischen s1 und s2 durch, wobei die Groß- und Kleinschreibung beachtet wird cs.

[static noexcept] int QString::compare(QStringView s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Diese Funktion überlastet compare().

[static noexcept] int QString::compare(const QString &s1, QLatin1StringView s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Diese Funktion überlädt compare().

Führt einen Vergleich zwischen s1 und s2 durch, wobei die Groß- und Kleinschreibung beachtet wird cs.

[static noexcept] int QString::compare(const QString &s1, QStringView s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Diese Funktion überlastet compare().

QString::const_iterator QString::constBegin() const

Gibt einen const STL-artigen Iterator zurück, der auf das erste Zeichen in der Zeichenkette zeigt.

Siehe auch begin() und constEnd().

const QChar *QString::constData() const

Gibt einen Zeiger auf die in QString gespeicherten Daten zurück. Der Zeiger kann verwendet werden, um auf die Zeichen zuzugreifen, aus denen die Zeichenkette besteht.

Beachten Sie, dass der Zeiger nur so lange gültig ist, wie die Zeichenkette nicht geändert wird.

Siehe auch data(), operator[](), und fromRawData().

QString::const_iterator QString::constEnd() const

Gibt einen Iterator im Stil von const STL zurück, der direkt auf das letzte Zeichen in der Zeichenkette zeigt.

Siehe auch constBegin() und end().

bool QString::contains(const QRegularExpression &re, QRegularExpressionMatch *rmatch = nullptr) const

Gibt true zurück, wenn der reguläre Ausdruck re irgendwo in dieser Zeichenkette übereinstimmt; andernfalls wird false zurückgegeben.

Wenn die Übereinstimmung erfolgreich ist und rmatch nicht nullptr ist, werden die Ergebnisse der Übereinstimmung auch in das Objekt QRegularExpressionMatch geschrieben, auf das rmatch verweist.

Siehe auch QRegularExpression::match().

bool QString::contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Gibt true zurück, wenn diese Zeichenkette ein Vorkommen der Zeichenkette str enthält; andernfalls wird false zurückgegeben.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Beispiel:

QString str = "Peter Pan";
str.contains("peter", Qt::CaseInsensitive);    // returns true

Siehe auch indexOf() und count().

bool QString::contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet contains().

Gibt true zurück, wenn diese Zeichenkette ein Vorkommen des Zeichens ch enthält; andernfalls gibt sie false zurück.

bool QString::contains(QLatin1StringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet contains().

Gibt true zurück, wenn diese Zeichenkette ein Vorkommen der Latin-1-Zeichenkette str enthält; andernfalls wird false zurückgegeben.

[noexcept] bool QString::contains(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet contains().

Gibt true zurück, wenn diese Zeichenkette ein Vorkommen der Zeichenkettenansicht str enthält; andernfalls gibt sie false zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Siehe auch indexOf() und count().

qsizetype QString::count(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Gibt die Anzahl der (sich möglicherweise überschneidenden) Vorkommen der Zeichenfolge str in dieser Zeichenfolge zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Siehe auch contains() und indexOf().

qsizetype QString::count(const QRegularExpression &re) const

Diese Funktion überlastet count().

Gibt die Anzahl der Übereinstimmungen des regulären Ausdrucks re in der Zeichenkette zurück.

Aus historischen Gründen zählt diese Funktion sich überschneidende Übereinstimmungen, so dass es im folgenden Beispiel vier Instanzen von "ana" oder "ama" gibt:

QString str = "banana and panama";
str.count(QRegularExpression("a[nm]a"));    // returns 4

Dieses Verhalten unterscheidet sich von der einfachen Iteration über die Übereinstimmungen in der Zeichenkette mit QRegularExpressionMatchIterator.

Siehe auch QRegularExpression::globalMatch().

qsizetype QString::count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet count().

Gibt die Anzahl der Vorkommen des Zeichens ch in der Zeichenkette zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Siehe auch contains() und indexOf().

[since 6.0] qsizetype QString::count(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet count().

Gibt die Anzahl der (sich möglicherweise überschneidenden) Vorkommen der Zeichenkette view str in dieser Zeichenkette zurück.

Wenn cs gleich Qt::CaseSensitive ist (die Vorgabe), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird zwischen Groß- und Kleinschreibung nicht unterschieden.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch contains() und indexOf().

QString::const_reverse_iterator QString::crbegin() const

Gibt einen const STL-ähnlichen Reverse-Iterator zurück, der auf das erste Zeichen der Zeichenkette in umgekehrter Reihenfolge zeigt.

Siehe auch begin(), rbegin(), und rend().

QString::const_reverse_iterator QString::crend() const

Gibt einen const STL-ähnlichen Reverse-Iterator zurück, der in umgekehrter Reihenfolge direkt auf das letzte Zeichen der Zeichenkette zeigt.

Siehe auch end(), rend(), und rbegin().

QChar *QString::data()

Gibt einen Zeiger auf die in QString gespeicherten Daten zurück. Der Zeiger kann verwendet werden, um auf die Zeichen zuzugreifen, aus denen die Zeichenkette besteht, und diese zu ändern.

Im Gegensatz zu constData() und unicode() sind die zurückgegebenen Daten immer '\0'-terminiert.

Beispiel:

QString str = "Hallo Welt";QChar *data = str.data();while (!data->isNull()) {    qDebug() << data->unicode();
   ++data; }

Beachten Sie, dass der Zeiger nur so lange gültig ist, wie die Zeichenkette nicht auf andere Weise verändert wird. Beim Nur-Lese-Zugriff ist constData() schneller, da es nie zu einer Tiefenkopie kommt.

Siehe auch constData() und operator[]().

const QChar *QString::data() const

Dies ist eine überladene Funktion.

Siehe auch fromRawData().

QString::iterator QString::end()

Gibt einen Iterator im STL-Stil zurück, der direkt auf das letzte Zeichen in der Zeichenkette zeigt.

Siehe auch begin() und constEnd().

QString::const_iterator QString::end() const

Diese Funktion überlastet end().

bool QString::endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Gibt true zurück, wenn die Zeichenfolge mit s endet; andernfalls wird false zurückgegeben.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird zwischen Groß- und Kleinschreibung nicht unterschieden.

QString str = "Bananas";
str.endsWith("anas");         // returns true
str.endsWith("pple");         // returns false

Siehe auch startsWith().

bool QString::endsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Gibt true zurück, wenn die Zeichenkette mit c endet; andernfalls wird false zurückgegeben.

Diese Funktion überlastet endsWith().

bool QString::endsWith(QLatin1StringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet endsWith().

[noexcept] bool QString::endsWith(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet endsWith().

Gibt true zurück, wenn die Zeichenfolge mit der Zeichenfolgenansicht str endet; andernfalls gibt sie false zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Siehe auch startsWith().

[since 6.1] QString::iterator QString::erase(QString::const_iterator first, QString::const_iterator last)

Entfernt aus der Zeichenkette die Zeichen im halboffenen Bereich [ first, last ). Gibt einen Iterator zu dem Zeichen unmittelbar nach dem letzten gelöschten Zeichen zurück (d.h. das Zeichen, auf das last vor dem Löschen verweist).

Diese Funktion wurde in Qt 6.1 eingeführt.

[since 6.5] QString::iterator QString::erase(QString::const_iterator it)

Dies ist eine überladene Funktion.

Entfernt das durch it bezeichnete Zeichen aus der Zeichenkette. Gibt einen Iterator zu dem Zeichen unmittelbar nach dem gelöschten Zeichen zurück.

QString c = "abcdefg";
auto it = c.erase(c.cbegin()); // c is now "bcdefg"; "it" points to "b"

Diese Funktion wurde in Qt 6.5 eingeführt.

QString &QString::fill(QChar ch, qsizetype size = -1)

Setzt jedes Zeichen in der Zeichenkette auf das Zeichen ch. Wenn size ungleich -1 ist (Voreinstellung), wird die Zeichenkette vorher auf size umgestellt.

Beispiel:

QString str = "Berlin";
str.fill('z');
// str == "zzzzzz"

str.fill('A', 2);
// str == "AA"

Siehe auch resize().

[static] QString QString::fromCFString(CFStringRef string)

Konstruiert eine neue QString, die eine Kopie des string CFString enthält.

[static, since 6.6] QString QString::fromEcmaString(emscripten::val jsString)

Konvertiert den ECMAScript-String jsString nach QString. Das Verhalten ist undefiniert, wenn der übergebene Parameter kein String ist.

Diese Funktion wurde in Qt 6.6 eingeführt.

Siehe auch toEcmaString().

[static] QString QString::fromLatin1(const char *str, qsizetype size)

Gibt ein QString zurück, das mit den ersten size Zeichen der Latin-1 Zeichenkette str initialisiert ist.

Wenn size -1 ist, wird stattdessen strlen(str) verwendet.

Siehe auch toLatin1(), fromUtf8(), und fromLocal8Bit().

[static, since 6.0] QString QString::fromLatin1(QByteArrayView str)

Dies ist eine überladene Funktion.

Gibt eine QString zurück, die mit der Latin-1-Zeichenkette str initialisiert ist.

Diese Funktion wurde in Qt 6.0 eingeführt.

[static] QString QString::fromLatin1(const QByteArray &str)

Dies ist eine überladene Funktion.

Gibt eine QString zurück, die mit der Latin-1-Zeichenkette str initialisiert ist.

[static] QString QString::fromLocal8Bit(const char *str, qsizetype size)

Gibt ein QString zurück, das mit den ersten size Zeichen der 8-Bit-Zeichenkette str initialisiert ist.

Wenn size -1 ist, wird stattdessen strlen(str) verwendet.

Auf Unix-Systemen ist dies äquivalent zu fromUtf8(). Beachten Sie, dass diese Funktion auf Apple-Systemen NSString.defaultCStringEncoding oder CFStringGetSystemEncoding() nicht berücksichtigt, da diese Funktionen typischerweise die veraltete "Western (Mac OS Roman)"-Kodierung zurückgeben, die auf modernen Apple-Betriebssystemen nicht verwendet werden sollte. Unter Windows wird die aktuelle Codepage des Systems verwendet.

Siehe auch toLocal8Bit(), fromLatin1(), und fromUtf8().

[static, since 6.0] QString QString::fromLocal8Bit(QByteArrayView str)

Dies ist eine überladene Funktion.

Gibt ein QString zurück, das mit der 8-Bit-Zeichenkette str initialisiert ist.

Auf Unix-Systemen ist dies äquivalent zu fromUtf8(). Beachten Sie, dass diese Funktion auf Apple-Systemen NSString.defaultCStringEncoding oder CFStringGetSystemEncoding() nicht berücksichtigt, da diese Funktionen typischerweise die veraltete "Western (Mac OS Roman)"-Kodierung zurückgeben, die auf modernen Apple-Betriebssystemen nicht verwendet werden sollte. Unter Windows wird die aktuelle Codepage des Systems verwendet.

Diese Funktion wurde in Qt 6.0 eingeführt.

[static] QString QString::fromLocal8Bit(const QByteArray &str)

Dies ist eine überladene Funktion.

Gibt ein QString zurück, das mit der 8-Bit-Zeichenkette str initialisiert ist.

Auf Unix-Systemen ist dies äquivalent zu fromUtf8(). Beachten Sie, dass diese Funktion auf Apple-Systemen NSString.defaultCStringEncoding oder CFStringGetSystemEncoding() nicht berücksichtigt, da diese Funktionen typischerweise die veraltete "Western (Mac OS Roman)"-Kodierung zurückgeben, die auf modernen Apple-Betriebssystemen nicht verwendet werden sollte. Unter Windows wird die aktuelle Codepage des Systems verwendet.

[static] QString QString::fromNSString(const NSString *string)

Konstruiert eine neue QString, die eine Kopie des string NSString enthält.

[static] QString QString::fromRawData(const QChar *unicode, qsizetype size)

Konstruiert ein QString, das die ersten size Unicode-Zeichen in dem Array unicode verwendet. Die Daten in unicode werden nicht kopiert. Der Aufrufer muss garantieren können, dass unicode nicht gelöscht oder verändert wird, solange QString (oder eine unveränderte Kopie davon) existiert.

Jeder Versuch, QString oder Kopien davon zu verändern, führt dazu, dass eine Tiefenkopie der Daten erstellt wird, um sicherzustellen, dass die Rohdaten nicht verändert werden.

Hier ein Beispiel für die Verwendung von QRegularExpression auf Rohdaten im Speicher, ohne dass die Daten in eine QString kopiert werden müssen:

QRegularExpression pattern("\u00A4");
static const QChar unicode[] = {
        0x005A, 0x007F, 0x00A4, 0x0060,
        0x1009, 0x0020, 0x0020};
qsizetype size = sizeof(unicode) / sizeof(QChar);

QString str = QString::fromRawData(unicode, size);
if (str.contains(pattern) {
    // ...
}

Siehe auch fromUtf16() und setRawData().

[static] QString QString::fromStdString(const std::string &str)

Gibt eine Kopie der Zeichenkette str zurück. Es wird angenommen, dass die angegebene Zeichenkette in UTF-8 kodiert ist und mit der Funktion fromUtf8() in QString umgewandelt wird.

Siehe auch fromLatin1(), fromLocal8Bit(), fromUtf8(), und QByteArray::fromStdString().

[static] QString QString::fromStdU16String(const std::u16string &str)

Gibt eine Kopie der Zeichenkette str zurück. Es wird angenommen, dass die angegebene Zeichenkette in UTF-16 kodiert ist und mit der Funktion fromUtf16() in QString umgewandelt wird.

Siehe auch fromUtf16(), fromStdWString(), und fromStdU32String().

[static] QString QString::fromStdU32String(const std::u32string &str)

Gibt eine Kopie der Zeichenkette str zurück. Es wird angenommen, dass die angegebene Zeichenkette in UTF-32 kodiert ist und mit der Funktion fromUcs4() in QString umgewandelt wird.

Siehe auch fromUcs4(), fromStdWString(), und fromStdU16String().

[static] QString QString::fromStdWString(const std::wstring &str)

Gibt eine Kopie der Zeichenkette str zurück. Es wird angenommen, dass die angegebene Zeichenkette in utf16 kodiert ist, wenn die Größe von wchar_t 2 Bytes beträgt (z.B. unter Windows) und ucs4, wenn die Größe von wchar_t 4 Bytes beträgt (die meisten Unix-Systeme).

Siehe auch fromUtf16(), fromLatin1(), fromLocal8Bit(), fromUtf8(), fromUcs4(), fromStdU16String(), und fromStdU32String().

[static] QString QString::fromUcs4(const char32_t *unicode, qsizetype size = -1)

Gibt ein QString zurück, das mit den ersten size Zeichen der Unicode-Zeichenfolge unicode (kodiert als UTF-32) initialisiert ist.

Wenn size gleich -1 ist (Voreinstellung), muss unicode mit \0' abgeschlossen werden.

Siehe auch toUcs4(), fromUtf16(), utf16(), setUtf16(), fromWCharArray(), und fromStdU32String().

[static] QString QString::fromUtf8(const char *str, qsizetype size)

Gibt ein QString zurück, das mit den ersten size Bytes der UTF-8 Zeichenkette str initialisiert ist.

Wenn size -1 ist, wird stattdessen strlen(str) verwendet.

UTF-8 ist ein Unicode-Codec und kann alle Zeichen in einer Unicode-Zeichenkette wie QString darstellen. Ungültige Sequenzen sind jedoch mit UTF-8 möglich, und wenn solche gefunden werden, werden sie durch ein oder mehrere "Ersatzzeichen" ersetzt oder unterdrückt. Dazu gehören Nicht-Unicode-Sequenzen, Nicht-Zeichen, überlange Sequenzen oder in UTF-8 kodierte Surrogat-Codepoints.

Diese Funktion kann verwendet werden, um eingehende Daten inkrementell zu verarbeiten, solange alle UTF-8-Zeichen innerhalb der eingehenden Daten terminiert werden. Alle nicht beendeten Zeichen am Ende des Strings werden ersetzt oder unterdrückt. Um eine zustandsabhängige Dekodierung durchzuführen, verwenden Sie bitte QStringDecoder.

Siehe auch toUtf8(), fromLatin1(), und fromLocal8Bit().

[static, since 6.0] QString QString::fromUtf8(QByteArrayView str)

Dies ist eine überladene Funktion.

Gibt eine QString zurück, die mit dem UTF-8-String str initialisiert ist.

Diese Funktion wurde in Qt 6.0 eingeführt.

[static] QString QString::fromUtf8(const QByteArray &str)

Dies ist eine überladene Funktion.

Gibt eine QString zurück, die mit dem UTF-8-String str initialisiert ist.

[static, since 6.1] QString QString::fromUtf8(const char8_t *str)

Dies ist eine überladene Funktion.

Diese Überladung ist nur beim Kompilieren im C++20-Modus verfügbar.

Diese Funktion wurde in Qt 6.1 eingeführt.

[static, since 6.0] QString QString::fromUtf8(const char8_t *str, qsizetype size)

Dies ist eine überladene Funktion.

Diese Überladung ist nur beim Kompilieren im C++20-Modus verfügbar.

Diese Funktion wurde in Qt 6.0 eingeführt.

[static] QString QString::fromUtf16(const char16_t *unicode, qsizetype size = -1)

Gibt ein QString zurück, das mit den ersten size Zeichen der Unicode-Zeichenkette unicode (ISO-10646-UTF-16 kodiert) initialisiert ist.

Wenn size gleich -1 ist (Voreinstellung), muss unicode mit \0'- abgeschlossen werden.

Diese Funktion prüft auf ein Byte Order Mark (BOM). Fehlt sie, wird die Byte-Reihenfolge des Hosts angenommen.

Diese Funktion ist im Vergleich zu den anderen Unicode-Konvertierungen langsam. Verwenden Sie QString(const QChar *, qsizetype) oder QString(const QChar *) wenn möglich.

QString erstellt eine Tiefenkopie der Unicode-Daten.

Siehe auch utf16(), setUtf16(), und fromStdU16String().

[static] QString QString::fromWCharArray(const wchar_t *string, qsizetype size = -1)

Liest die ersten size Codeeinheiten des Arrays wchar_t, auf dessen Anfang string zeigt, konvertiert sie in Unicode und gibt das Ergebnis als QString zurück. Die von wchar_t verwendete Kodierung wird als UTF-32 angenommen, wenn die Größe des Typs vier Bytes beträgt, oder als UTF-16, wenn die Größe zwei Bytes beträgt.

Wenn size -1 ist (Voreinstellung), muss string mit '\0' abgeschlossen werden.

Siehe auch fromUtf16(), fromLatin1(), fromLocal8Bit(), fromUtf8(), fromUcs4(), und fromStdWString().

QChar &QString::front()

Gibt einen Verweis auf das erste Zeichen in der Zeichenkette zurück. Dasselbe wie operator[](0).

Diese Funktion wird aus Gründen der STL-Kompatibilität bereitgestellt.

Siehe auch back(), at(), und operator[]().

QChar QString::front() const

Gibt das erste Zeichen der Zeichenkette zurück. Dasselbe wie at(0).

Diese Funktion wird aus Gründen der STL-Kompatibilität bereitgestellt.

Siehe auch back(), at(), und operator[]().

qsizetype QString::indexOf(QLatin1StringView str, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Gibt die Indexposition des ersten Vorkommens der Latin-1-Zeichenkette zurück, die von str in dieser Zeichenkette betrachtet wird, wobei ab der Indexposition from vorwärts gesucht wird. Gibt -1 zurück, wenn str nicht gefunden wird.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Beispiel:

QString x = "sticky question";
QString y = "sti";
x.indexOf(y);               // returns 0
x.indexOf(y, 1);            // returns 10
x.indexOf(y, 10);           // returns 10
x.indexOf(y, 11);           // returns -1

Wenn from -1 ist, beginnt die Suche beim letzten Zeichen; wenn es -2 ist, beim vorletzten Zeichen und so weiter.

Siehe auch lastIndexOf(), contains(), und count().

qsizetype QString::indexOf(const QRegularExpression &re, qsizetype from = 0, QRegularExpressionMatch *rmatch = nullptr) const

Gibt die Indexposition der ersten Übereinstimmung des regulären Ausdrucks re in der Zeichenkette zurück, wobei ab der Indexposition from vorwärts gesucht wird. Gibt -1 zurück, wenn re nirgendwo übereinstimmt.

Wenn die Übereinstimmung erfolgreich ist und rmatch nicht nullptr ist, werden die Ergebnisse der Übereinstimmung auch in das Objekt QRegularExpressionMatch geschrieben, auf das rmatch zeigt.

Beispiel:

QString str = "the minimum";
str.indexOf(QRegularExpression("m[aeiou]"), 0);       // returns 4

QString str = "the minimum";
QRegularExpressionMatch match;
str.indexOf(QRegularExpression("m[aeiou]"), 0, &match);       // returns 4
// match.captured() == mi

qsizetype QString::indexOf(const QString &str, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Gibt die Indexposition des ersten Vorkommens der Zeichenfolge str in dieser Zeichenfolge zurück, wobei ab der Indexposition from vorwärts gesucht wird. Gibt -1 zurück, wenn str nicht gefunden wird.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Beispiel:

QString x = "sticky question";
QString y = "sti";
x.indexOf(y);               // returns 0
x.indexOf(y, 1);            // returns 10
x.indexOf(y, 10);           // returns 10
x.indexOf(y, 11);           // returns -1

Wenn from -1 ist, beginnt die Suche beim letzten Zeichen; wenn es -2 ist, beim vorletzten Zeichen und so weiter.

Siehe auch lastIndexOf(), contains(), und count().

qsizetype QString::indexOf(QChar ch, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet indexOf().

Gibt die Indexposition des ersten Vorkommens des Zeichens ch in dieser Zeichenkette zurück, wobei ab der Indexposition from vorwärts gesucht wird. Gibt -1 zurück, wenn ch nicht gefunden wird.

[noexcept] qsizetype QString::indexOf(QStringView str, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet indexOf().

Gibt die Indexposition des ersten Vorkommens der Zeichenkettenansicht str in dieser Zeichenkette zurück, wobei ab der Indexposition from vorwärts gesucht wird. Gibt -1 zurück, wenn str nicht gefunden wird.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Wenn from -1 ist, beginnt die Suche beim letzten Zeichen; wenn es -2 ist, beim vorletzten Zeichen und so weiter.

Siehe auch QStringView::indexOf(), lastIndexOf(), contains(), und count().

QString &QString::insert(qsizetype position, const QString &str)

Fügt die Zeichenkette str am angegebenen Index position ein und gibt eine Referenz auf diese Zeichenkette zurück.

Beispiel:

QString str = "Meal";
str.insert(1, QString("ontr"));
// str == "Montreal"

Diese Zeichenkette wächst, um das Einfügen zu ermöglichen. Wenn position hinter dem Ende der Zeichenkette liegt, werden Leerzeichen an die Zeichenkette angehängt, um diese position zu erreichen, gefolgt von str.

Siehe auch append(), prepend(), replace(), und remove().

QString &QString::insert(qsizetype position, QChar ch)

Diese Funktion überlastet insert().

Fügt ch an dem angegebenen Index position in die Zeichenkette ein.

Diese Zeichenkette wächst, um die Einfügung zu ermöglichen. Wenn position hinter dem Ende der Zeichenkette liegt, werden Leerzeichen an die Zeichenkette angehängt, um diese position zu erreichen, gefolgt von ch.

QString &QString::insert(qsizetype position, QLatin1StringView str)

Diese Funktion überlastet insert().

Fügt die Latin-1-Zeichenkette, die von str angezeigt wird, am angegebenen Index position ein.

Diese Zeichenkette wächst, um das Einfügen zu ermöglichen. Wenn position hinter dem Ende der Zeichenkette liegt, werden Leerzeichen an die Zeichenkette angehängt, um diese position zu erreichen, gefolgt von str.

[since 6.0] QString &QString::insert(qsizetype position, QStringView str)

Diese Funktion überlastet insert().

Fügt die Zeichenkette view str am angegebenen Index position ein und gibt eine Referenz auf diese Zeichenkette zurück.

Diese Zeichenkette wächst, um das Einfügen zu ermöglichen. Wenn position hinter dem Ende des Strings liegt, werden Leerzeichen an den String angehängt, um diesen position zu erreichen, gefolgt von str.

Diese Funktion wurde in Qt 6.0 eingeführt.

[since 6.5] QString &QString::insert(qsizetype position, QUtf8StringView str)

Diese Funktion überlastet insert().

Fügt die UTF-8-String-Ansicht str am angegebenen Index position ein.

Diese Zeichenkette wächst, um die Einfügung zu ermöglichen. Wenn position über das Ende des Strings hinausgeht, werden Leerzeichen an den String angehängt, um diesen position zu erreichen, gefolgt von str.

Diese Funktion wurde in Qt 6.5 eingeführt.

QString &QString::insert(qsizetype position, const QByteArray &str)

Diese Funktion überlastet insert().

Interpretiert den Inhalt von str als UTF-8, fügt den kodierten Unicode-String am angegebenen Index position ein und gibt einen Verweis auf diesen String zurück.

Diese Zeichenkette wächst, um das Einfügen zu ermöglichen. Wenn position hinter dem Ende der Zeichenkette liegt, werden Leerzeichen an die Zeichenkette angehängt, um diese position zu erreichen, gefolgt von str.

Diese Funktion ist nicht verfügbar, wenn QT_NO_CAST_FROM_ASCII definiert ist.

QString &QString::insert(qsizetype position, const char *str)

Diese Funktion überlastet insert().

Fügt die C-Zeichenkette str am angegebenen Index position ein und gibt eine Referenz auf diese Zeichenkette zurück.

Diese Zeichenkette wächst, um das Einfügen zu ermöglichen. Wenn position hinter dem Ende der Zeichenkette liegt, werden Leerzeichen an die Zeichenkette angehängt, um diese position zu erreichen, gefolgt von str.

Diese Funktion ist nicht verfügbar, wenn QT_NO_CAST_FROM_ASCII definiert ist.

QString &QString::insert(qsizetype position, const QChar *unicode, qsizetype size)

Diese Funktion überlastet insert().

Fügt die ersten size Zeichen des Arrays QChar unicode an dem angegebenen Index position in die Zeichenkette ein.

Diese Zeichenkette wächst, um das Einfügen zu ermöglichen. Wenn position hinter dem Ende der Zeichenkette liegt, werden Leerzeichen an die Zeichenkette angehängt, um diese position zu erreichen, gefolgt von size Zeichen des QChar Arrays unicode.

[noexcept] bool QString::isEmpty() const

Gibt true zurück, wenn die Zeichenkette keine Zeichen enthält; andernfalls wird false zurückgegeben.

Beispiel:

QString().isEmpty();            // returns true
QString("").isEmpty();          // returns true
QString("x").isEmpty();         // returns false
QString("abc").isEmpty();       // returns false

Siehe auch size().

bool QString::isLower() const

Gibt true zurück, wenn die Zeichenkette kleingeschrieben ist, d. h. sie ist identisch mit ihrer toLower()-Faltung.

Beachten Sie, dass dies nicht bedeutet, dass die Zeichenkette keine Großbuchstaben enthält (einige Großbuchstaben haben keine Kleinbuchstaben-Faltung; sie werden von toLower() unverändert gelassen). Weitere Informationen finden Sie in der Unicode-Norm, Abschnitt 3.13.

Siehe auch QChar::toLower() und isUpper().

bool QString::isNull() const

Gibt true zurück, wenn diese Zeichenkette null ist; andernfalls wird false zurückgegeben.

Beispiel:

QString().isNull();             // returns true
QString("").isNull();           // returns false
QString("abc").isNull();        // returns false

Qt unterscheidet aus historischen Gründen zwischen Null-Strings und leeren Strings. Für die meisten Anwendungen ist es wichtig, ob eine Zeichenkette Daten enthält oder nicht, und dies kann mit der Funktion isEmpty() ermittelt werden.

Siehe auch isEmpty().

bool QString::isRightToLeft() const

Gibt true zurück, wenn die Zeichenkette von rechts nach links gelesen wird.

Siehe auch QStringView::isRightToLeft().

bool QString::isUpper() const

Gibt true zurück, wenn die Zeichenkette in Großbuchstaben geschrieben ist, d. h. sie ist identisch mit ihrer toUpper()-Faltung.

Beachten Sie, dass dies nicht bedeutet, dass die Zeichenkette keine Kleinbuchstaben enthält (einige Kleinbuchstaben haben keine Großbuchstaben-Faltung; sie werden von toUpper() unverändert gelassen). Weitere Informationen finden Sie in der Unicode-Norm, Abschnitt 3.13.

Siehe auch QChar::toUpper() und isLower().

[noexcept] bool QString::isValidUtf16() const

Gibt true zurück, wenn die Zeichenkette gültige UTF-16-kodierte Daten enthält, andernfalls false.

Beachten Sie, dass diese Funktion keine spezielle Validierung der Daten durchführt; sie prüft lediglich, ob sie erfolgreich aus UTF-16 dekodiert werden können. Es wird davon ausgegangen, dass die Daten in Host-Byte-Reihenfolge vorliegen; das Vorhandensein eines BOM ist bedeutungslos.

Siehe auch QStringView::isValidUtf16().

qsizetype QString::lastIndexOf(const QRegularExpression &re, qsizetype from, QRegularExpressionMatch *rmatch = nullptr) const

Gibt die Indexposition der letzten Übereinstimmung des regulären Ausdrucks re in der Zeichenkette zurück, die vor der Indexposition from beginnt.

Ist from gleich -1, beginnt die Suche am letzten Zeichen; ist es -2, am vorletzten Zeichen und so weiter.

Gibt -1 zurück, wenn re nirgendwo übereinstimmt.

Wenn die Übereinstimmung erfolgreich ist und rmatch nicht nullptr ist, werden die Ergebnisse der Übereinstimmung auch in das Objekt QRegularExpressionMatch geschrieben, auf das rmatch zeigt.

Beispiel:

QString str = "the minimum";
str.lastIndexOf(QRegularExpression("m[aeiou]"));      // returns 8

QString str = "the minimum";
QRegularExpressionMatch match;
str.lastIndexOf(QRegularExpression("m[aeiou]"), -1, &match);      // returns 8
// match.captured() == mu

qsizetype QString::lastIndexOf(const QString &str, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Gibt die Indexposition des letzten Vorkommens der Zeichenkette str in dieser Zeichenkette zurück, wobei ab der Indexposition from rückwärts gesucht wird.

Ist from gleich -1, beginnt die Suche beim letzten Zeichen; ist es -2, beim vorletzten Zeichen und so weiter.

Gibt -1 zurück, wenn str nicht gefunden wird.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Beispiel:

QString x = "crazy azimuths";
QString y = "az";
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

Siehe auch indexOf(), contains(), und count().

[noexcept, since 6.3] qsizetype QString::lastIndexOf(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet lastIndexOf().

Diese Funktion wurde in Qt 6.3 eingeführt.

[since 6.2] qsizetype QString::lastIndexOf(QLatin1StringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet lastIndexOf().

Gibt die Indexposition des letzten Vorkommens der Zeichenfolge str in dieser Zeichenfolge zurück. Gibt -1 zurück, wenn str nicht gefunden wird.

Wenn cs gleich Qt::CaseSensitive ist (die Vorgabe), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird zwischen Groß- und Kleinschreibung nicht unterschieden.

Beispiel:

QString x = "crazy azimuths";
QString y = "az";
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

Diese Funktion wurde in Qt 6.2 eingeführt.

Siehe auch indexOf(), contains(), und count().

[noexcept, since 6.2] qsizetype QString::lastIndexOf(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet lastIndexOf().

Gibt die Indexposition des letzten Vorkommens der Zeichenkettenansicht str in dieser Zeichenkette zurück. Gibt -1 zurück, wenn str nicht gefunden wird.

Wenn cs gleich Qt::CaseSensitive ist (die Vorgabe), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird zwischen Groß- und Kleinschreibung nicht unterschieden.

Diese Funktion wurde in Qt 6.2 eingeführt.

Siehe auch indexOf(), contains(), und count().

[since 6.2] qsizetype QString::lastIndexOf(const QRegularExpression &re, QRegularExpressionMatch *rmatch = nullptr) const

Diese Funktion überlastet lastIndexOf().

Gibt die Indexposition der letzten Übereinstimmung mit dem regulären Ausdruck re in der Zeichenkette zurück. Gibt -1 zurück, wenn re nirgends übereinstimmt.

Wenn die Übereinstimmung erfolgreich ist und rmatch nicht nullptr ist, werden die Ergebnisse der Übereinstimmung auch in das Objekt QRegularExpressionMatch geschrieben, auf das rmatch zeigt.

Beispiel:

QString str = "the minimum";
str.lastIndexOf(QRegularExpression("m[aeiou]"));      // returns 8

QString str = "the minimum";
QRegularExpressionMatch match;
str.lastIndexOf(QRegularExpression("m[aeiou]"), -1, &match);      // returns 8
// match.captured() == mu

Diese Funktion wurde in Qt 6.2 eingeführt.

[since 6.2] qsizetype QString::lastIndexOf(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet lastIndexOf().

Gibt die Indexposition des letzten Vorkommens der Zeichenfolge str in dieser Zeichenfolge zurück. Gibt -1 zurück, wenn str nicht gefunden wird.

Wenn cs gleich Qt::CaseSensitive ist (die Vorgabe), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird zwischen Groß- und Kleinschreibung nicht unterschieden.

Beispiel:

QString x = "crazy azimuths";
QString y = "az";
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

Diese Funktion wurde in Qt 6.2 eingeführt.

Siehe auch indexOf(), contains(), und count().

qsizetype QString::lastIndexOf(QChar ch, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet lastIndexOf().

Gibt die Indexposition des letzten Vorkommens des Zeichens ch in dieser Zeichenfolge zurück, wobei ab der Indexposition from rückwärts gesucht wird.

qsizetype QString::lastIndexOf(QLatin1StringView str, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet lastIndexOf().

Gibt die Indexposition des letzten Vorkommens der Latin-1-Zeichenkette zurück, die von str in dieser Zeichenkette betrachtet wird, wobei ab der Indexposition from rückwärts gesucht wird.

Ist from gleich -1, beginnt die Suche beim letzten Zeichen; ist es -2, beim vorletzten Zeichen usw.

Gibt -1 zurück, wenn str nicht gefunden wird.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Beispiel:

QString x = "crazy azimuths";
QString y = "az";
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

Siehe auch indexOf(), contains(), und count().

[noexcept] qsizetype QString::lastIndexOf(QStringView str, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Diese Funktion überlastet lastIndexOf().

Gibt die Indexposition des letzten Vorkommens der Zeichenkettenansicht str in dieser Zeichenkette zurück, wobei ab der Indexposition from rückwärts gesucht wird.

Ist from gleich -1, beginnt die Suche beim letzten Zeichen; ist es -2, beim vorletzten Zeichen usw.

Gibt -1 zurück, wenn str nicht gefunden wird.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Siehe auch indexOf(), contains(), und count().

QString QString::leftJustified(qsizetype width, QChar fill = u' ', bool truncate = false) const

Gibt eine Zeichenkette der Größe width zurück, die diese Zeichenkette mit dem Zeichen fill aufgefüllt enthält.

Wenn truncate gleich false ist und size() der Zeichenkette größer ist als width, dann ist die zurückgegebene Zeichenkette eine Kopie der Zeichenkette.

QString s = "apple";
QString t = s.leftJustified(8, '.');    // t == "apple..."

Wenn truncate gleich true ist und size() der Zeichenkette größer als width ist, werden alle Zeichen in einer Kopie der Zeichenkette nach der Position width entfernt, und die Kopie wird zurückgegeben.

QString str = "Pineapple";
str = str.leftJustified(5, '.', true);    // str == "Pinea"

Siehe auch rightJustified().

[noexcept] qsizetype QString::length() const

Gibt die Anzahl der Zeichen in dieser Zeichenkette zurück. Äquivalent zu size().

Siehe auch resize().

[static] int QString::localeAwareCompare(const QString &s1, const QString &s2)

Vergleicht s1 mit s2 und gibt eine ganze Zahl zurück, die kleiner, gleich oder größer als Null ist, wenn s1 kleiner, gleich oder größer als s2 ist.

Der Vergleich wird auf eine lokal- und plattformabhängige Weise durchgeführt. Verwenden Sie diese Funktion, um dem Benutzer sortierte Listen von Zeichenketten zu präsentieren.

Siehe auch compare(), QLocale, und Comparing Strings.

[since 6.0] int QString::localeAwareCompare(QStringView other) const

Diese Funktion ist eine Überladung von localeAwareCompare().

Vergleicht diese Zeichenkette mit der Zeichenkette other und gibt eine ganze Zahl zurück, die kleiner, gleich oder größer als Null ist, wenn diese Zeichenkette kleiner, gleich oder größer als die Zeichenkette other ist.

Der Vergleich wird in einer lokal- und plattformabhängigen Weise durchgeführt. Verwenden Sie diese Funktion, um dem Benutzer sortierte Listen von Zeichenketten zu präsentieren.

Dasselbe wie localeAwareCompare(*this, other).

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch Comparing Strings.

int QString::localeAwareCompare(const QString &other) const

Diese Funktion ist eine Überladung von localeAwareCompare().

Vergleicht diese Zeichenkette mit der Zeichenkette other und gibt eine ganze Zahl zurück, die kleiner, gleich oder größer als Null ist, wenn diese Zeichenkette kleiner, gleich oder größer als die Zeichenkette other ist.

Der Vergleich wird in einer lokal- und plattformabhängigen Weise durchgeführt. Verwenden Sie diese Funktion, um dem Benutzer sortierte Listen von Zeichenketten zu präsentieren.

Dasselbe wie localeAwareCompare(*this, other).

Siehe auch Comparing Strings.

[static, since 6.0] int QString::localeAwareCompare(QStringView s1, QStringView s2)

Diese Funktion ist eine Überladung von localeAwareCompare().

Vergleicht s1 mit s2 und gibt eine ganze Zahl zurück, die kleiner, gleich oder größer als Null ist, wenn s1 kleiner, gleich oder größer als s2 ist.

Der Vergleich wird auf eine lokal- und plattformabhängige Weise durchgeführt. Verwenden Sie diese Funktion, um dem Benutzer sortierte Listen von Zeichenketten zu präsentieren.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch Comparing Strings.

QString QString::normalized(QString::NormalizationForm mode, QChar::UnicodeVersion version = QChar::Unicode_Unassigned) const

Gibt die Zeichenkette in der angegebenen Unicode-Normalisierung mode zurück, entsprechend der angegebenen version des Unicode-Standards.

[static] QString QString::number(long n, int base = 10)

Gibt ein String-Äquivalent der Zahl n entsprechend der angegebenen base zurück.

Die Basis ist standardmäßig 10 und muss zwischen 2 und 36 liegen. Für andere Basen als 10 wird n als Ganzzahl ohne Vorzeichen behandelt.

Für die Formatierung wird immer QLocale::C verwendet, d. h. Englisch/Vereinigte Staaten. Um eine lokalisierte String-Darstellung einer Zahl zu erhalten, verwenden Sie QLocale::toString() mit dem entsprechenden Gebietsschema.

long a = 63;
QString s = QString::number(a, 16);             // s == "3f"
QString t = QString::number(a, 16).toUpper();     // t == "3F"

Siehe auch setNum().

[static] QString QString::number(double n, char format = 'g', int precision = 6)

Gibt eine Zeichenkette zurück, die die Fließkommazahl n darstellt.

Gibt eine Zeichenkette zurück, die n repräsentiert, formatiert entsprechend den angegebenen format und precision.

Bei Formaten mit einem Exponenten zeigt der Exponent sein Vorzeichen und hat mindestens zwei Ziffern, wobei der Exponent bei Bedarf links mit Null aufgefüllt wird.

Siehe auch setNum(), QLocale::toString(), QLocale::FloatingPointPrecisionOption, und Number Formats.

[static] QString QString::number(int n, int base = 10)

Dies ist eine überladene Funktion.

[static] QString QString::number(qlonglong n, int base = 10)

Dies ist eine überladene Funktion.

[static] QString QString::number(qulonglong n, int base = 10)

Dies ist eine überladene Funktion.

[static] QString QString::number(uint n, int base = 10)

Dies ist eine überladene Funktion.

[static] QString QString::number(ulong n, int base = 10)

Dies ist eine überladene Funktion.

QString &QString::prepend(const QString &str)

Stellt die Zeichenkette str an den Anfang dieser Zeichenkette und gibt einen Verweis auf diese Zeichenkette zurück.

Dieser Vorgang ist in der Regel sehr schnell(konstante Zeit), da QString zusätzlichen Platz am Anfang der Zeichenkette reserviert, so dass sie wachsen kann, ohne jedes Mal die gesamte Zeichenkette neu zu reservieren.

Beispiel:

QString x = "ship";
QString y = "air";
x.prepend(y);
// x == "airship"

Siehe auch append() und insert().

QString &QString::prepend(QChar ch)

Diese Funktion überlädt prepend().

Hängt das Zeichen ch an diese Zeichenkette an.

QString &QString::prepend(QLatin1StringView str)

Diese Funktion überlädt prepend().

Stellt die Latin-1-Zeichenkette, die von str angezeigt wird, dieser Zeichenkette voran.

[since 6.0] QString &QString::prepend(QStringView str)

Diese Funktion überlädt prepend().

Stellt die Zeichenkettenansicht str an den Anfang dieser Zeichenkette und gibt eine Referenz auf diese Zeichenkette zurück.

Diese Funktion wurde in Qt 6.0 eingeführt.

[since 6.5] QString &QString::prepend(QUtf8StringView str)

Diese Funktion überlädt prepend().

Hängt die UTF-8-String-Ansicht str an diesen String an.

Diese Funktion wurde in Qt 6.5 eingeführt.

QString &QString::prepend(const QByteArray &ba)

Diese Funktion überlädt prepend().

Hängt das Byte-Array ba an diese Zeichenkette an. Das Byte-Array wird mit der Funktion fromUtf8() in Unicode konvertiert.

Sie können diese Funktion deaktivieren, indem Sie QT_NO_CAST_FROM_ASCII definieren, wenn Sie Ihre Anwendungen kompilieren. Dies kann nützlich sein, wenn Sie z. B. sicherstellen wollen, dass alle für den Benutzer sichtbaren Zeichenketten die Funktion QObject::tr() durchlaufen.

QString &QString::prepend(const char *str)

Diese Funktion überlädt prepend().

Fügt die Zeichenkette str an diese Zeichenkette an. Der const char-Zeiger wird mit der Funktion fromUtf8() in Unicode umgewandelt.

Sie können diese Funktion deaktivieren, indem Sie QT_NO_CAST_FROM_ASCII definieren, wenn Sie Ihre Anwendungen kompilieren. Dies kann nützlich sein, wenn Sie z. B. sicherstellen wollen, dass alle für den Benutzer sichtbaren Zeichenketten die Funktion QObject::tr() durchlaufen.

QString &QString::prepend(const QChar *str, qsizetype len)

Diese Funktion überlädt prepend().

Hängt len Zeichen aus dem Array QChar str an diese Zeichenkette an und gibt eine Referenz auf diese Zeichenkette zurück.

void QString::push_back(const QString &other)

Diese Funktion wird aus Gründen der STL-Kompatibilität bereitgestellt und hängt die angegebene Zeichenkette other an das Ende dieser Zeichenkette an. Sie ist äquivalent zu append(other).

Siehe auch append().

void QString::push_back(QChar ch)

Dies ist eine überladene Funktion.

Hängt das angegebene Zeichen ch an das Ende dieser Zeichenkette an.

void QString::push_front(const QString &other)

Diese Funktion wird aus Gründen der STL-Kompatibilität bereitgestellt und stellt die angegebene Zeichenfolge other an den Anfang dieser Zeichenfolge. Sie ist äquivalent zu prepend(other).

Siehe auch prepend().

void QString::push_front(QChar ch)

Dies ist eine überladene Funktion.

Stellt das angegebene Zeichen ch an den Anfang der Zeichenkette.

QString::reverse_iterator QString::rbegin()

Gibt einen Reverse-Iterator im STL-Stil zurück, der auf das erste Zeichen in der Zeichenkette in umgekehrter Reihenfolge zeigt.

Siehe auch begin(), crbegin(), und rend().

QString::const_reverse_iterator QString::rbegin() const

Dies ist eine überladene Funktion.

QString &QString::remove(const QRegularExpression &re)

Entfernt jedes Vorkommen des regulären Ausdrucks re in der Zeichenkette und gibt einen Verweis auf die Zeichenkette zurück. Ein Beispiel:

QString r = "Telephone";
r.remove(QRegularExpression("[aeiou]."));
// r == "The"

Durch das Entfernen von Elementen wird die Kapazität der Zeichenkette erhalten und der zugewiesene Speicher nicht verringert. Um zusätzliche Kapazität abzubauen und so viel Speicher wie möglich freizugeben, rufen Sie squeeze() nach der letzten Änderung der Größe der Zeichenkette auf.

Siehe auch indexOf(), lastIndexOf(), und replace().

QString &QString::remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Entfernt jedes Vorkommen des Zeichens ch in dieser Zeichenfolge und gibt einen Verweis auf diese Zeichenfolge zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Beispiel:

QString t = "Ali Baba";
t.remove(QChar('a'), Qt::CaseInsensitive);
// t == "li Bb"

Dies ist dasselbe wie replace(ch, "", cs).

Durch das Entfernen von Elementen wird die Kapazität der Zeichenkette erhalten und der zugewiesene Speicherplatz nicht verringert. Um zusätzliche Kapazität abzubauen und so viel Speicher wie möglich freizugeben, rufen Sie squeeze() nach der letzten Änderung der Größe der Zeichenkette auf.

Siehe auch replace().

QString &QString::remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Entfernt jedes Vorkommen der angegebenen Zeichenfolge str in dieser Zeichenfolge und gibt einen Verweis auf diese Zeichenfolge zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Dies ist dasselbe wie replace(str, "", cs).

Durch das Entfernen von Elementen wird die Kapazität der Zeichenkette beibehalten und der zugewiesene Speicherplatz nicht verringert. Um zusätzliche Kapazität abzubauen und so viel Speicher wie möglich freizugeben, rufen Sie squeeze() nach der letzten Änderung der Größe der Zeichenkette auf.

Siehe auch replace().

QString &QString::remove(qsizetype position, qsizetype n)

Entfernt n Zeichen aus der Zeichenkette, beginnend mit dem angegebenen position Index, und gibt einen Verweis auf die Zeichenkette zurück.

Wenn der angegebene position Index innerhalb der Zeichenkette liegt, aber position + n über das Ende der Zeichenkette hinausgeht, wird die Zeichenkette am angegebenen position abgeschnitten.

Wenn n <= 0 ist, wird nichts geändert.

QString s = "Montreal";
s.remove(1, 4);
// s == "Meal"

Durch das Entfernen von Elementen wird die Kapazität der Zeichenkette erhalten und der zugewiesene Speicherplatz nicht verringert. Um zusätzliche Kapazität abzubauen und so viel Speicher wie möglich freizugeben, rufen Sie squeeze() nach der letzten Änderung der Größe der Zeichenkette auf.

Siehe auch insert() und replace().

QString &QString::remove(QLatin1StringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Dies ist eine überladene Funktion.

Entfernt jedes Vorkommen der angegebenen Latin-1-Zeichenkette, die von str betrachtet wird, aus dieser Zeichenkette und gibt einen Verweis auf diese Zeichenkette zurück.

Wenn cs gleich Qt::CaseSensitive ist (die Vorgabe), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Dies ist dasselbe wie replace(str, "", cs).

Durch das Entfernen von Elementen wird die Kapazität der Zeichenkette beibehalten und der zugewiesene Speicherplatz nicht verringert. Um zusätzliche Kapazität abzubauen und so viel Speicher wie möglich freizugeben, rufen Sie squeeze() nach der letzten Änderung der Größe der Zeichenkette auf.

Siehe auch replace().

[since 6.5] QString &QString::removeAt(qsizetype pos)

Entfernt das Zeichen am Index pos. Wenn pos außerhalb der Grenzen liegt (d.h. pos >= size()), tut diese Funktion nichts.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch remove().

[since 6.5] QString &QString::removeFirst()

Entfernt das erste Zeichen in dieser Zeichenkette. Wenn die Zeichenkette leer ist, tut diese Funktion nichts.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch remove().

[since 6.1] template <typename Predicate> QString &QString::removeIf(Predicate pred)

Entfernt alle Elemente, für die das Prädikat pred true zurückgibt, aus der Zeichenkette. Gibt eine Referenz auf die Zeichenkette zurück.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch remove().

[since 6.5] QString &QString::removeLast()

Entfernt das letzte Zeichen in dieser Zeichenkette. Wenn die Zeichenkette leer ist, tut diese Funktion nichts.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch remove().

QString::reverse_iterator QString::rend()

Gibt einen umgekehrten Iterator im STL-Stil zurück, der in umgekehrter Reihenfolge direkt auf das letzte Zeichen der Zeichenkette zeigt.

Siehe auch end(), crend(), und rbegin().

QString::const_reverse_iterator QString::rend() const

Dies ist eine überladene Funktion.

QString QString::repeated(qsizetype times) const

Gibt eine Kopie dieser Zeichenkette zurück, die die angegebene Anzahl von times wiederholt.

Wenn times kleiner als 1 ist, wird eine leere Zeichenkette zurückgegeben.

Beispiel:

QString str("ab");
str.repeated(4);            // returns "abababab"

QString &QString::replace(qsizetype position, qsizetype n, const QString &after)

Ersetzt die Zeichen von n ab dem Index position durch die Zeichenfolge after und gibt einen Verweis auf diese Zeichenfolge zurück.

Beispiel:

QString x = "Say yes!";
QString y = "no";
x.replace(4, 3, y);
// x == "Say no!"

Siehe auch insert() und remove().

QString &QString::replace(const QRegularExpression &re, const QString &after)

Diese Funktion überlädt replace().

Ersetzt jedes Vorkommen des regulären Ausdrucks re in der Zeichenkette durch after. Gibt einen Verweis auf die Zeichenkette zurück. Ein Beispiel:

QString s = "Banana";
s.replace(QRegularExpression("a[mn]"), "ox");
// s == "Boxoxa"

Bei regulären Ausdrücken, die Erfassungsgruppen enthalten, werden die Vorkommen von \1, \2, ..., in after durch die von der entsprechenden Erfassungsgruppe erfasste Zeichenkette ersetzt.

QString t = "A <i>bon mot</i>.";
t.replace(QRegularExpression("<i>([^<]*)</i>"), "\\emph{\\1}");
// t == "A \\emph{bon mot}."

Siehe auch indexOf(), lastIndexOf(), remove(), QRegularExpression, und QRegularExpressionMatch.

QString &QString::replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Diese Funktion überlastet replace().

Ersetzt jedes Vorkommen des Zeichens before durch das Zeichen after und gibt einen Verweis auf diese Zeichenfolge zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

QString &QString::replace(QChar c, QLatin1StringView after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Diese Funktion überlastet replace().

Ersetzt jedes Vorkommen des Zeichens c durch die Zeichenfolge after und gibt einen Verweis auf diese Zeichenfolge zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

QString &QString::replace(QChar ch, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Diese Funktion überlastet replace().

Ersetzt jedes Vorkommen des Zeichens ch in der Zeichenfolge durch after und gibt einen Verweis auf diese Zeichenfolge zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

QString &QString::replace(QLatin1StringView before, QLatin1StringView after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Diese Funktion überlastet replace().

Ersetzt jedes Vorkommen der Latin-1-Zeichenfolge in dieser Zeichenfolge, die von before betrachtet wird, durch die Latin-1-Zeichenfolge, die von after betrachtet wird, und gibt einen Verweis auf diese Zeichenfolge zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

QString &QString::replace(QLatin1StringView before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Diese Funktion überlastet replace().

Ersetzt jedes Vorkommen der von before betrachteten Latin-1-Zeichenfolge in dieser Zeichenfolge durch die Zeichenfolge after und gibt einen Verweis auf diese Zeichenfolge zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

QString &QString::replace(const QString &before, QLatin1StringView after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Diese Funktion überlastet replace().

Ersetzt jedes Vorkommen der Zeichenfolge before durch die Zeichenfolge after und gibt einen Verweis auf diese Zeichenfolge zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

QString &QString::replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Diese Funktion überlastet replace().

Ersetzt jedes Vorkommen der Zeichenfolge before durch die Zeichenfolge after und gibt einen Verweis auf diese Zeichenfolge zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standardeinstellung), wird zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

Beispiel:

QString str = "colour behaviour flavour neighbour";
str.replace(QString("ou"), QString("o"));
// str == "color behavior flavor neighbor"

Beispiel:

QString equis = "xxxxxx";
equis.replace("xx", "x");
// equis == "xxx"

QString &QString::replace(qsizetype position, qsizetype n, QChar after)

Diese Funktion überlastet replace().

Ersetzt die Zeichen von n ab dem Index position durch das Zeichen after und gibt einen Verweis auf diese Zeichenkette zurück.

QString &QString::replace(qsizetype position, qsizetype n, const QChar *after, qsizetype alen)