QString Class

Dokumentation zu Member-Funktionen

[constexpr noexcept] QString::QString()

Erzeugt eine Null-Zeichenkette. Null-Zeichenketten gelten ebenfalls als leer.

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

QString::QString(QChar ch)

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

QString::QString(QLatin1StringView str)

Erstellt eine Kopie der Latin-1-Zeichenkette, wie sie von str dargestellt wird.

Siehe auch fromLatin1().

[explicit, since 6.8] QString::QString(QStringView sv)

Erstellt eine Zeichenkette, die mit den Daten der String-Ansicht initialisiert wird.

Der QString ist genau dann null, wenn „ sv “ null ist.

Diese Funktion wurde in Qt 6.8 eingeführt.

Siehe auch ` fromUtf16()`.

QString::QString(const QByteArray &ba)

Erstellt eine Zeichenkette, die mit dem Byte-Array „ ba “ initialisiert wird. Das angegebene Byte-Array wird mithilfe von „ fromUtf8()“ in Unicode konvertiert.

Sie können diesen Konstruktor deaktivieren, indem Sie bei der Kompilierung Ihrer Anwendungen ` QT_NO_CAST_FROM_ASCII ` definieren. Dies kann beispielsweise nützlich sein, wenn Sie sicherstellen möchten, dass alle für den Benutzer sichtbaren Zeichenfolgen über ` QObject::tr()` verarbeitet werden.

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

QString::QString(const char *str)

Erstellt eine Zeichenkette, die mit der 8-Bit-Zeichenkette „ str “ initialisiert ist. Der angegebene const char-Zeiger wird mithilfe der Funktion „ fromUtf8()“ in Unicode konvertiert.

Sie können diesen Konstruktor deaktivieren, indem Sie bei der Kompilierung Ihrer Anwendungen ` QT_NO_CAST_FROM_ASCII ` definieren. Dies kann beispielsweise nützlich sein, wenn Sie sicherstellen möchten, dass alle für den Benutzer sichtbaren Zeichenfolgen über ` QObject::tr()` verarbeitet werden.

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

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

Erzeugt eine Zeichenkette, die mit der UTF-8-Zeichenkette „ str “ initialisiert ist. Der angegebene Zeiger vom Typ `const char8_t` wird mithilfe 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)

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

Ist unicode gleich 0, wird eine leere Zeichenkette erstellt.

Ist size negativ, wird angenommen, dass unicode auf ein durch „'\0'“ abgeschlossenes Array verweist, dessen Länge dynamisch ermittelt wird. Das abschließende Nullzeichen wird nicht als Teil der Zeichenkette betrachtet.

QString erstellt eine tiefe Kopie der Zeichenfolgendaten. Die Unicode-Daten werden unverändert kopiert, und die Byte-Order-Markierung bleibt, sofern vorhanden, erhalten.

Siehe auch ` fromRawData()`.

QString::QString(qsizetype size, QChar ch)

Erstellt eine Zeichenkette aus dem angegebenen „ size “, wobei jedes Zeichen auf „ ch “ gesetzt wird.

Siehe auch fill().

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

Erstellt eine Kopie von ` other`.

Dieser Vorgang dauert eine konstante Zeit, da QString implizit gemeinsam genutzt wird. Dadurch ist die Rückgabe eines QString aus einer Funktion sehr schnell. Wird eine gemeinsam genutzte Instanz geändert, wird sie kopiert (Copy-on-Write), was lineare Zeit in Anspruch nimmt.

Siehe auch ` operator=()`.

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

Erstellt eine QString-Instanz und sorgt dafür, dass diese auf dasselbe Objekt verweist, auf das zuvor „ other “ verwiesen hat.

[noexcept] QString::~QString()

Löscht die Zeichenkette.

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

Fügt die Zeichenfolge „ str “ am Ende dieser Zeichenfolge an.

Beispiel:

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

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

Dies entspricht der Verwendung der Funktion ` insert()`:

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

Die Funktion `append()` ist in der Regel sehr schnell (konstante Laufzeit), da ` QString ` am Ende der Zeichenkettendaten zusätzlichen Speicherplatz vorab reserviert, sodass die Zeichenkette wachsen kann, ohne dass jedes Mal die gesamte Zeichenkette neu zugewiesen werden muss.

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

QString &QString::append(QChar ch)

Fügt das Zeichen „ ch “ an diese Zeichenkette an.

QString &QString::append(QLatin1StringView str)

Fügt die von ` str ` zurückgegebene Latin-1-Zeichenkette an diese Zeichenkette an.

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

Fügt die angegebene String-View „ 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)

Fügt die UTF-8-Zeichenkette „ str “ an diese Zeichenkette an.

Diese Funktion wurde in Qt 6.5 eingeführt.

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

Fügt das Byte-Array „ ba “ an diese Zeichenkette an. Das angegebene Byte-Array wird mithilfe der Funktion „ fromUtf8()“ in Unicode konvertiert.

Sie können diese Funktion deaktivieren, indem Sie bei der Kompilierung Ihrer Anwendungen ` QT_NO_CAST_FROM_ASCII ` definieren. Dies kann beispielsweise nützlich sein, wenn Sie sicherstellen möchten, dass alle für den Benutzer sichtbaren Zeichenfolgen durch die Funktion ` QObject::tr()` verarbeitet werden.

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

Fügt die Zeichenkette „ str “ an diese Zeichenkette an. Der angegebene „const char“-Zeiger wird mithilfe der Funktion „ fromUtf8()“ in Unicode konvertiert.

Sie können diese Funktion deaktivieren, indem Sie beim Kompilieren Ihrer Anwendungen ` QT_NO_CAST_FROM_ASCII ` definieren. Dies kann beispielsweise nützlich sein, wenn Sie sicherstellen möchten, dass alle für den Benutzer sichtbaren Zeichenfolgen über ` QObject::tr()` verarbeitet werden.

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

Fügt die Zeichen aus dem Array „ QChar “ str als Zeichenkette „ len “ an diese Zeichenkette an.

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 Argument aus „ args “ ersetzt „ %N “ durch den niedrigsten Wert aus „ N “ (alle), das zweite Argument aus „ args “ ersetzt „ %N “ durch den nächstniedrigeren Wert aus „ N “ usw.

Args kann aus beliebigen Zeichen bestehen, die implizit in „ QAnyStringView “ konvertiert werden.

Siehe auch QString::arg().

template <typename T> requires if_string_like<T> QString QString::arg(const T &a, int fieldWidth = 0, QChar fillChar = u' ') const

Gibt eine Kopie dieser Zeichenkette zurück, wobei der Platzhalter mit der niedrigsten Nummer durch die Zeichenkette „ a “ ersetzt wird, d. h. „ %1 “, „ %2 “, …, „ %99 “.

fieldWidth Legt die Mindestlänge fest, die „ a “ einnehmen soll. Wenn „ a “ weniger Platz benötigt als „ fieldWidth “, wird es mit dem Zeichen „ fillChar “ auf „ fieldWidth “ aufgefüllt. Ein positiver Wert für „ fieldWidth “ erzeugt rechtsbündigen Text. Ein negativer Wert für „ fieldWidth “ erzeugt linksbündigen Text.

Dieses Beispiel zeigt, wie wir eine Zeichenkette vom Typ „ status “ erstellen können, um den Fortschritt bei der Verarbeitung einer Dateiliste anzuzeigen:

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

Zunächst ersetzt „ arg(i) “ „ %1 “. Dann ersetzt „ arg(total) “ „ %2 “. Schließlich ersetzt „ arg(fileName) “ „ %3 “.

Ein Vorteil der Verwendung von `arg()` gegenüber ` asprintf()` besteht darin, dass sich die Reihenfolge der nummerierten Platzhalter ändern kann, wenn die Zeichenfolgen der Anwendung in andere Sprachen übersetzt werden, aber jedes `arg()` ersetzt dennoch den Platzhalter mit der niedrigsten Nummer, der noch nicht ersetzt wurde, unabhängig davon, wo er vorkommt. Wenn der Platzhalter „ %i “ mehr als einmal in der Zeichenkette vorkommt, ersetzt arg() alle Vorkommen.

Wenn kein unersetzter Platzhalter mehr vorhanden ist, wird eine Warnmeldung ausgegeben und das Ergebnis ist undefiniert. Die Nummern der Platzhalter müssen im Bereich von 1 bis 99 liegen.

template <typename T> requires if_integral_non_char<T> QString QString::arg(T a, int fieldWidth = 0, int base = 10, QChar fillChar = u' ') const

Das Argument ` a ` wird in der Basis ` base` angegeben, die standardmäßig 10 beträgt und zwischen 2 und 36 liegen muss. Bei anderen Basen als 10 wird ` a ` als vorzeichenlose Ganzzahl behandelt.

fieldWidth Gibt die Mindestanzahl an Zeichen an, auf die „ a “ aufgefüllt und mit dem Zeichen „ fillChar “ ergänzt wird. Ein positiver Wert führt zu rechtsbündigem Text; ein negativer Wert zu linksbündigem Text.

Auf das „%“ kann ein „L“ folgen; in diesem Fall wird die Zeichenfolge durch eine lokalisierte Darstellung von ` a` ersetzt. Die Konvertierung verwendet die Standard-Locale, die durch ` QLocale::setDefault()` festgelegt wurde. Wenn keine Standard-Locale angegeben wurde, wird die System-Locale verwendet. Das „L“-Flag 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.

template <typename T> requires if_floating_point<T> QString QString::arg(T a, int fieldWidth = 0, char format = 'g', int precision = -1, QChar fillChar = u' ') const

Das Argument „ a “ wird gemäß den angegebenen Formaten „ format “ und „ precision “ formatiert. Weitere Informationen finden Sie unter Floating-point Formats.

fieldWidth Gibt die Mindestlänge an, auf die ` a ` aufgefüllt und mit dem Zeichen ` fillChar` ergänzt wird. Ein positiver Wert führt zu rechtsbündigem Text, ein negativer Wert zu linksbündigem 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 Formatzeichenfolge 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 UTF-8-kodiert sein.

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

Bei ` translations` sollten Sie, insbesondere wenn die Zeichenfolgen mehr als eine Escape-Sequenz enthalten, stattdessen die Funktion ` arg()` in Betracht ziehen. 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 Zeichenkette durch eine Kopie von v und gibt eine Referenz auf diese Zeichenkette zurück.

Die Größe dieser Zeichenkette entspricht der Größe von v, die wie bei v.toString() in UTF-16 konvertiert wurde. Im Gegensatz zu QAnyStringView::toString() reserviert diese Funktion jedoch nur dann Speicher, wenn die geschätzte Größe die Kapazität dieser Zeichenkette überschreitet oder diese Zeichenkette gemeinsam genutzt wird.

Diese Funktion wurde in Qt 6.6 eingeführt.

Siehe auch ` QAnyStringView::toString()`.

[since 6.6] template <typename InputIterator> requires if_compatible_iterator<InputIterator> 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 unbedingt mit der Länge des Bereichs selbst übereinstimmen muss, da diese Funktion den Eingabezeichensatz transparent in UTF-16 umcodiert.

Diese Funktion reserviert nur dann Speicher, 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 überschreitet oder wenn diese Zeichenkette gemeinsam genutzt wird.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ InputIterator “ die Anforderungen eines „LegacyInputIterator“ erfüllt und der „ value_type “ von „ InputIterator “ einer der folgenden Zeichentypen ist:

• QChar
• QLatin1Char
• char
• unsigned char
• signed char
• char8_t
• char16_t
• (auf Plattformen wie Windows, auf denen 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 eine Referenz auf diese Zeichenkette zurück.

Die Größe dieser Zeichenkette entspricht n, wobei dieser Wert nicht negativ sein darf.

Diese Funktion reserviert nur dann Speicher, wenn „ n “ die Kapazität dieser Zeichenkette überschreitet oder diese Zeichenkette 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 an der angegebenen Indexposition position in der Zeichenkette zurück.

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

Siehe auch ` operator[]()`.

QChar &QString::back()

Gibt eine Referenz auf das letzte Zeichen der Zeichenkette zurück. Entspricht „ 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. Entspricht „ 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

qsizetype QString::capacity() const

Gibt die maximale Anzahl an Zeichen zurück, die in der Zeichenkette gespeichert werden können, ohne dass eine Neuzuweisung erzwungen wird.

Der einzige Zweck dieser Funktion besteht darin, eine Möglichkeit zur Feinabstimmung der Speichernutzung von QString bereitzustellen. Im Allgemeinen werden Sie diese Funktion so gut wie nie aufrufen müssen. Wenn Sie wissen möchten, wie viele Zeichen die Zeichenkette enthält, rufen Sie size() auf.

Siehe auch ` reserve()` und ` squeeze()`.

QString::const_iterator QString::cbegin() const

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

Siehe auch „ begin()“ und „ cend()“.

QString::const_iterator QString::cend() const

Gibt einen konstanten Iterator im STL-Stil zurück, der direkt auf das Zeichen nach dem letzten Zeichen der Zeichenkette zeigt.

Siehe auch „ cbegin()“ und „ end()“.

void QString::chop(qsizetype n)

Entfernt die Zeichen „ n “ vom Ende der Zeichenkette.

Ist ` n ` größer oder gleich ` size()`, ist das Ergebnis eine leere Zeichenkette; ist ` n ` negativ, 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 möchten, verwenden Sie stattdessen ` remove()`.

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

Gibt eine Zeichenkette zurück, die die Zeichen size() – len ganz links in dieser Zeichenkette enthält.

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

void QString::clear()

Löscht den Inhalt der Zeichenkette und setzt sie auf null.

Siehe auch resize() und isNull().

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

Vergleicht die Zeichenfolge „ s1 “ mit der Zeichenfolge „ 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 beide gleich sind.

Wenn „ cs “ auf „ Qt::CaseSensitive “ gesetzt ist (Standardeinstellung), erfolgt der Vergleich unter Berücksichtigung der Groß-/Kleinschreibung; andernfalls erfolgt der Vergleich ohne Berücksichtigung der Groß-/Kleinschreibung.

Der Vergleich unter Berücksichtigung der Groß-/Kleinschreibung basiert ausschließlich auf den numerischen Unicode-Werten der Zeichen und ist sehr schnell, entspricht jedoch nicht den Erwartungen eines Menschen. Denken Sie beispielsweise an das Sortieren 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

Führt einen Vergleich mit „ ch “ durch, wobei die Einstellung zur Groß-/Kleinschreibung „ cs “ verwendet wird.

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

Entspricht „compare(*this, other, cs)“.

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

Führt einen Vergleich mit „ s “ durch, wobei die Einstellung zur Groß-/Kleinschreibung „ cs “ verwendet wird.

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

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 beide Zeichenketten gleich sind.

Entspricht compare(*this, other, cs).

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

Führt einen Vergleich zwischen „ s1 “ und „ s2 “ durch, wobei die Einstellung zur Groß-/Kleinschreibung „ cs “ verwendet wird.

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

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

Führt einen Vergleich zwischen „ s1 “ und „ s2 “ durch, wobei die Einstellung zur Groß-/Kleinschreibung „ cs “ verwendet wird.

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

QString::const_iterator QString::constBegin() const

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

Siehe auch „ begin()“ und „ constEnd()“.

const QChar *QString::constData() const

Gibt einen Zeiger auf die in ` QString` gespeicherten Daten zurück. Mit diesem Zeiger kann auf die Zeichen zugegriffen werden, aus denen die Zeichenkette besteht.

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

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

QString::const_iterator QString::constEnd() const

Gibt einen konstanten Iterator im STL-Stil zurück, der direkt auf das Zeichen nach dem letzten Zeichen 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 “ an einer beliebigen Stelle in dieser Zeichenkette übereinstimmt; andernfalls wird „ false “ zurückgegeben.

Wenn die Übereinstimmung erfolgreich ist und rmatch nicht nullptr ist, werden die Ergebnisse der Übereinstimmung außerdem in das QRegularExpressionMatch -Objekt 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 Zeichenfolge die Zeichenfolge „ str “ enthält; andernfalls wird „ false “ zurückgegeben.

Wenn „ cs “ auf „ Qt::CaseSensitive “ gesetzt ist (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

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

Gibt „ true “ zurück, wenn diese Zeichenkette das Zeichen „ ch “ enthält; andernfalls wird „ false “ zurückgegeben.

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

Gibt „ true “ zurück, wenn diese Zeichenkette eine Instanz der Latin-1-Zeichenkette „ str “ enthält; andernfalls wird „ false “ zurückgegeben.

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

Gibt „ true “ zurück, wenn diese Zeichenfolge die Zeichenfolge „view str “ enthält; andernfalls wird „ false “ zurückgegeben.

Ist „ cs “ gleich „ Qt::CaseSensitive “ (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

Siehe auch „ indexOf()“ und „ count()“.

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

Gibt die Anzahl der (möglicherweise überlappenden) Vorkommen der Zeichenfolge „ str “ in dieser Zeichenfolge zurück.

Wenn „ cs “ auf „ Qt::CaseSensitive “ gesetzt ist (Standardeinstellung), wird bei der Suche die Groß-/Kleinschreibung berücksichtigt; andernfalls wird die Groß-/Kleinschreibung nicht berücksichtigt.

Siehe auch „ contains()“ und „ indexOf()“.

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

Gibt zurück, wie oft der reguläre Ausdruck „ re “ in der Zeichenkette vorkommt.

Aus historischen Gründen zählt diese Funktion überlappende Übereinstimmungen, sodass es im folgenden Beispiel vier Vorkommen 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 Durchlaufung der Übereinstimmungen in der Zeichenkette mit ` QRegularExpressionMatchIterator`.

Siehe auch ` QRegularExpression::globalMatch()`.

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

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

Ist ` cs ` auf ` Qt::CaseSensitive ` gesetzt (Standard), wird bei der Suche 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

Gibt die Anzahl der (möglicherweise überlappenden) Vorkommen der Zeichenfolge „ str “ in dieser Zeichenfolge zurück.

Ist „ cs “ auf „ Qt::CaseSensitive “ gesetzt (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht berücksichtigt.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch „ contains()“ und „ indexOf()“.

QString::const_reverse_iterator QString::crbegin() const

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

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

QString::const_reverse_iterator QString::crend() const

Gibt einen konstanen Reverse-Iterator im STL-Stil zurück, der in umgekehrter Reihenfolge direkt auf das Zeichen nach dem letzten Zeichen der Zeichenkette zeigt.

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

QChar *QString::data()

Gibt einen Zeiger auf die in ` QString` gespeicherten Daten zurück. Mit diesem Zeiger kann auf die Zeichen, aus denen die Zeichenkette besteht, zugegriffen und diese geändert werden.

Im Gegensatz zu ` constData()` und ` unicode()` werden die zurückgegebenen Daten immer mit einem `'\0'` abgeschlossen.

Beispiel:

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

Beachten Sie, dass der Zeiger nur so lange gültig bleibt, wie die Zeichenkette nicht auf andere Weise verändert wird. Für den schreibgeschützten Zugriff ist ` constData()` schneller, da dabei niemals eine tiefe Kopie erstellt wird.

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

const QChar *QString::data() const

Siehe auch ` fromRawData()`.

void QString::detach()

Stellt sicher, dass die Daten dieser Zeichenfolge nicht mehr mit anderen Instanzen geteilt werden.

QString::iterator QString::end()

Gibt einen Iterator im STL-Stil zurück, der direkt auf das Zeichen nach dem letzten Zeichen der Zeichenkette zeigt.

Siehe auch ` begin()` und ` constEnd()`.

QString::const_iterator QString::end() const

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 den Wert Qt::CaseSensitive hat (Standard), wird bei der Suche zwischen Groß- und Kleinschreibung unterschieden; andernfalls wird die Groß- und Kleinschreibung nicht berücksichtigt.

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.

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

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

Gibt „ true “ zurück, wenn die Zeichenfolge mit der Zeichenfolge „ str “ endet; andernfalls wird „ false “ zurückgegeben.

Ist cs gleich Qt::CaseSensitive (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

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 auf das Zeichen unmittelbar nach dem zuletzt gelöschten Zeichen zurück (d. h. das Zeichen, auf das vor dem Löschen mit „ last “ verwiesen wurde).

Diese Funktion wurde in Qt 6.1 eingeführt.

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

Entfernt das durch ` it ` bezeichnete Zeichen aus der Zeichenkette. Gibt einen Iterator auf das Zeichen zurück, das unmittelbar auf das gelöschte Zeichen folgt.

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 (Standard) ist, wird die Zeichenkette zuvor auf size angepasst.

Beispiel:

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

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

Siehe auch resize().

Gibt eine Zeichenkette zurück, die die ersten n Zeichen dieser Zeichenkette enthält (d. h. vom Anfang dieser Zeichenkette bis einschließlich des Elements an der Indexposition n, dieses jedoch nicht mit eingeschlossen).

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

Diese Funktionen wurden in Qt 6.0 eingeführt.

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

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

Erstellt ein neues „ QString “, das eine Kopie des CFString „ string “ enthält.

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

Konvertiert die ECMAScript-Zeichenkette „ jsString “ in „ QString “. Das Verhalten ist undefiniert, wenn der übergebene Parameter keine Zeichenkette 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 wurde.

Ist size gleich -1, wird stattdessen strlen(str) verwendet.

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

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

Gibt ein ` QString ` zurück, das mit der Latin-1-Zeichenkette ` str` initialisiert ist.

Diese Funktion wurde in Qt 6.0 eingeführt.

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

Gibt ein ` QString ` zurück, das 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 wurde.

Ist size gleich -1, wird stattdessen strlen(str) verwendet.

Auf Unix-Systemen entspricht dies fromUtf8(). Beachten Sie, dass diese Funktion auf Apple-Systemen NSString.defaultCStringEncoding oder CFStringGetSystemEncoding() nicht berücksichtigt, da diese Funktionen typischerweise die veraltete Kodierung „Western (Mac OS Roman)“ 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)

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

Auf Unix-Systemen entspricht dies fromUtf8(). Beachten Sie, dass diese Funktion auf Apple-Systemen NSString.defaultCStringEncoding oder CFStringGetSystemEncoding() nicht berücksichtigt, da diese Funktionen in der Regel die veraltete Kodierung „Western (Mac OS Roman)“ 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)

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

Auf Unix-Systemen entspricht dies fromUtf8(). Beachten Sie, dass diese Funktion auf Apple-Systemen NSString.defaultCStringEncoding oder CFStringGetSystemEncoding() nicht berücksichtigt, da diese Funktionen in der Regel die veraltete Kodierung „Western (Mac OS Roman)“ 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)

Erstellt ein neues „ QString “, das eine Kopie des „ string “-NSString enthält.

[static, since 6.10] QString QString::fromRawData(const char16_t *unicode, qsizetype size)

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

Jeder Versuch, die Datei „ QString “ oder Kopien davon zu ändern, führt dazu, dass eine tiefe Kopie der Daten erstellt wird, wodurch sichergestellt wird, dass die Rohdaten nicht verändert werden.

Hier ist ein Beispiel dafür, wie wir eine ` QRegularExpression ` auf Rohdaten im Speicher anwenden können, ohne die Daten in eine ` QString` kopieren zu müssen:

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

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

Diese Funktion wurde in Qt 6.10 eingeführt.

Siehe auch fromUtf16(), setRawData(), data(), constData(), nullTerminate() und nullTerminated().

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

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

Gibt eine Kopie der Zeichenkette „ str “ zurück. Es wird davon ausgegangen, dass die angegebene Zeichenkette in UTF-8 kodiert ist, und sie wird mithilfe der Funktion „ fromUtf8()“ in „ QString “ konvertiert.

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 davon ausgegangen, dass die angegebene Zeichenkette in UTF-16 kodiert ist, und sie wird mithilfe der Funktion „ fromUtf16()“ in „ QString “ konvertiert.

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

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

Gibt eine Kopie der Zeichenkette „ str “ zurück. Es wird davon ausgegangen, dass die angegebene Zeichenkette in UTF-32 kodiert ist, und sie wird mithilfe der Funktion „ fromUcs4()“ in „ QString “ konvertiert.

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

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

Gibt eine Kopie der Zeichenkette „ str “ zurück. Es wird davon ausgegangen, dass die angegebene Zeichenkette in UTF-16 kodiert ist, wenn die Größe von `wchar_t` 2 Byte beträgt (z. B. unter Windows), und in UCS-4, wenn die Größe von `wchar_t` 4 Byte 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-Zeichenkette ` unicode ` (kodiert als UTF-32) initialisiert wurde.

Ist size gleich -1 (Standard), muss unicode mit „\0 “ enden.

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

Ist size gleich -1, wird stattdessen strlen(str) verwendet.

UTF-8 ist ein Unicode-Codec und kann alle Zeichen in einer Unicode-Zeichenkette wie QString darstellen. Allerdings sind bei UTF-8 ungültige Sequenzen möglich; werden solche gefunden, 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-Codepunkte.

Diese Funktion kann verwendet werden, um eingehende Daten inkrementell zu verarbeiten, solange alle UTF-8-Zeichen innerhalb der eingehenden Daten abgeschlossen sind. Alle nicht abgeschlossenen Zeichen am Ende der Zeichenkette werden ersetzt oder unterdrückt. Für eine zustandsbehaftete Dekodierung verwenden Sie bitte QStringDecoder.

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

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

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

Diese Funktion wurde in Qt 6.0 eingeführt.

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

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

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

Diese Überladung ist nur verfügbar, wenn im C++20-Modus kompiliert wird.

Diese Funktion wurde in Qt 6.1 eingeführt.

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

Diese Überladung ist nur verfügbar, wenn im C++20-Modus kompiliert wird.

Diese Funktion wurde in Qt 6.0 eingeführt.

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

Gibt einen „ QString “ zurück, der mit den ersten „ size “ Zeichen der Unicode-Zeichenkette „ unicode “ (in ISO-10646-UTF-16 kodiert) initialisiert wurde.

Ist size gleich -1 (Standard), muss unicode mit '\0' enden.

Diese Funktion prüft auf eine Byte-Order-Markierung (BOM). Fehlt diese, wird die Byte-Reihenfolge des Hosts angenommen.

Diese Funktion ist im Vergleich zu den anderen Unicode-Konvertierungen langsam. Verwenden Sie nach Möglichkeit „ QString “ (const QChar *, qsizetype) oder „ QString “ (const QChar *).

QString Erstellt eine tiefe Kopie 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 “ verweist, konvertiert sie in Unicode und gibt das Ergebnis als „ QString “ zurück. Es wird davon ausgegangen, dass die von „ wchar_t “ verwendete Kodierung UTF-32 ist, wenn die Größe des Typs vier Byte beträgt, bzw. UTF-16, wenn die Größe zwei Byte beträgt.

Ist size gleich -1 (Standard), muss die string mit „\0 “ abgeschlossen sein.

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

QChar &QString::front()

Gibt eine Referenz auf das erste Zeichen der Zeichenkette zurück. Entspricht „ 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. Entspricht „ 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 von „ str “ in dieser Zeichenkette erkannten Latin-1-Zeichenkette zurück, wobei die Suche ausgehend von der Indexposition „ from “ vorwärts erfolgt. Gibt -1 zurück, wenn „ str “ nicht gefunden wird.

Wenn cs gleich Qt::CaseSensitive ist (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

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

Ist from gleich -1, beginnt die Suche am letzten Zeichen; ist es gleich -2, am 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 die Suche ab der Indexposition „ from “ vorwärts erfolgt. Gibt -1 zurück, wenn „ re “ an keiner Stelle übereinstimmt.

Wenn die Suche erfolgreich ist und rmatch nicht mit nullptr übereinstimmt, werden die Suchergebnisse zudem in das QRegularExpressionMatch -Objekt geschrieben, auf das rmatch verweist.

Beispiel:

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

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 Zeichenkette „ str “ in dieser Zeichenkette zurück, wobei die Suche ab der Indexposition „ from “ vorwärts erfolgt. Gibt -1 zurück, wenn „ str “ nicht gefunden wird.

Wenn „ cs “ gleich „ Qt::CaseSensitive “ ist (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

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

Ist from gleich -1, beginnt die Suche beim letzten Zeichen; ist es gleich -2, 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

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

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

Gibt die Indexposition des ersten Vorkommens der Zeichenfolge „view str “ in dieser Zeichenfolge zurück, wobei die Suche beginnend bei der Indexposition „ from “ vorwärts erfolgt. Gibt -1 zurück, wenn „ str “ nicht gefunden wird.

Ist cs gleich Qt::CaseSensitive (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

Ist from gleich -1, beginnt die Suche beim letzten Zeichen; ist es gleich -2, 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 “ an der angegebenen Position „ position “ ein und gibt eine Referenz auf diese Zeichenkette zurück.

Beispiel:

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

Diese Zeichenkette wird vergrößert, um die Einfügung aufzunehmen. Liegt „ position “ jenseits des Endes der Zeichenkette, werden Leerzeichen an die Zeichenkette angehängt, um diesen Index „ position “ zu erreichen, gefolgt von „ str “.

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

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

Fügt „ ch “ an der angegebenen Position „ position “ in die Zeichenkette ein.

Die Zeichenkette wird entsprechend der Einfügung verlängert. Liegt position jenseits des Endes der Zeichenkette, werden Leerzeichen an die Zeichenkette angehängt, um diesen position zu erreichen, gefolgt von ch.

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

Fügt die von str angezeigte Latin-1-Zeichenkette an der angegebenen Position position ein.

Diese Zeichenkette wird zur Aufnahme der Einfügung erweitert. Befindet sich position jenseits des Endes der Zeichenkette, werden Leerzeichen an die Zeichenkette angehängt, um diesen position zu erreichen, gefolgt von str.

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

Fügt die Zeichenkette „ str “ an der angegebenen Position „ position “ ein und gibt eine Referenz auf diese Zeichenkette zurück.

Die Zeichenkette wird entsprechend der Einfügung verlängert. Liegt „ position “ jenseits des Endes der Zeichenkette, werden Leerzeichen an die Zeichenkette angehängt, um diesen Index „ 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)

Fügt die UTF-8-Zeichenkette „ str “ an der angegebenen Position „ position “ ein.

Diese Zeichenkette wird vergrößert, um die Einfügung aufzunehmen. Liegt position jenseits des Endes der Zeichenkette, werden Leerzeichen an die Zeichenkette angehängt, um diese position zu erreichen, gefolgt von str.

Diese Funktion wurde in Qt 6.5 eingeführt.

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

Interpretiert den Inhalt von str als UTF-8, fügt die darin kodierte Unicode-Zeichenkette an der angegebenen Stelle position ein und gibt eine Referenz auf diese Zeichenkette zurück.

Diese Zeichenkette wird entsprechend der Einfügung verlängert. Liegt position jenseits des Endes der Zeichenkette, werden Leerzeichen an die Zeichenkette angehängt, um diesen 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)

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

Diese Zeichenkette wird entsprechend der Einfügung verlängert. Liegt position jenseits des Endes der Zeichenkette, werden Leerzeichen an die Zeichenkette angehängt, um diesen 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)

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

Die Zeichenkette wird entsprechend erweitert, um Platz für die Einfügung zu schaffen. Liegt position jenseits des Endes der Zeichenkette, werden Leerzeichen an die Zeichenkette angehängt, um diese position zu erreichen, gefolgt von size Zeichen aus dem Array QChar unicode .

[constexpr noexcept] bool QString::isEmpty() const

Gibt „ true “ zurück, wenn die Zeichenfolge 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 aus Kleinbuchstaben besteht, d. h., wenn sie mit ihrer „ toLower()“-Umwandlung identisch ist.

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

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

[constexpr] 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-Zeichenketten und leeren Zeichenketten. Für die meisten Anwendungen ist es entscheidend, ob eine Zeichenkette Daten enthält oder nicht, und dies lässt sich mit der Funktion ` isEmpty()` feststellen.

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., wenn sie mit ihrer „ toUpper()“-Umwandlung identisch ist.

Beachten Sie, dass dies nicht bedeutet, dass die Zeichenkette keine Kleinbuchstaben enthält (einige Kleinbuchstaben haben keine Großbuchstaben-Folding; sie bleiben durch toUpper() unverändert). Weitere Informationen finden Sie im Unicode-Standard, 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 diese erfolgreich aus UTF-16 dekodiert werden können. Es wird davon ausgegangen, dass die Daten in der Host-Byte-Reihenfolge vorliegen; das Vorhandensein eines BOM ist irrelevant.

Siehe auch QStringView::isValidUtf16().

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 Funktionen wurden in Qt 6.0 eingeführt.

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

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 gleich -2, am vorletzten Zeichen und so weiter.

Gibt -1 zurück, wenn „ re “ an keiner Stelle übereinstimmt.

Ist die Suche erfolgreich und ist „ rmatch “ nicht „ nullptr “, werden die Ergebnisse der Suche zudem in das „ QRegularExpressionMatch “-Objekt geschrieben, auf das „ rmatch “ verweist.

Beispiel:

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

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 die Suche rückwärts ab der Indexposition „ from “ erfolgt.

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

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

Ist ` cs ` auf ` Qt::CaseSensitive ` gesetzt (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls erfolgt die Suche ohne Berücksichtigung der Groß-/Kleinschreibung.

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 wurde in Qt 6.3 eingeführt.

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

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 (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

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

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

Wenn cs gleich Qt::CaseSensitive ist (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

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

Gibt die Indexposition der letzten Übereinstimmung des regulären Ausdrucks „ re “ in der Zeichenkette zurück. Gibt -1 zurück, wenn „ re “ an keiner Stelle übereinstimmt.

Wenn die Suche erfolgreich ist und „ rmatch “ nicht mit „ nullptr “ übereinstimmt, werden die Suchergebnisse zusätzlich in das Objekt „ QRegularExpressionMatch “ geschrieben, auf das „ rmatch “ verweist.

Beispiel:

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

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

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 (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

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

Gibt die Indexposition des letzten Vorkommens des Zeichens „ ch “ in dieser Zeichenkette zurück, wobei die Suche rückwärts ab der Indexposition „ from “ erfolgt.

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

Gibt die Indexposition des letzten Vorkommens der von ` str ` in dieser Zeichenkette erkannten Latin-1-Zeichenkette zurück, wobei die Suche rückwärts ab der Indexposition ` from` erfolgt.

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

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

Ist „ cs “ auf „ Qt::CaseSensitive “ gesetzt (Standard), wird bei der Suche die Groß-/Kleinschreibung berücksichtigt; andernfalls wird die Groß-/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

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

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

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

Ist „ cs “ gleich „ Qt::CaseSensitive “ (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht berücksichtigt.

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

Gibt eine Teilzeichenkette zurück, die die n Zeichen ganz links in dieser Zeichenkette enthält (d. h. vom Anfang dieser Zeichenkette bis einschließlich des Elements an der Indexposition n).

Wenn Sie wissen, dass n nicht außerhalb des zulässigen Bereichs liegen kann, verwenden Sie in neuem Code stattdessen first(), da dies schneller ist.

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

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

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

Gibt eine Zeichenkette der Größe width zurück, die diese Zeichenkette enthält, ergänzt durch das Zeichen fill.

Wenn „ truncate “ gleich „ false “ ist und die Anzahl der Zeichen in der Zeichenkette gemäß „ size()“ größer als „ width “ ist, dann ist die zurückgegebene Zeichenkette eine Kopie der ursprünglichen Zeichenkette.

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

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

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

Siehe auch ` rightJustified()`.

[constexpr noexcept] qsizetype QString::length() const

Gibt die Anzahl der Zeichen in dieser Zeichenkette zurück. Entspricht „ size()“.

Siehe auch resize().

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

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

Der Vergleich erfolgt lokal- und plattformabhängig. Verwenden Sie diese Funktion, um dem Benutzer sortierte Listen von Zeichenfolgen anzuzeigen.

Siehe auch compare(), QLocale und Comparing Strings.

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

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

Der Vergleich erfolgt lokal- und plattformabhängig. Verwenden Sie diese Funktion, um dem Benutzer sortierte Listen von Zeichenfolgen anzuzeigen.

Entspricht ` localeAwareCompare(*this, other)`.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch „ Comparing Strings “.

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

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

Der Vergleich erfolgt lokal- und plattformabhängig. Verwenden Sie diese Funktion, um dem Benutzer sortierte Listen von Zeichenfolgen anzuzeigen.

Entspricht „ localeAwareCompare(*this, other) “.

Siehe auch „ Comparing Strings “.

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

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

Der Vergleich erfolgt lokal- und plattformabhängig. Verwenden Sie diese Funktion, um dem Benutzer sortierte Listen von Zeichenfolgen anzuzeigen.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch „ Comparing Strings “.

Die Funktion gibt die maximale Anzahl an Elementen zurück, die die Zeichenkette theoretisch enthalten kann. In der Praxis kann diese Zahl jedoch deutlich geringer ausfallen, da sie durch den dem System zur Verfügung stehenden Speicher begrenzt ist.

Diese Funktionen wurden in Qt 6.8 eingeführt.

Gibt eine Zeichenkette zurück, die die Zeichen „ n “ dieser Zeichenkette enthält, beginnend mit dem angegebenen Index „ position “ bis einschließlich der Elementposition position + n.

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

Gibt eine leere Zeichenkette zurück, wenn der Index „ position “ die Länge der Zeichenkette überschreitet. Wenn in der Zeichenkette, beginnend bei der angegebenen Position „ position “, weniger als „ n “ Zeichen verfügbar sind oder wenn „ n “ den Wert -1 hat (Standard), gibt die Funktion alle Zeichen zurück, die ab der angegebenen Position „ position “ verfügbar sind.

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

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

Gibt die Zeichenkette in der angegebenen Unicode-Normalisierungs mode zurück, gemäß der im Unicode-Standard festgelegten „ version “.

[since 6.10] QString &QString::nullTerminate()

Wenn diese Zeichenkette nicht null-terminiert ist, erstellt diese Methode eine tiefe Kopie der Daten und versieht sie mit einem Null-Terminator.

Eine Zeichenkette vom Typ ` QString ` ist standardmäßig null-terminiert. In einigen Fällen (z. B. bei Verwendung von ` fromRawData()`) endet die Zeichenkette jedoch nicht unbedingt mit einem ` \0 `-Zeichen, was beim Aufruf von Methoden, die eine null-terminierte Zeichenkette erwarten, zu Problemen führen kann.

Diese Funktion wurde in Qt 6.10 eingeführt.

Siehe auch „ nullTerminated()“, „ fromRawData()“ und „ setRawData()“.

Gibt eine Kopie dieser Zeichenkette zurück, die immer mit einem Null-Zeichen abgeschlossen ist.

Diese Funktionen wurden in Qt 6.10 eingeführt.

Siehe auch nullTerminate(), fromRawData() und setRawData().

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

Gibt eine Zeichenfolge zurück, die der Zahl „ n “ gemäß der angegebenen Basis „ base “ entspricht.

Die Basis ist standardmäßig 10 und muss zwischen 2 und 36 liegen. Bei anderen Basen als 10 wird „ n “ als vorzeichenlose Ganzzahl behandelt.

Die Formatierung erfolgt immer gemäß „ QLocale::C “, d. h. „English/UnitedStates“. Um eine lokalisierte Zeichenfolgendarstellung einer Zahl zu erhalten, verwenden Sie „ QLocale::toString()“ mit der entsprechenden Locale.

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 Zeichenfolge zurück, die die Gleitkommazahl n darstellt.

Gibt eine Zeichenkette zurück, die n darstellt und gemäß den angegebenen Formaten format und precision formatiert ist.

Bei Formaten mit einem Exponenten wird das Vorzeichen des Exponenten angezeigt und der Exponent besteht aus mindestens zwei Ziffern, wobei der Exponent bei Bedarf links mit Nullen aufgefüllt wird.

Siehe auch setNum(), QLocale::toString(), QLocale::FloatingPointPrecisionOption sowie Number formats.

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

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

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

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

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

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

Fügt die Zeichenfolge „ str “ am Anfang dieser Zeichenfolge ein und gibt eine Referenz auf diese Zeichenfolge zurück.

Dieser Vorgang ist in der Regel sehr schnell (konstante Laufzeit), da „ QString “ zusätzlichen Speicherplatz am Anfang der Zeichenkettendaten vorab reserviert, sodass die Zeichenkette wachsen kann, ohne dass jedes Mal die gesamte Zeichenkette neu zugewiesen werden muss.

Beispiel:

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

Siehe auch ` append()` und ` insert()`.

QString &QString::prepend(QChar ch)

Fügt dem String das Zeichen „ ch “ voran.

QString &QString::prepend(QLatin1StringView str)

Fügt die von ` str ` ausgewertete Latin-1-Zeichenkette an diese Zeichenkette an.

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

Fügt die Zeichenfolgenansicht „ str “ am Anfang dieser Zeichenfolge ein und gibt eine Referenz auf diese Zeichenfolge zurück.

Diese Funktion wurde in Qt 6.0 eingeführt.

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

Fügt der UTF-8-Zeichenkette „ str “ vor.

Diese Funktion wurde in Qt 6.5 eingeführt.

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

Fügt dem String das Byte-Array „ ba “ vor. Das Byte-Array wird mithilfe der Funktion „ fromUtf8()“ in Unicode konvertiert.

Sie können diese Funktion deaktivieren, indem Sie bei der Kompilierung Ihrer Anwendungen ` QT_NO_CAST_FROM_ASCII ` definieren. Dies kann beispielsweise nützlich sein, wenn Sie sicherstellen möchten, dass alle für den Benutzer sichtbaren Zeichenfolgen die Funktion ` QObject::tr()` durchlaufen.

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

Fügt dieser Zeichenkette die Zeichenkette „ str “ vor. Der „const char“-Zeiger wird mithilfe der Funktion „ fromUtf8()“ in Unicode konvertiert.

Sie können diese Funktion deaktivieren, indem Sie beim Kompilieren Ihrer Anwendungen ` QT_NO_CAST_FROM_ASCII ` definieren. Dies kann beispielsweise nützlich sein, wenn Sie sicherstellen möchten, dass alle für den Benutzer sichtbaren Zeichenfolgen die Funktion ` QObject::tr()` durchlaufen.

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

Fügt dieser Zeichenkette die Zeichen „ len “ aus dem Array „ QChar “ str vor und gibt eine Referenz auf diese Zeichenkette zurück.

void QString::push_back(const QString &other)

Diese Funktion dient der STL-Kompatibilität und hängt die angegebene Zeichenkette „ other “ an das Ende dieser Zeichenkette an. Sie entspricht „ append(other) “.

Siehe auch ` append()`.

void QString::push_back(QChar ch)

Fügt das angegebene Zeichen „ ch “ am Ende dieser Zeichenkette an.

void QString::push_front(const QString &other)

Diese Funktion dient der STL-Kompatibilität und fügt die angegebene Zeichenfolge „ other “ am Anfang dieser Zeichenfolge ein. Sie entspricht „ prepend(other) “.

Siehe auch prepend().

void QString::push_front(QChar ch)

Fügt das angegebene Zeichen „ ch “ am Anfang dieser Zeichenkette ein.

QString::reverse_iterator QString::rbegin()

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

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

QString::const_reverse_iterator QString::rbegin() const

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

Entfernt alle Vorkommen des regulären Ausdrucks „ re “ aus der Zeichenkette und gibt eine Referenz auf die Zeichenkette zurück. Beispiel:

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

Durch das Entfernen von Elementen bleibt die Kapazität der Zeichenkette erhalten, und die Menge des zugewiesenen Speichers wird nicht verringert. Um überschüssige Kapazität abzubauen und so viel Speicher wie möglich freizugeben, rufen Sie ` squeeze()` nach der letzten Änderung der Zeichenkettengröße auf.

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

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

Entfernt jedes Vorkommen des Zeichens „ ch “ aus dieser Zeichenkette und gibt eine Referenz auf diese Zeichenkette zurück.

Wenn „ cs “ auf „ Qt::CaseSensitive “ gesetzt ist (Standardeinstellung), wird bei der Suche die Groß-/Kleinschreibung berücksichtigt; andernfalls wird die Groß-/Kleinschreibung nicht berücksichtigt.

Beispiel:

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

Dies entspricht „ replace(ch, "", cs) “.

Das Entfernen von Elementen bewahrt die Kapazität der Zeichenkette und verringert nicht die Menge des zugewiesenen Speichers. Um überschüssige 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 alle Vorkommen der angegebenen Zeichenfolge „ str “ aus dieser Zeichenfolge und gibt eine Referenz auf diese Zeichenfolge zurück.

Wenn „ cs “ auf „ Qt::CaseSensitive “ gesetzt ist (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

Dies entspricht der Funktion ` replace(str, "", cs)`.

Beim Entfernen von Elementen bleibt die Kapazität der Zeichenkette erhalten, und die Menge des zugewiesenen Speichers wird nicht verringert. Um überschüssige Kapazität abzubauen und so viel Speicher wie möglich freizugeben, rufen Sie ` squeeze()` nach der letzten Änderung der Zeichenkettengröße auf.

Siehe auch ` replace()`.

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

Entfernt Zeichen vom Typ „ n “ aus der Zeichenkette, beginnend am angegebenen Index „ position “, und gibt eine Referenz auf die Zeichenkette zurück.

Befindet sich der angegebene Index „ position “ zwar innerhalb der Zeichenkette, liegt jedoch „ position + n “ über das Ende der Zeichenkette hinaus, wird die Zeichenkette an der angegebenen Stelle „ position “ abgeschnitten.

Ist n <= 0, wird nichts geändert.

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

Das Entfernen von Elementen bewahrt die Kapazität der Zeichenkette und verringert nicht die Menge des zugewiesenen Speichers. Um überschüssige Kapazität abzubauen und so viel Speicher wie möglich freizugeben, rufen Sie squeeze() nach der letzten Änderung der Zeichenkettengröße auf.

Siehe auch „ insert()“ und „ replace()“.

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

Entfernt alle Vorkommen der durch str interpretierten angegebenen Latin-1-Zeichenkette aus dieser Zeichenkette und gibt eine Referenz auf diese Zeichenkette zurück.

Ist ` cs ` auf ` Qt::CaseSensitive ` gesetzt (Standard), wird bei der Suche die Groß-/Kleinschreibung berücksichtigt; andernfalls wird die Groß-/Kleinschreibung nicht berücksichtigt.

Dies entspricht der Funktion ` replace(str, "", cs)`.

Das Entfernen von Elementen bewahrt die Kapazität der Zeichenkette und verringert nicht die Menge des zugewiesenen Speichers. Um überschüssige 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 “. Liegt „ pos “ außerhalb des zulässigen Bereichs (d. h. „ pos “ >= „ size()“), führt diese Funktion keine Aktion aus.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch remove().

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

Entfernt das erste Zeichen dieser Zeichenkette. Ist die Zeichenkette leer, führt diese Funktion keine Aktion aus.

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 aus der Zeichenkette, für die das Prädikat „ pred “ den Wert „true“ zurückgibt. 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 dieser Zeichenkette. Ist die Zeichenkette leer, führt diese Funktion keine Aktion aus.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch ` remove()`.

QString::reverse_iterator QString::rend()

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

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

QString::const_reverse_iterator QString::rend() const

QString QString::repeated(qsizetype times) const

Gibt eine Kopie dieser Zeichenkette zurück, die so oft wiederholt wird, wie in „ times “ angegeben.

Ist times kleiner als 1, 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 n, beginnend am Index position, durch die Zeichenfolge after und gibt eine Referenz 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)

Ersetzt jedes Vorkommen des regulären Ausdrucks „ re “ in der Zeichenkette durch „ after “. Gibt eine Referenz auf die Zeichenkette zurück. Beispiel:

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

Bei regulären Ausdrücken, die Erfassungsgruppen enthalten, werden 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)

Ersetzt jedes Vorkommen des Zeichens „ before “ durch das Zeichen „ after “ und gibt eine Referenz auf diese Zeichenkette zurück.

Ist cs gleich Qt::CaseSensitive (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

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

Ersetzt jedes Vorkommen des Zeichens „ c “ durch die Zeichenkette „ after “ und gibt eine Referenz auf diese Zeichenkette zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

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

Ersetzt jedes Vorkommen des Zeichens „ ch “ in der Zeichenkette durch „ after “ und gibt eine Referenz auf diese Zeichenkette zurück.

Wenn „ cs “ gleich „ Qt::CaseSensitive “ ist (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

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

Ersetzt jedes Vorkommen der Latin-1-Zeichenkette, die unter before angezeigt wird, in dieser Zeichenkette durch die Latin-1-Zeichenkette, die unter after angezeigt wird, und gibt eine Referenz auf diese Zeichenkette zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

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

Ersetzt jedes Vorkommen der von before angezeigten Latin-1-Zeichenkette in dieser Zeichenkette durch die Zeichenkette after und gibt eine Referenz auf diese Zeichenkette zurück.

Wenn cs gleich Qt::CaseSensitive ist (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

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

Ersetzt jedes Vorkommen der Zeichenfolge „ before “ durch die Zeichenfolge „ after “ und gibt eine Referenz auf diese Zeichenfolge zurück.

Wenn „ cs “ gleich „ Qt::CaseSensitive “ ist (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

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

Ersetzt jedes Vorkommen der Zeichenfolge „ before “ durch die Zeichenfolge „ after “ und gibt eine Referenz auf diese Zeichenfolge zurück.

Wenn „ cs “ gleich „ Qt::CaseSensitive “ ist (Standard), wird bei der Suche die Groß-/Kleinschreibung beachtet; andernfalls wird die Groß-/Kleinschreibung nicht beachtet.

Beispiel:

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