QByteArray Class

Dokumentation zu den Mitgliedsfunktionen

[constexpr noexcept] QByteArray::QByteArray()

Erstellt ein leeres Byte-Array.

Siehe auch ` isEmpty()`.

[explicit, since 6.8] QByteArray::QByteArray(QByteArrayView v)

Erstellt ein Byte-Array, das mit den Daten der Byte-Array-Ansicht initialisiert ist.

Das `QByteArray` ist genau dann null, wenn ` v ` null ist.

Diese Funktion wurde in Qt 6.8 eingeführt.

QByteArray::QByteArray(const char *data, qsizetype size = -1)

Erstellt ein Byte-Array, das die ersten size Bytes des Arrays data enthält.

Ist data gleich 0, wird ein Null-Byte-Array erstellt.

Ist size negativ, wird angenommen, dass data auf eine durch „\0 “ begrenzte Zeichenkette verweist, und ihre Länge wird dynamisch ermittelt.

QByteArray erstellt eine tiefe Kopie der Zeichenkettendaten.

Siehe auch fromRawData().

QByteArray::QByteArray(qsizetype size, Qt::Initialization)

Erstellt ein Byte-Array der Größe size mit nicht initialisiertem Inhalt.

Beispiel:

QByteArray buffer(123, Qt::Uninitialized);

QByteArray::QByteArray(qsizetype size, char ch)

Erzeugt ein Byte-Array der Größe size, wobei jedes Byte auf ch gesetzt wird.

Siehe auch fill().

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

Erstellt eine Kopie von ` other`.

Dieser Vorgang dauert konstant lange, da `QByteArray` implizit gemeinsam genutzt wird. Dadurch ist die Rückgabe eines `QByteArray` 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] QByteArray::QByteArray(QByteArray &&other)

Erstellt eine QByteArray-Instanz per Move-Konstruktion, sodass diese auf dasselbe Objekt verweist, auf das zuvor „ other “ verwiesen hat.

[noexcept] QByteArray::~QByteArray()

Löscht das Byte-Array.

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

Fügt das Byte-Array „ ba “ an das Ende dieses Byte-Arrays an.

Beispiel:

QByteArray x("free");
QByteArray y("dom");
x.append(y);
// x == "freedom"

Dies entspricht „insert(size(), ba)“.

Hinweis: ` QByteArray ` ist eine implizit gemeinsam genutzte Klasse. Wenn Sie also an ein leeres Byte-Array anhängen, nutzt das Byte-Array lediglich die in ` ba` enthaltenen Daten. In diesem Fall erfolgt kein Kopieren der Daten, was konstante Zeit in Anspruch nimmt. Wird eine gemeinsam genutzte Instanz geändert, wird sie kopiert (Copy-on-Write), was lineare Zeit in Anspruch nimmt.

Ist das Byte-Array, an das angehängt wird, nicht leer, wird eine tiefe Kopie der Daten erstellt, was lineare Zeit in Anspruch nimmt.

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

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

QByteArray &QByteArray::append(QByteArrayView data)

Fügt „ data “ an dieses Byte-Array an.

QByteArray &QByteArray::append(char ch)

Fügt das Byte- ch, an dieses Byte-Array an.

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

Fügt die durch „\0 “ begrenzte Zeichenkette „ str “ an dieses Byte-Array an.

QByteArray &QByteArray::append(const char *str, qsizetype len)

Fügt die ersten len Bytes, beginnend bei str, an dieses Byte-Array an und gibt eine Referenz auf dieses Byte-Array zurück. Die angehängten Bytes können „\0 “-Bytes enthalten.

Ist len negativ, wird str als durch „\0 “ abgeschlossene Zeichenkette angesehen, und die zu kopierende Länge wird automatisch mithilfe von qstrlen() ermittelt.

Ist ` len ` gleich Null oder ist ` str ` null, wird dem Byte-Array nichts angehängt. Stellen Sie sicher, dass ` len ` nicht länger ist als ` str`.

QByteArray &QByteArray::append(qsizetype count, char ch)

Fügt count Kopien des Byte- ch s an dieses Byte-Array an und gibt eine Referenz auf dieses Byte-Array zurück.

Ist ` count ` negativ oder gleich Null, wird dem Byte-Array nichts angehängt.

[since 6.6] QByteArray &QByteArray::assign(QByteArrayView v)

Ersetzt den Inhalt dieses Byte-Arrays durch eine Kopie von v und gibt eine Referenz auf dieses Byte-Array zurück.

Die Größe dieses Byte-Arrays entspricht der Größe von ` v`.

Diese Funktion reserviert nur dann Speicher, wenn die Größe von ` v ` die Kapazität dieses Byte-Arrays überschreitet oder dieses Byte-Array gemeinsam genutzt wird.

Diese Funktion wurde in Qt 6.6 eingeführt.

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

Ersetzt den Inhalt dieses Byte-Arrays durch eine Kopie der Elemente im Iterator-Bereich [first, last) und gibt eine Referenz auf dieses Byte-Array zurück.

Die Größe dieses Byte-Arrays entspricht der Anzahl der Elemente im Bereich [first, last).

Diese Funktion reserviert nur dann Speicher, wenn die Anzahl der Elemente im Bereich die Kapazität dieses Byte-Arrays überschreitet oder dieses Byte-Array gemeinsam genutzt wird.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn InputIterator die Anforderungen eines LegacyInputIterator erfüllt.

Diese Funktion wurde in Qt 6.6 eingeführt.

[since 6.6] QByteArray &QByteArray::assign(qsizetype n, char c)

Ersetzt den Inhalt dieses Byte-Arrays durch n Kopien von c und gibt eine Referenz auf dieses Byte-Array zurück.

Die Größe dieses Byte-Arrays entspricht n, wobei dieser Wert nicht negativ sein darf.

Diese Funktion reserviert nur dann Speicher, wenn „ n “ die Kapazität dieses Byte-Arrays überschreitet oder dieses Byte-Array gemeinsam genutzt wird.

Diese Funktion wurde in Qt 6.6 eingeführt.

Siehe auch ` fill()`.

char QByteArray::at(qsizetype i) const

Gibt das Byte an der Indexposition i im Byte-Array zurück.

i muss eine gültige Indexposition im Byte-Array sein (d. h. 0 <= i < size()).

Siehe auch ` operator[]()`.

char &QByteArray::back()

Gibt eine Referenz auf das letzte Byte im Byte-Array zurück. Entspricht „ operator[](size() - 1) “.

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

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

char QByteArray::back() const

Gibt das letzte Byte im Byte-Array zurück. Entspricht „ at(size() - 1) “.

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

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

QByteArray::iterator QByteArray::begin()

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

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

[noexcept] QByteArray::const_iterator QByteArray::begin() const

qsizetype QByteArray::capacity() const

Gibt die maximale Anzahl an Bytes zurück, die im Byte-Array 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 „ QByteArray “ bereitzustellen. Im Allgemeinen werden Sie diese Funktion so gut wie nie aufrufen müssen. Wenn Sie wissen möchten, wie viele Bytes sich im Byte-Array befinden, rufen Sie „ size()“ auf.

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

[noexcept] QByteArray::const_iterator QByteArray::cbegin() const

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

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

[noexcept] QByteArray::const_iterator QByteArray::cend() const

Gibt einen konstanten Iterator im STL-Stil zurück, der direkt auf das letzte Byte im Byte-Array zeigt.

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

void QByteArray::chop(qsizetype n)

Entfernt n Bytes vom Ende des Byte-Arrays.

Ist ` n ` größer als ` size()`, ist das Ergebnis ein leeres Byte-Array.

Beispiel:

QByteArray ba("STARTTLS\r\n");
ba.chop(2);                 // ba == "STARTTLS"

Siehe auch „ truncate()“, „ resize()“ und „ first()“.

Gibt ein Byte-Array zurück, das die Bytes ganz links ( size() – len ) dieses Byte-Arrays enthält.

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

void QByteArray::clear()

Löscht den Inhalt des Byte-Arrays und setzt ihn auf null.

Siehe auch resize() und isNull().

[noexcept, since 6.0] int QByteArray::compare(QByteArrayView bv, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Gibt eine ganze Zahl zurück, die kleiner als, gleich oder größer als Null ist, je nachdem, ob dieser QByteArray vor, an derselben Position wie oder nach dem QByteArrayView bv sortiert wird. Der Vergleich erfolgt unter Berücksichtigung der Groß-/Kleinschreibung cs.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch operator== und Character Case.

[noexcept] QByteArray::const_iterator QByteArray::constBegin() const

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

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

[noexcept] const char *QByteArray::constData() const

Gibt einen Zeiger auf die im Byte-Array gespeicherten konstanten Daten zurück. Der Zeiger kann verwendet werden, um auf die Bytes zuzugreifen, aus denen das Array besteht. Die Daten werden mit „\0 “ abgeschlossen, es sei denn, das Objekt „ QByteArray “ wurde aus Rohdaten erstellt.

Der Zeiger bleibt gültig, solange keine Trennung erfolgt und das ` QByteArray ` nicht verändert wird.

Diese Funktion ist vor allem nützlich, um ein Byte-Array an eine Funktion zu übergeben, die ein ` const char *` akzeptiert.

Hinweis: Ein ` QByteArray ` kann beliebige Byte-Werte speichern, einschließlich `'\0's`, doch die meisten Funktionen, die ` char * `-Argumente entgegennehmen, gehen davon aus, dass die Daten am ersten `'\0` enden, auf das sie stoßen.

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

[noexcept] QByteArray::const_iterator QByteArray::constEnd() const

Gibt einen konstanten Iterator im STL-Stil zurück, der direkt auf das letzte Byte im Byte-Array zeigt.

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

[since 6.0] bool QByteArray::contains(QByteArrayView bv) const

Gibt „ true “ zurück, wenn dieses Byte-Array ein Vorkommen der von „ bv “ untersuchten Byte-Sequenz enthält; andernfalls wird „ false “ zurückgegeben.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch indexOf() und count().

bool QByteArray::contains(char ch) const

Gibt „ true “ zurück, wenn das Byte-Array das Byte „ ch “ enthält; andernfalls wird „ false “ zurückgegeben.

[since 6.0] qsizetype QByteArray::count(QByteArrayView bv) const

Gibt die Anzahl der (möglicherweise überlappenden) Vorkommen der von „ bv “ in diesem Byte-Array erkannten Byte-Sequenz zurück.

Diese Funktion wurde in Qt 6.0 eingeführt.

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

qsizetype QByteArray::count(char ch) const

Gibt die Anzahl der Vorkommen der Byte- ch s im Byte-Array zurück.

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

[noexcept] QByteArray::const_reverse_iterator QByteArray::crbegin() const

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

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

[noexcept] QByteArray::const_reverse_iterator QByteArray::crend() const

Gibt einen konstanten Reverse-Iterator im STL-Stil zurück, der in umgekehrter Reihenfolge direkt auf das letzte Byte des Byte-Arrays zeigt.

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

char *QByteArray::data()

Gibt einen Zeiger auf die im Byte-Array gespeicherten Daten zurück. Mit diesem Zeiger kann auf die Bytes des Arrays zugegriffen und diese geändert werden. Die Daten werden durch „\0 “ abgeschlossen, d. h., die Anzahl der Bytes, auf die Sie über den zurückgegebenen Zeiger zugreifen können, beträgt size() + 1, einschließlich des Abschlusszeichens „\0 “.

Beispiel:

QByteArray ba("Hello world");
char *data = ba.data();
while (*data) {
    cout << "[" << *data << "]" << endl;
    ++data;
}

Der Zeiger bleibt gültig, solange keine Abkopplung erfolgt und die ` QByteArray ` nicht geändert wird.

Für den schreibgeschützten Zugriff ist ` constData()` schneller, da dabei niemals eine tiefe Kopie erstellt wird.

Diese Funktion ist vor allem nützlich, um ein Byte-Array an eine Funktion zu übergeben, die einen ` const char *` akzeptiert.

Das folgende Beispiel erstellt eine Kopie des von `data()` zurückgegebenen `char*`, beschädigt jedoch den Heap und führt zu einem Absturz, da es kein Byte für das `'\0'` am Ende reserviert:

QString tmp = "test";
QByteArray text = tmp.toLocal8Bit();
char *data = new char[text.size()];
strcpy(data, text.data());
delete [] data;

Hier wird die richtige Speichermenge zugewiesen:

QString tmp = "test";
QByteArray text = tmp.toLocal8Bit();
char *data = new char[text.size() + 1];
strcpy(data, text.data());
delete [] data;

Hinweis: Ein ` QByteArray ` kann beliebige Byte-Werte speichern, einschließlich `'\0`-Zeichen, doch die meisten Funktionen, die ` char * `-Argumente entgegennehmen, gehen davon aus, dass die Daten am ersten `'\0` enden, auf das sie stoßen.

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

[noexcept] const char *QByteArray::data() const

QByteArray::iterator QByteArray::end()

Gibt einen Iterator im STL-Stil zurück, der direkt auf das letzte Byte im Byte-Array zeigt.

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

[noexcept] QByteArray::const_iterator QByteArray::end() const

[since 6.0] bool QByteArray::endsWith(QByteArrayView bv) const

Gibt „ true “ zurück, wenn dieses Byte-Array mit der unter bv beschriebenen Byte-Sequenz endet; andernfalls wird „ false “ zurückgegeben.

Beispiel:

QByteArray url("http://qt-project.org/doc/qt-5.0/qtdoc/index.html");
if (url.endsWith(".html"))
    {/*...*/}

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch startsWith() und last().

bool QByteArray::endsWith(char ch) const

Gibt „ true “ zurück, wenn dieses Byte-Array mit dem Byte „ ch “ endet; andernfalls wird „ false “ zurückgegeben.

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

Entfernt aus dem Byte-Array die Zeichen im halboffenen Bereich [ first, last ). Gibt einen Iterator auf das Zeichen zurück, auf das last vor dem Löschen verwies.

Diese Funktion wurde in Qt 6.1 eingeführt.

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

Entfernt das durch ` it ` bezeichnete Zeichen aus dem Byte-Array. Gibt einen Iterator auf das Zeichen zurück, das unmittelbar auf das gelöschte Zeichen folgt.

QByteArray ba = "abcdefg";
auto it = ba.erase(ba.cbegin()); // ba is now "bcdefg" and it points to "b"

Diese Funktion wurde in Qt 6.5 eingeführt.

QByteArray &QByteArray::fill(char ch, qsizetype size = -1)

Setzt jedes Byte im Byte-Array auf „ ch “. Wenn „ size “ ungleich -1 (Standardwert) ist, wird das Byte-Array zuvor auf die Größe „size size “ angepasst.

Beispiel:

QByteArray ba("Istambul");
ba.fill('o');
// ba == "oooooooo"

ba.fill('X', 2);
// ba == "XX"

Siehe auch ` resize()`.

Gibt die ersten n Bytes des Byte-Arrays zurück.

Beispiel:

QByteArray x("Pineapple");
QByteArray 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] QByteArray QByteArray::fromBase64(const QByteArray &base64, QByteArray::Base64Options options = Base64Encoding)

Gibt eine dekodierte Kopie des Base64-Arrays base64 zurück, wobei die unter options definierten Optionen verwendet werden. Wenn options den Wert IgnoreBase64DecodingErrors (Standard) enthält, wird die Eingabe nicht auf Gültigkeit geprüft; ungültige Zeichen in der Eingabe werden übersprungen, sodass der Dekodierungsprozess mit den nachfolgenden Zeichen fortgesetzt werden kann. Wenn options den Wert AbortOnBase64DecodingErrors enthält, wird die Dekodierung beim ersten ungültigen Zeichen abgebrochen.

Beispiel:

QByteArray text = QByteArray::fromBase64("UXQgaXMgZ3JlYXQh");
text.data();            // returns "Qt is great!"

QByteArray::fromBase64("PHA+SGVsbG8/PC9wPg==", QByteArray::Base64Encoding); // returns "<p>Hello?</p>"
QByteArray::fromBase64("PHA-SGVsbG8_PC9wPg==", QByteArray::Base64UrlEncoding); // returns "<p>Hello?</p>"

Der zur Dekodierung von Base64-kodierten Daten verwendete Algorithmus ist in RFC 4648 definiert.

Gibt die dekodierten Daten zurück oder, falls die Option „ AbortOnBase64DecodingErrors “ übergeben wurde und die Eingabedaten ungültig waren, ein leeres Byte-Array.

Siehe auch „ toBase64()“ und „ fromBase64Encoding()“.

Dekodiert das Base64-Array base64 unter Verwendung der in options definierten Optionen. Wenn options den Wert IgnoreBase64DecodingErrors (Standard) enthält, wird die Eingabe nicht auf Gültigkeit geprüft; ungültige Zeichen in der Eingabe werden übersprungen, sodass der Dekodierungsprozess mit den nachfolgenden Zeichen fortgesetzt wird. Wenn options den Wert AbortOnBase64DecodingErrors enthält, wird die Dekodierung beim ersten ungültigen Zeichen beendet.

Beispiel:

void process(const QByteArray &);

if (auto result = QByteArray::fromBase64Encoding(encodedData))
    process(*result);

Der zur Dekodierung von Base64-kodierten Daten verwendete Algorithmus ist in RFC 4648 definiert.

Gibt ein `QByteArrayFromBase64Result`-Objekt zurück, das die dekodierten Daten sowie ein Flag enthält, das angibt, ob die Dekodierung erfolgreich war. Wenn die Option ` AbortOnBase64DecodingErrors ` übergeben wurde und die Eingabedaten ungültig waren, ist der Inhalt der dekodierten Daten nicht spezifiziert.

Siehe auch ` toBase64()`.

[static] QByteArray QByteArray::fromCFData(CFDataRef data)

Erstellt ein neues ` QByteArray `, das eine Kopie des `CFData`-Objekts ` data` enthält.

Siehe auch fromRawCFData(), fromRawData(), toRawCFData() und toCFData().

[static, since 6.5] QByteArray QByteArray::fromEcmaUint8Array(emscripten::val uint8array)

Erstellt ein neues ` QByteArray `, das eine Kopie des `Uint8Array`- uint8array s enthält.

Diese Funktion überträgt Daten aus einem JavaScript-Datenpuffer – der aus C++-Code nicht adressierbar ist – in den Heap-Speicher eines ` QByteArray`. Das `Uint8Array` kann freigegeben werden, sobald diese Funktion zurückkehrt und eine Kopie erstellt wurde.

Das Argument „ uint8array “ muss ein „emscripten::val“ sein, das auf ein „Uint8Array“-Objekt verweist, das beispielsweise aus einer globalen JavaScript-Variablen stammt:

emscripten::val uint8array = emscripten::val::global("g_uint8array");
QByteArray byteArray = QByteArray::fromEcmaUint8Array(uint8array);

Diese Funktion gibt ein null- QByteArray zurück, wenn die Größe des Uint8Array die maximale Kapazität von ` QByteArray` überschreitet oder wenn das Argument ` uint8array ` nicht vom Typ `Uint8Array` ist.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch ` toEcmaUint8Array()`.

[static] QByteArray QByteArray::fromHex(const QByteArray &hexEncoded)

Gibt eine dekodierte Kopie des hexadezimal kodierten Arrays „ hexEncoded “ zurück. Die Eingabe wird nicht auf Gültigkeit geprüft; ungültige Zeichen in der Eingabe werden übersprungen, sodass der Dekodierungsprozess mit den nachfolgenden Zeichen fortgesetzt werden kann.

Beispiel:

QByteArray text = QByteArray::fromHex("517420697320677265617421");
text.data();            // returns "Qt is great!"

Siehe auch ` toHex()`.

[static] QByteArray QByteArray::fromNSData(const NSData *data)

Erstellt ein neues ` QByteArray `, das eine Kopie des `NSData`-Objekts ` data` enthält.

Siehe auch fromRawNSData(), fromRawData(), toNSData() und toRawNSData().

[static] QByteArray QByteArray::fromPercentEncoding(const QByteArray &input, char percent = '%')

Dekodiert „ input “ aus der Prozent-Kodierung im URI-/URL-Format.

Gibt ein Byte-Array zurück, das den dekodierten Text enthält. Der Parameter „ percent “ ermöglicht die Verwendung eines anderen Zeichens als „%“ (z. B. „_“ oder „=“) als Escape-Zeichen. Entspricht der Eingabe:percentDecoded(Prozent).

Beispiel:

QByteArray text = QByteArray::fromPercentEncoding("Qt%20is%20great%33");
qDebug("%s", text.data());      // reports "Qt is great!"

Siehe auch percentDecoded().

[static, since 6.11] QByteArray QByteArray::fromPercentEncoding(QByteArray &&input, char percent = '%')

Diese Funktion wurde in Qt 6.11 eingeführt.

[static] QByteArray QByteArray::fromRawCFData(CFDataRef data)

Erstellt ein ` QByteArray `, das die Bytes des `CFData`- data s verwendet.

Die Bytes des ` data` werden nicht kopiert.

Der Aufrufer garantiert, dass das CFData-Objekt nicht gelöscht oder geändert wird, solange dieses QByteArray -Objekt existiert.

Siehe auch fromCFData(), fromRawData(), toRawCFData() und toCFData().

[static] QByteArray QByteArray::fromRawData(const char *data, qsizetype size)

Erstellt eine „ QByteArray “, die die ersten „ size “ Bytes des Arrays „ data “ verwendet. Die Bytes werden nicht kopiert. „ QByteArray “ enthält den Zeiger „ data “. Der Aufrufer garantiert, dass „ data “ nicht gelöscht oder verändert wird, solange diese „ QByteArray “ und alle unveränderten Kopien davon existieren. Mit anderen Worten: Da QByteArray eine implizit gemeinsam genutzte Klasse ist und die von dieser Funktion zurückgegebene Instanz den Zeiger data enthält, darf der Aufrufer data nicht löschen oder direkt ändern, solange das zurückgegebene QByteArray und etwaige Kopien davon existieren. Allerdings übernimmt QByteArray nicht die Eigentumsrechte an data, sodass der Destruktor von QByteArray niemals das ursprüngliche data löschen wird, selbst wenn das letzte QByteArray, das auf data verweist, zerstört wird.

Ein nachfolgender Versuch, den Inhalt des zurückgegebenen QByteArray oder einer davon erstellten Kopie zu ändern, führt dazu, dass vor der Änderung eine tiefe Kopie des data -Arrays erstellt wird. Dadurch wird sichergestellt, dass das Roh- data -Array selbst niemals durch QByteArray verändert wird.

Hier ist ein Beispiel dafür, wie man mit einem ` QDataStream ` Daten aus Rohdaten im Speicher ausliest, ohne die Rohdaten in ein ` QByteArray` zu kopieren:

static const char mydata[] = {
    '\x00', '\x00', '\x03', '\x84', '\x78', '\x9c', '\x3b', '\x76',
    '\xec', '\x18', '\xc3', '\x31', '\x0a', '\xf1', '\xcc', '\x99',
    //...
    '\x6d', '\x5b'
};

QByteArray data = QByteArray::fromRawData(mydata, sizeof(mydata));
QDataStream in(&data, QIODevice::ReadOnly);
//...

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

[static] QByteArray QByteArray::fromRawNSData(const NSData *data)

Erstellt ein ` QByteArray `, das die Bytes des `NSData`- data s verwendet.

Die Bytes des ` data` werden nicht kopiert.

Der Aufrufer garantiert, dass das NSData-Objekt nicht gelöscht oder verändert wird, solange dieses „ QByteArray “-Objekt existiert.

Siehe auch fromNSData(), fromRawData(), toRawNSData() und toNSData().

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

Gibt eine Kopie der Zeichenkette „ str “ als „ QByteArray “ zurück.

Siehe auch „ toStdString()“ und „ QString::fromStdString()“.

char &QByteArray::front()

Gibt einen Verweis auf das erste Byte im Byte-Array zurück. Entspricht „ operator[](0) “.

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

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

char QByteArray::front() const

Gibt das erste Byte des Byte-Arrays zurück. Entspricht „ at(0) “.

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

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

[since 6.0] qsizetype QByteArray::indexOf(QByteArrayView bv, qsizetype from = 0) const

Gibt die Indexposition des Anfangs des ersten Vorkommens der von ` bv ` in diesem Byte-Array untersuchten Byte-Sequenz zurück, wobei die Suche ausgehend von der Indexposition ` from` vorwärts erfolgt. Gibt -1 zurück, wenn keine Übereinstimmung gefunden wird.

Beispiel:

QByteArray x("sticky question");
QByteArrayView 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

Diese Funktion wurde in Qt 6.0 eingeführt.

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

qsizetype QByteArray::indexOf(char ch, qsizetype from = 0) const

Gibt die Indexposition des Beginns des ersten Vorkommens des Byte- ch s in diesem Byte-Array zurück, wobei die Suche ausgehend von der Indexposition from vorwärts erfolgt. Gibt -1 zurück, wenn keine Übereinstimmung gefunden wird.

Beispiel:

QByteArray ba("ABCBA");
ba.indexOf("B");            // returns 1
ba.indexOf("B", 1);         // returns 1
ba.indexOf("B", 2);         // returns 3
ba.indexOf("X");            // returns -1

Siehe auch ` lastIndexOf()` und ` contains()`.

[since 6.0] QByteArray &QByteArray::insert(qsizetype i, QByteArrayView data)

Fügt an der Indexposition „ i “ den Wert „ data “ ein und gibt eine Referenz auf dieses Byte-Array zurück.

Beispiel:

QByteArray ba("Meal");
ba.insert(1, QByteArrayView("ontr"));
// ba == "Montreal"

Bei großen Byte-Arrays kann dieser Vorgang langsam sein (lineare Laufzeit), da alle Bytes an den Indizes i und darüber im Speicher um mindestens eine Position weiter verschoben werden müssen.

Das Array wird vergrößert, um die Einfügung aufzunehmen. Liegt i jenseits des Endes des Arrays, wird das Array zunächst mit Leerzeichen aufgefüllt, um diese Position i zu erreichen.

Diese Funktion wurde in Qt 6.0 eingeführt.

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

QByteArray &QByteArray::insert(qsizetype i, const QByteArray &data)

Fügt „ data “ an der Indexposition „ i “ ein und gibt einen Verweis auf dieses Byte-Array zurück.

Dieses Array wird vergrößert, um die Einfügung aufzunehmen. Befindet sich „ i “ jenseits des Array-Endes, wird das Array zunächst mit Leerzeichen erweitert, um die Position „ i “ zu erreichen.

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

QByteArray &QByteArray::insert(qsizetype i, const char *s)

Fügt „ s “ an der Indexposition „ i “ ein und gibt eine Referenz auf dieses Byte-Array zurück.

Dieses Array wird vergrößert, um die Einfügung aufzunehmen. Liegt i jenseits des Array-Endes, wird das Array zunächst mit Leerzeichen aufgefüllt, um die Position i zu erreichen.

Die Funktion entspricht insert(i, QByteArrayView(s))

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

QByteArray &QByteArray::insert(qsizetype i, char ch)

Fügt die Byte- ch an der Indexposition i in das Byte-Array ein.

Dieses Array wird vergrößert, um die Einfügung aufzunehmen. Liegt i jenseits des Array-Endes, wird das Array zunächst mit Leerzeichen aufgefüllt, um diese Position i zu erreichen.

QByteArray &QByteArray::insert(qsizetype i, const char *data, qsizetype len)

Fügt len Bytes, beginnend bei data, an der Position i in das Byte-Array ein.

Dieses Array wird vergrößert, um die Einfügung aufzunehmen. Liegt i jenseits des Endes des Arrays, wird das Array zunächst mit Leerzeichen erweitert, um diese i zu erreichen.

QByteArray &QByteArray::insert(qsizetype i, qsizetype count, char ch)

Fügt count Kopien des Byte- ch s an der Indexposition i in das Byte-Array ein.

Dieses Array wird vergrößert, um Platz für die Einfügung zu schaffen. Liegt i jenseits des Array-Endes, wird das Array zunächst mit Leerzeichen aufgefüllt, um diese i zu erreichen.

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

Gibt „ true “ zurück, wenn das Byte-Array die Größe 0 hat; andernfalls wird „ false “ zurückgegeben.

Beispiel:

QByteArray().isEmpty();         // returns true
QByteArray("").isEmpty();       // returns true
QByteArray("abc").isEmpty();    // returns false

Siehe auch ` size()`.

bool QByteArray::isLower() const

Gibt „ true “ zurück, wenn dieses Byte-Array aus Kleinbuchstaben besteht, d. h., wenn es mit der Faltung von „ toLower()“ identisch ist.

Beachten Sie, dass dies nicht bedeutet, dass das Byte-Array ausschließlich Kleinbuchstaben enthält, sondern lediglich, dass es keine ASCII-Großbuchstaben enthält.

Siehe auch isUpper() und toLower().

[noexcept] bool QByteArray::isNull() const

Gibt „ true “ zurück, wenn dieses Byte-Array null ist; andernfalls wird „ false “ zurückgegeben.

Beispiel:

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

Qt unterscheidet aus historischen Gründen zwischen Null-Byte-Arrays und leeren Byte-Arrays. Für die meisten Anwendungen ist es entscheidend, ob ein Byte-Array Daten enthält oder nicht, und dies lässt sich mit ` isEmpty()` feststellen.

Siehe auch ` isEmpty()`.

bool QByteArray::isUpper() const

Gibt „ true “ zurück, wenn dieses Byte-Array aus Großbuchstaben besteht, d. h., wenn es mit der Faltung von toUpper() identisch ist.

Beachten Sie, dass dies nicht bedeutet, dass das Byte-Array ausschließlich Großbuchstaben enthält, sondern lediglich, dass es keine ASCII-Kleinbuchstaben enthält.

Siehe auch ` isLower()` und ` toUpper()`.

[noexcept, since 6.3] bool QByteArray::isValidUtf8() const

Gibt „ true “ zurück, wenn dieses Byte-Array gültige, UTF-8-kodierte Daten enthält, andernfalls „ false “.

Diese Funktion wurde in Qt 6.3 eingeführt.

Gibt die letzten n Bytes des Byte-Arrays zurück.

Beispiel:

QByteArray x("Pineapple");
QByteArray 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()“.

[since 6.0] qsizetype QByteArray::lastIndexOf(QByteArrayView bv, qsizetype from) const

Gibt die Indexposition des Anfangs des letzten Vorkommens der von ` bv ` in diesem Byte-Array betrachteten Byte-Sequenz zurück, wobei rückwärts von 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 keine Übereinstimmung gefunden wird.

Beispiel:

QByteArray x("crazy azimuths");
QByteArrayView 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.0 eingeführt.

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

[since 6.2] qsizetype QByteArray::lastIndexOf(QByteArrayView bv) const

Gibt die Indexposition des Anfangs des letzten Vorkommens der von „ bv “ in diesem Byte-Array untersuchten Byte-Sequenz zurück, wobei vom Ende des Byte-Arrays aus rückwärts gesucht wird. Gibt -1 zurück, wenn keine Übereinstimmung gefunden wird.

Beispiel:

QByteArray x("crazy azimuths");
QByteArrayView 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 QByteArray::lastIndexOf(char ch, qsizetype from = -1) const

Gibt die Indexposition des Anfangs des letzten Vorkommens der Byte- ch in diesem Byte-Array zurück, wobei die Suche rückwärts ab der Indexposition from erfolgt. Ist from gleich -1 (Standardwert), beginnt die Suche am letzten Byte (an der Indexposition size() - 1). Gibt -1 zurück, wenn keine Übereinstimmung gefunden wird.

Beispiel:

QByteArray ba("ABCBA");
ba.lastIndexOf("B");        // returns 3
ba.lastIndexOf("B", 3);     // returns 3
ba.lastIndexOf("B", 2);     // returns 1
ba.lastIndexOf("X");        // returns -1

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

Gibt ein Byte-Array zurück, das die ersten len Bytes dieses Byte-Arrays enthält.

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

Das gesamte Byte-Array wird zurückgegeben, wenn ` len ` größer als ` size()` ist.

Gibt ein leeres ` QByteArray ` zurück, wenn ` len ` kleiner als 0 ist.

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

QByteArray QByteArray::leftJustified(qsizetype width, char fill = ' ', bool truncate = false) const

Gibt ein Byte-Array der Größe „ width “ zurück, das dieses Byte-Array enthält, aufgefüllt mit dem Byte „ fill “.

Ist truncate falsch und ist der Wert von size() des Byte-Arrays größer als width, so ist das zurückgegebene Byte-Array eine Kopie dieses Byte-Arrays.

Ist ` truncate ` wahr und ist ` size()` des Byte-Arrays größer als ` width`, werden alle Bytes in einer Kopie des Byte-Arrays ab der Position ` width ` entfernt und die Kopie zurückgegeben.

Beispiel:

QByteArray x("apple");
QByteArray y = x.leftJustified(8, '.');   // y == "apple..."

Siehe auch ` rightJustified()`.

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

Entspricht „ size()“.

Sie gibt die maximale Anzahl an Elementen zurück, die das Byte-Array theoretisch aufnehmen kann. In der Praxis kann diese Zahl jedoch deutlich geringer ausfallen, da sie durch die dem System zur Verfügung stehende Speichermenge begrenzt ist.

Diese Funktionen wurden in Qt 6.8 eingeführt.

Gibt ein Byte-Array zurück, das len Bytes aus diesem Byte-Array enthält, beginnend an der Position pos.

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

Wenn ` len ` den Wert -1 (Standard) hat oder ` pos ` + ` len ` >= ` size` ist, gibt die Funktion ein Byte-Array zurück, das alle Bytes ab der Position ` pos ` bis zum Ende des Byte-Arrays enthält.

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

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

Wenn die Daten dieses Byte-Arrays nicht null-terminiert sind, erstellt diese Methode eine tiefe Kopie der Daten und versieht sie mit einem Null-Terminator.

Ein „ QByteArray “ ist standardmäßig null-terminiert; in einigen Fällen (z. B. bei Verwendung von ` fromRawData()`) enden die Daten jedoch nicht unbedingt mit einem „ \0 “-Zeichen, was beim Aufruf von Methoden, die eine null-terminierte Zeichenkette erwarten (z. B. C-API), zu Problemen führen kann.

Diese Funktion wurde in Qt 6.10 eingeführt.

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

Gibt eine Kopie dieses Byte-Arrays zurück, die stets mit einem Null-Zeichen abgeschlossen ist. Siehe nullTerminate().

Diese Funktionen wurden in Qt 6.10 eingeführt.

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

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

Gibt ein Byte-Array zurück, das die ganze Zahl „ n “ als Text darstellt.

Gibt ein Byte-Array zurück, das eine Zeichenkette enthält, die „ n “ darstellt, wobei die angegebene „ base “ (standardmäßig „ten“) verwendet wird. Die Basen 2 bis 36 werden unterstützt, wobei für Ziffern über 9 Buchstaben verwendet werden: A steht für zehn, B für elf und so weiter.

Beispiel:

int n = 63;
QByteArray::number(n);              // returns "63"
QByteArray::number(n, 16);          // returns "3f"
QByteArray::number(n, 16).toUpper();  // returns "3F"

Siehe auch setNum() und toInt().

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

Siehe auch toLong().

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

Siehe auch toLongLong().

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

Siehe auch toULongLong().

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

Siehe auch toUInt().

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

Siehe auch toULong().

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

Gibt ein Byte-Array zurück, das die Gleitkommazahl n als Text darstellt.

Gibt ein Byte-Array zurück, das eine Zeichenkette enthält, die n darstellt, mit den angegebenen Parametern ` format ` und ` precision`, deren Bedeutung der von ` QLocale::toString` (double, char, int) entspricht. Beispiel:

QByteArray ba = QByteArray::number(12.3456, 'E', 3);
// ba == 1.235E+01

Siehe auch toDouble() und QLocale::FloatingPointPrecisionOption.

[since 6.4] QByteArray QByteArray::percentDecoded(char percent = '%') const &

Dekodiert die Prozentkodierung im URI-/URL-Stil.

Gibt ein Byte-Array zurück, das den dekodierten Text enthält. Der Parameter „ percent “ ermöglicht die Verwendung eines anderen Zeichens als „%“ (z. B. „_“ oder „=“) als Escape-Zeichen.

Beispiel:

QByteArray encoded("Qt%20is%20great%33");
QByteArray decoded = encoded.percentDecoded(); // Set to "Qt is great!"

Diese Funktion wurde in Qt 6.4 eingeführt.

Siehe auch toPercentEncoding() und QUrl::fromPercentEncoding().

[since 6.11] QByteArray QByteArray::percentDecoded(char percent = '%') &&

Diese Funktion wurde in Qt 6.11 eingeführt.

QByteArray &QByteArray::prepend(QByteArrayView ba)

Fügt die Byte-Array-Ansicht „ ba “ an dieses Byte-Array an und gibt eine Referenz auf dieses Byte-Array zurück.

Dieser Vorgang ist in der Regel sehr schnell (konstante Laufzeit), da „ QByteArray “ zusätzlichen Speicherplatz am Anfang der Daten vorab reserviert, sodass das Array erweitert werden kann, ohne dass jedes Mal das gesamte Array neu zugewiesen werden muss.

Beispiel:

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

Dies entspricht der Funktion `insert(0, ba)`.

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

QByteArray &QByteArray::prepend(char ch)

Fügt dem Byte-Array das Byte- ch, voran.

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

Fügt „ ba “ an den Anfang dieses Byte-Arrays an.

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

Fügt die mit „\0 “ abgeschlossene Zeichenkette „ str “ an den Anfang dieses Byte-Arrays ein.

QByteArray &QByteArray::prepend(const char *str, qsizetype len)

Fügt diesem Byte-Array len Bytes an, beginnend bei str. Die angefügten Bytes können „\0 “-Bytes enthalten.

QByteArray &QByteArray::prepend(qsizetype count, char ch)

Fügt diesem Byte-Array count Kopien des Byte- ch s vor.

void QByteArray::push_back(const QByteArray &other)

Diese Funktion dient der STL-Kompatibilität. Sie entspricht der Funktion `append(other)`.

[since 6.0] void QByteArray::push_back(QByteArrayView str)

Entspricht append(str).

Diese Funktion wurde in Qt 6.0 eingeführt.

void QByteArray::push_back(char ch)

Entspricht append(ch).

void QByteArray::push_back(const char *str)

Entspricht append(str).

void QByteArray::push_front(const QByteArray &other)

Diese Funktion dient der STL-Kompatibilität. Sie entspricht der Funktion „prepend(other)“.

[since 6.0] void QByteArray::push_front(QByteArrayView str)

Entspricht prepend(str).

Diese Funktion wurde in Qt 6.0 eingeführt.

void QByteArray::push_front(char ch)

Entspricht „prepend(ch)“.

void QByteArray::push_front(const char *str)

Entspricht „prepend(str)“.

QByteArray::reverse_iterator QByteArray::rbegin()

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

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

[noexcept] QByteArray::const_reverse_iterator QByteArray::rbegin() const

QByteArray &QByteArray::remove(qsizetype pos, qsizetype len)

Entfernt len Bytes aus dem Array, beginnend bei der Indexposition pos, und gibt eine Referenz auf das Array zurück.

Liegt „ pos “ außerhalb des zulässigen Bereichs, geschieht nichts. Ist „ pos “ gültig, aber ist „ pos “ + „ len “ größer als die Größe des Arrays, wird das Array an der Position „ pos “ abgeschnitten.

Beispiel:

QByteArray ba("Montreal");
ba.remove(1, 4);
// ba == "Meal"

Beim Entfernen von Elementen bleibt die Kapazität des Arrays 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 Array-Größe auf.

Siehe auch insert(), replace() und squeeze().

[since 6.5] QByteArray &QByteArray::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] QByteArray &QByteArray::removeFirst()

Entfernt das erste Zeichen aus diesem Byte-Array. Ist das Byte-Array 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> QByteArray &QByteArray::removeIf(Predicate pred)

Entfernt alle Bytes aus dem Byte-Array, für die das Prädikat „ pred “ den Wert „true“ zurückgibt. Gibt eine Referenz auf das Byte-Array zurück.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch ` remove()`.

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

Entfernt das letzte Zeichen aus diesem Byte-Array. Ist das Byte-Array leer, führt diese Funktion keine Aktion aus.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch ` remove()`.

QByteArray::reverse_iterator QByteArray::rend()

Gibt einen Reverse-Iterator im STL-Stil zurück, der in umgekehrter Reihenfolge direkt auf das letzte Byte im Byte-Array zeigt.

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

[noexcept] QByteArray::const_reverse_iterator QByteArray::rend() const

QByteArray QByteArray::repeated(qsizetype times) const

Gibt eine Kopie dieses Byte-Arrays zurück, die um die angegebene Anzahl von times wiederholt wird.

Ist times kleiner als 1, wird ein leeres Byte-Array zurückgegeben.

Beispiel:

QByteArray ba("ab");
ba.repeated(4);             // returns "abababab"

QByteArray &QByteArray::replace(qsizetype pos, qsizetype len, QByteArrayView after)

Ersetzt die ` len ` Bytes ab der Indexposition ` pos ` durch das Byte-Array ` after` und gibt eine Referenz auf dieses Byte-Array zurück.

Beispiel:

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

Siehe auch insert() und remove().

[since 6.0] QByteArray &QByteArray::replace(QByteArrayView before, QByteArrayView after)

Ersetzt jedes Vorkommen des Byte-Arrays „ before “ durch das Byte-Array „ after “.

Beispiel:

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

Diese Funktion wurde in Qt 6.0 eingeführt.

QByteArray &QByteArray::replace(char before, QByteArrayView after)

Ersetzt jedes Vorkommen des Byte- before s durch das Byte-Array after.

QByteArray &QByteArray::replace(char before, char after)

Ersetzt jedes Vorkommen des Bytes „ before “ durch das Byte „ after “.

QByteArray &QByteArray::replace(const char *before, qsizetype bsize, const char *after, qsizetype asize)

Ersetzt jedes Vorkommen der Bytes „ bsize “, beginnend bei „ before “, durch die Bytes „ asize “, beginnend bei „ after “. Da die Längen der Zeichenketten durch „ bsize “ und „ asize “ vorgegeben sind, dürfen sie die Bytes „'\0'“ enthalten und müssen nicht mit „'\0'“ abgeschlossen sein.

QByteArray &QByteArray::replace(qsizetype pos, qsizetype len, const char *after, qsizetype alen)

Ersetzt die Bytes „ len “ ab der Indexposition „ pos “ durch die Bytes „ alen “, beginnend an der Position „ after “. Die eingefügten Bytes können „'\0 “-Bytes enthalten.

void QByteArray::reserve(qsizetype size)

Versucht, Speicherplatz für mindestens size Bytes zuzuweisen.

Wenn Sie im Voraus wissen, wie groß das Byte-Array sein wird, können Sie diese Funktion aufrufen; wenn Sie resize() häufig aufrufen, erzielen Sie wahrscheinlich eine bessere Leistung.

Wenn Sie sich nicht sicher sind, wie viel Speicherplatz benötigt wird, ist es in der Regel besser, eine Obergrenze von ` size` zu verwenden oder eine hohe Schätzung der wahrscheinlichsten Größe, falls eine strenge Obergrenze deutlich darüber liegen würde. Ist ` size ` zu niedrig angesetzt, wird das Array bei Bedarf vergrößert, sobald die reservierte Größe überschritten wird. Dies kann zu einer größeren Speicherzuweisung führen, als es Ihre beste Überschätzung vorsähe, und den Vorgang, der dies auslöst, verlangsamen.

Der einzige Zweck dieser Funktion besteht darin, eine Möglichkeit zur Feinabstimmung der Speichernutzung von ` QByteArray` zu bieten. Im Allgemeinen wirst du diese Funktion so gut wie nie aufrufen müssen.

Siehe auch „ squeeze()“ und „ capacity()“.

void QByteArray::resize(qsizetype size)

Legt die Größe des Byte-Arrays auf size Bytes fest.

Ist „ size “ größer als die aktuelle Größe, wird das Byte-Array auf „ size “ Bytes erweitert, wobei die zusätzlichen Bytes am Ende angehängt werden. Die neuen Bytes sind nicht initialisiert.

Ist ` size ` kleiner als die aktuelle Größe, werden Bytes jenseits der Position ` size ` aus dem Byte-Array entfernt.

Siehe auch ` size()`, ` truncate()` und ` squeeze()`.

[since 6.4] void QByteArray::resize(qsizetype newSize, char c)

Legt die Größe des Byte-Arrays auf newSize Bytes fest.

Ist „ newSize “ größer als die aktuelle Größe, wird das Byte-Array auf „ newSize “ Bytes erweitert, wobei die zusätzlichen Bytes am Ende angehängt werden. Die neuen Bytes werden auf „ c “ initialisiert.

Ist ` newSize ` kleiner als die aktuelle Größe, werden Bytes jenseits der Position ` newSize ` aus dem Byte-Array entfernt.

Diese Funktion wurde in Qt 6.4 eingeführt.

Siehe auch „ size()“, „ truncate()“ und „ squeeze()“.

[since 6.8] void QByteArray::resizeForOverwrite(qsizetype size)

Passen Sie die Größe des Byte-Arrays auf size Bytes an. Wenn die Größe des Byte-Arrays zunimmt, sind die neuen Bytes nicht initialisiert.

Das Verhalten entspricht dem von ` resize(size)`.

Diese Funktion wurde in Qt 6.8 eingeführt.

Siehe auch ` resize()`.

Gibt ein Byte-Array zurück, das die letzten len Bytes dieses Byte-Arrays enthält.

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

Das gesamte Byte-Array wird zurückgegeben, wenn ` len ` größer als ` size()` ist.

Gibt ein leeres ` QByteArray ` zurück, wenn ` len ` kleiner als 0 ist.

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

QByteArray QByteArray::rightJustified(qsizetype width, char fill = ' ', bool truncate = false) const

Gibt ein Byte-Array der Größe width zurück, das das Byte „ fill “ gefolgt von diesem Byte-Array enthält.

Ist truncate falsch und ist die Größe des Byte-Arrays größer als width, so ist das zurückgegebene Byte-Array eine Kopie dieses Byte-Arrays.

Ist ` truncate ` wahr und ist die Größe des Byte-Arrays größer als ` width`, wird das resultierende Byte-Array an der Position ` width` abgeschnitten.

Beispiel:

QByteArray x("apple");
QByteArray y = x.rightJustified(8, '.');    // y == "...apple"

Siehe auch ` leftJustified()`.

QByteArray &QByteArray::setNum(int n, int base = 10)

Gibt die Ganzzahl n als Text wieder.

Setzt dieses Byte-Array auf eine Zeichenkette, die n in der Basis base (standardmäßig 10) darstellt, und gibt eine Referenz auf dieses Byte-Array zurück. Die Basen 2 bis 36 werden unterstützt, wobei für Ziffern über 9 Buchstaben verwendet werden; A steht für 10, B für 11 und so weiter.

Beispiel:

QByteArray ba;
int n = 63;
ba.setNum(n);           // ba == "63"
ba.setNum(n, 16);       // ba == "3f"

Siehe auch ` number()` und ` toInt()`.

QByteArray &QByteArray::setNum(long n, int base = 10)

Siehe auch ` toLong()`.

QByteArray &QByteArray::setNum(qlonglong n, int base = 10)

Siehe auch toLongLong().

QByteArray &QByteArray::setNum(qulonglong n, int base = 10)

Siehe auch toULongLong().

QByteArray &QByteArray::setNum(short n, int base = 10)

Siehe auch toShort().

QByteArray &QByteArray::setNum(uint n, int base = 10)

Siehe auch toUInt().

QByteArray &QByteArray::setNum(ulong n, int base = 10)

Siehe auch ` toULong()`.

QByteArray &QByteArray::setNum(ushort n, int base = 10)

Siehe auch toUShort().

QByteArray &QByteArray::setNum(double n, char format = 'g', int precision = 6)

Stellt die Gleitkommazahl n als Text dar.

Setzt dieses Byte-Array auf eine Zeichenkette, die n darstellt, wobei format und precision vorgegeben sind (mit derselben Bedeutung wie bei QLocale::toString(double, char, int)), und gibt eine Referenz auf dieses Byte-Array zurück.

Siehe auch toDouble() und QLocale::FloatingPointPrecisionOption.

QByteArray &QByteArray::setNum(float n, char format = 'g', int precision = 6)

Stellt die Gleitkommazahl n als Text dar.

Setzt dieses Byte-Array auf eine Zeichenkette, die n darstellt, wobei format und precision vorgegeben sind (mit derselben Bedeutung wie bei QLocale::toString(double, char, int)), und gibt eine Referenz auf dieses Byte-Array zurück.

Siehe auch toFloat() und QLocale::FloatingPointPrecisionOption.

QByteArray &QByteArray::setRawData(const char *data, qsizetype size)

Setzt das ` QByteArray ` so zurück, dass es die ersten ` size ` Bytes des Arrays ` data ` verwendet. Die Bytes werden nicht kopiert. Die Variable ` QByteArray ` enthält den Zeiger ` data `. Der Aufrufer garantiert, dass ` data ` nicht gelöscht oder verändert wird, solange dieses ` QByteArray ` und alle unveränderten Kopien davon existieren.

Diese Funktion kann anstelle von ` fromRawData()` verwendet werden, um vorhandene ` QByteArray `-Objekte wiederzuverwenden und so Speicherneuzuweisungen zu vermeiden.

Siehe auch fromRawData(), data(), constData(), nullTerminate() und nullTerminated().

void QByteArray::shrink_to_fit()

Diese Funktion dient der STL-Kompatibilität. Sie entspricht der Funktion „ squeeze()“.

QByteArray QByteArray::simplified() const

Gibt eine Kopie dieses Byte-Arrays zurück, bei der die Leerzeichen am Anfang und am Ende entfernt wurden und in der jede Folge interner Leerzeichen durch ein einzelnes Leerzeichen ersetzt wurde.

Bei den Leerzeichen handelt es sich um diejenigen, für die die Standard-C++-Funktion ` isspace() ` in der C-Locale den Wert ` true ` zurückgibt; dies sind die ASCII-Zeichen Tabulator „\t “, Zeilenvorschub „\n “, Wagenrücklauf „\r “, vertikaler Tabulator „\v “, Seitenvorschub „\f “ und Leerzeichen „ “.

Beispiel:

QByteArray ba("  lots\t of\nwhitespace\r\n ");
ba = ba.simplified();
// ba == "lots of whitespace";

Siehe auch trimmed(), QChar::SpecialCharacter und Spacing Characters.

[constexpr noexcept] qsizetype QByteArray::size() const

Gibt die Anzahl der Bytes in diesem Byte-Array zurück.

Das letzte Byte im Byte-Array befindet sich an der Position size() - 1. Darüber hinaus stellt „ QByteArray “ sicher, dass das Byte an der Position size() immer „'\0'“ ist, sodass Sie den Rückgabewert von „ data()“ und „ constData()“ als Argumente für Funktionen verwenden können, die mit „'\0'“ abgeschlossene Zeichenketten erwarten. Wenn das Objekt ` QByteArray ` aus einem ` raw data ` erstellt wurde, das das abschließende Byte „\0 “ nicht enthielt, fügt ` QByteArray ` dieses nicht automatisch hinzu, es sei denn, es wird eine tiefe Kopie erstellt.

Beispiel:

QByteArray ba("Hello");
qsizetype n = ba.size();    // n == 5
ba.data()[0];               // returns 'H'
ba.data()[4];               // returns 'o'
ba.data()[5];               // returns '\0'

Siehe auch isEmpty() und resize().

[since 6.8] QByteArray &QByteArray::slice(qsizetype pos, qsizetype n)

Ändert dieses Byte-Array so, dass es an der Position pos beginnt und sich über n Bytes erstreckt, und gibt eine Referenz auf dieses Byte-Array zurück.

Beispiel:

QByteArray x = "Five pineapples"_ba;
x.slice(5);     // x == "pineapples"
x.slice(4, 3);  // x == "app"

Diese Funktion wurde in Qt 6.8 eingeführt.

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

[since 6.8] QByteArray &QByteArray::slice(qsizetype pos)

Ändert dieses Byte-Array so, dass es an der Position pos beginnt und sich bis zu seinem Ende erstreckt, und gibt eine Referenz auf dieses Byte-Array zurück.

Diese Funktion wurde in Qt 6.8 eingeführt.

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

Gibt ein Byte-Array zurück, das die ` n ` Bytes dieses Objekts enthält, beginnend an der Position ` pos`.

Beispiel:

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

Diese Funktionen wurden in Qt 6.0 eingeführt.

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

Gibt ein Byte-Array zurück, das die Bytes enthält, die bei der Position pos in diesem Objekt beginnen und sich bis zum Ende dieses Objekts erstrecken.

Diese Funktionen wurden in Qt 6.0 eingeführt.

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

QList<QByteArray> QByteArray::split(char sep) const

Teilt das Byte-Array an allen Stellen, an denen sep vorkommt, in Teilarrays auf und gibt die Liste dieser Arrays zurück. Wenn sep an keiner Stelle im Byte-Array vorkommt, gibt split() eine Liste mit einem einzigen Element zurück, die dieses Byte-Array enthält.

void QByteArray::squeeze()

Gibt den Speicher frei, der nicht zur Speicherung der Daten des Arrays benötigt wird.

Der einzige Zweck dieser Funktion besteht darin, eine Möglichkeit zur Feinabstimmung der Speichernutzung von QByteArray bereitzustellen. Im Allgemeinen werden Sie diese Funktion so gut wie nie aufrufen müssen.

Siehe auch „ reserve()“ und „ capacity()“.

[since 6.0] bool QByteArray::startsWith(QByteArrayView bv) const

Gibt „ true “ zurück, wenn dieses Byte-Array mit der von „ bv “ ermittelten Byte-Sequenz beginnt; andernfalls wird „ false “ zurückgegeben.

Beispiel:

QByteArray url("ftp://ftp.qt-project.org/");
if (url.startsWith("ftp:"))
    {/*...*/}

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch endsWith() und first().

bool QByteArray::startsWith(char ch) const

Gibt „ true “ zurück, wenn dieses Byte-Array mit dem Byte- ch beginnt; andernfalls wird „ false “ zurückgegeben.

[noexcept] void QByteArray::swap(QByteArray &other)

Tauscht dieses Byte-Array mit „ other “ aus. Dieser Vorgang ist sehr schnell und schlägt niemals fehl.

QByteArray QByteArray::toBase64(QByteArray::Base64Options options = Base64Encoding) const

Gibt eine Kopie des Byte-Arrays zurück, das unter Verwendung der Optionen „ options “ kodiert wurde.

QByteArray text("Qt is great!");
text.toBase64();        // returns "UXQgaXMgZ3JlYXQh"

QByteArray hello("<p>Hello?</p>");
hello.toBase64(QByteArray::Base64Encoding | QByteArray::OmitTrailingEquals);      // returns "PHA+SGVsbG8/PC9wPg"
hello.toBase64(QByteArray::Base64Encoding);                                       // returns "PHA+SGVsbG8/PC9wPg=="
hello.toBase64(QByteArray::Base64UrlEncoding);                                    // returns "PHA-SGVsbG8_PC9wPg=="
hello.toBase64(QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);   // returns "PHA-SGVsbG8_PC9wPg"

Der zur Kodierung von Base64-kodierten Daten verwendete Algorithmus ist in RFC 4648 definiert.

Siehe auch ` fromBase64()`.

CFDataRef QByteArray::toCFData() const

Erstellt ein CFData-Objekt aus einem „ QByteArray “.

Der Aufrufer ist Eigentümer des CFData-Objekts und für dessen Freigabe verantwortlich.

Siehe auch „ toRawCFData()“, „ fromCFData()“, „ fromRawCFData()“ und „ fromRawData()“.

double QByteArray::toDouble(bool *ok = nullptr) const

Gibt das in einen „ double “-Wert konvertierte Byte-Array zurück.

Gibt „unendlich“ zurück, wenn es bei der Konvertierung zu einem Überlauf kommt, oder 0,0, wenn die Konvertierung aus anderen Gründen fehlschlägt (z. B. Unterlauf).

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

QByteArray string("1234.56");
bool ok;
double a = string.toDouble(&ok);   // a == 1234.56, ok == true

string = "1234.56 Volt";
a = string.toDouble(&ok);             // a == 0, ok == false

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch ` number()`.

[since 6.5] emscripten::val QByteArray::toEcmaUint8Array()

Erstellt ein `Uint8Array` aus einem ` QByteArray`.

Diese Funktion überträgt Daten aus dem Heap-Speicher eines ` QByteArray ` in einen JavaScript-Datenpuffer. Die Funktion reserviert Speicherplatz in einem `ArrayBuffer`, kopiert die Daten dorthin und gibt eine `Uint8Array`-Ansicht auf diesen Puffer zurück.

Die JavaScript-Objekte besitzen eine Kopie der Daten, und dieser ` QByteArray ` kann nach der Erstellung der Kopie sicher gelöscht werden.

QByteArray byteArray = "test";
emscripten::val uint8array = byteArray.toEcmaUint8Array();

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch ` fromEcmaUint8Array()`.

float QByteArray::toFloat(bool *ok = nullptr) const

Gibt das in einen Wert vom Typ „ float “ konvertierte Byte-Array zurück.

Gibt „unendlich“ zurück, wenn bei der Konvertierung ein Überlauf auftritt, oder 0,0, wenn die Konvertierung aus anderen Gründen (z. B. Unterlauf) fehlschlägt.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

QByteArray string("1234.56");
bool ok;
float a = string.toFloat(&ok);    // a == 1234.56, ok == true

string = "1234.56 Volt";
a = string.toFloat(&ok);              // a == 0, ok == false

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch ` number()`.

QByteArray QByteArray::toHex(char separator = '\0') const

Gibt eine hexadezimal kodierte Kopie des Byte-Arrays zurück.

Die Hex-Kodierung verwendet die Ziffern 0–9 und die Buchstaben a–f.

Wenn „ separator “ nicht „\0 “ ist, wird das Trennzeichen zwischen den Hex-Bytes eingefügt.

Beispiel:

QByteArray macAddress = QByteArray::fromHex("123456abcdef");
macAddress.toHex(':'); // returns "12:34:56:ab:cd:ef"
macAddress.toHex(0);   // returns "123456abcdef"

Siehe auch fromHex().

int QByteArray::toInt(bool *ok = nullptr, int base = 10) const

Gibt das Byte-Array zurück, das unter Verwendung der Basis base in ein „ int “ konvertiert wurde; standardmäßig ist dies die Basis 10. Die Basen 0 sowie 2 bis 36 werden unterstützt, wobei für Ziffern über 9 Buchstaben verwendet werden; A steht für 10, B für 11 und so weiter.

Ist ` base ` gleich 0, wird die Basis automatisch anhand der folgenden Regeln ermittelt: Beginnt das Byte-Array mit „0x“, wird davon ausgegangen, dass es hexadezimal ist (Basis 16); ansonsten wird bei Beginn mit „0b“ angenommen, dass es sich um Binärzahlen (Basis 2) handelt; ansonsten wird bei Beginn mit „0“ angenommen, dass es sich um Oktalzahlen (Basis 8) handelt; andernfalls wird angenommen, dass es sich um Dezimalzahlen handelt.

Gibt 0 zurück, wenn die Konvertierung fehlschlägt.

Ist „ ok “ nicht auf „ nullptr “ gesetzt, wird ein Fehler durch Setzen von *ok auf „ false “ gemeldet, und ein Erfolg durch Setzen von *ok auf „ true “.

QByteArray str("FF");
bool ok;
int hex = str.toInt(&ok, 16);     // hex == 255, ok == true
int dec = str.toInt(&ok, 10);     // dec == 0, ok == false

Siehe auch number().

long QByteArray::toLong(bool *ok = nullptr, int base = 10) const

Gibt das Byte-Array zurück, das unter Verwendung der Basis base in einen „ long “-Ganzzahlwert konvertiert wurde; die Standardbasis ist 10. Die Basen 0 sowie 2 bis 36 werden unterstützt, wobei für Ziffern über 9 Buchstaben verwendet werden: A steht für 10, B für 11 und so weiter.

Ist ` base ` gleich 0, wird die Basis automatisch anhand der folgenden Regeln ermittelt: Beginnt das Byte-Array mit „0x“, wird davon ausgegangen, dass es hexadezimal (Basis 16) ist; ansonsten wird bei Beginn mit „0b“ davon ausgegangen, dass es sich um Binärzahlen (Basis 2) handelt; ansonsten wird bei Beginn mit „0“ davon ausgegangen, dass es sich um Oktalzahlen (Basis 8) handelt; andernfalls wird von Dezimalzahlen ausgegangen.

Gibt 0 zurück, wenn die Konvertierung fehlschlägt.

Ist ` ok ` nicht ` nullptr`, wird ein Fehler gemeldet, indem *`ok ` auf ` false` gesetzt wird, und ein Erfolg, indem *`ok ` auf ` true` gesetzt wird.

QByteArray str("FF");
bool ok;
long hex = str.toLong(&ok, 16);   // hex == 255, ok == true
long dec = str.toLong(&ok, 10);   // dec == 0, ok == false

Siehe auch number().

qlonglong QByteArray::toLongLong(bool *ok = nullptr, int base = 10) const

Gibt das Byte-Array zurück, das unter Verwendung der Basis base in ein „ long long “ konvertiert wurde; die Standardbasis ist 10. Die Basen 0 sowie 2 bis 36 werden unterstützt, wobei für Ziffern über 9 Buchstaben verwendet werden; A steht für 10, B für 11 und so weiter.

Ist ` base ` gleich 0, wird die Basis automatisch anhand der folgenden Regeln ermittelt: Beginnt das Byte-Array mit „0x“, wird davon ausgegangen, dass es hexadezimal ist (Basis 16); ansonsten wird bei Beginn mit „0b“ davon ausgegangen, dass es sich um Binärzahlen (Basis 2) handelt; ansonsten wird bei Beginn mit „0“ davon ausgegangen, dass es sich um Oktalzahlen (Basis 8) handelt; andernfalls wird davon ausgegangen, dass es sich um Dezimalzahlen handelt.

Gibt 0 zurück, wenn die Konvertierung fehlschlägt.

Ist ` ok ` nicht ` nullptr`, wird ein Fehler gemeldet, indem *`ok ` auf ` false` gesetzt wird, und ein Erfolg, indem *`ok ` auf ` true` gesetzt wird.

Siehe auch number().

QByteArray QByteArray::toLower() const

Gibt eine Kopie des Byte-Arrays zurück, in der jeder ASCII-Großbuchstabe in einen Kleinbuchstaben umgewandelt wurde.

Beispiel:

QByteArray x("Qt by THE QT COMPANY");
QByteArray y = x.toLower();
// y == "qt by the qt company"

Siehe auch isLower(), toUpper() und Character Case.

NSData *QByteArray::toNSData() const

Erstellt ein NSData-Objekt aus einem „ QByteArray “.

Das NSData-Objekt wird automatisch freigegeben.

Siehe auch „ fromNSData()“, „ fromRawNSData()“, „ fromRawData()“ und „ toRawNSData()“.

QByteArray QByteArray::toPercentEncoding(const QByteArray &exclude = QByteArray(), const QByteArray &include = QByteArray(), char percent = '%') const

Gibt eine prozentkodierte Kopie dieses Byte-Arrays im URI-/URL-Format zurück. Mit dem Parameter „ percent “ können Sie das Standardzeichen „%“ durch ein anderes überschreiben.

Standardmäßig kodiert diese Funktion alle Bytes, die nicht zu den folgenden gehören:

ALPHA („a“ bis „z“ und „A“ bis „Z“) / ZIFFERN (0 bis 9) / „-“ / „.“ / „_“ / „~“

Um zu verhindern, dass Bytes kodiert werden, übergeben Sie sie an „ exclude “. Um die Kodierung von Bytes zu erzwingen, übergeben Sie sie an „ include “. Das Zeichen „ percent “ wird immer kodiert.

Beispiel:

QByteArray text = "{eine verdächtige Zeichenfolge?}";
QByteArray ba = text.toPercentEncoding("{}", "s");
qDebug("%s", ba.constData());
// gibt „{a fi%73hy %73tring%3F}“ aus

Die Hex-Kodierung verwendet die Ziffern 0–9 und die Großbuchstaben A–F.

Siehe auch fromPercentEncoding() und QUrl::toPercentEncoding().

CFDataRef QByteArray::toRawCFData() const

Erstellt ein CFData-Objekt, das die Bytes von „ QByteArray “ verwendet.

Die Bytes des ` QByteArray` werden nicht kopiert.

Der Aufrufer garantiert, dass das ` QByteArray ` nicht gelöscht oder geändert wird, solange dieses `CFData`-Objekt existiert.

Siehe auch „ toCFData()“, „ fromRawCFData()“, „ fromCFData()“ und „ fromRawData()“.

NSData *QByteArray::toRawNSData() const

Erstellt ein NSData-Objekt, das die Bytes von „ QByteArray “ verwendet.

Die Bytes des ` QByteArray` werden nicht kopiert.

Der Aufrufer garantiert, dass das ` QByteArray ` nicht gelöscht oder verändert wird, solange dieses `NSData`-Objekt existiert.

Siehe auch fromRawNSData(), fromNSData(), fromRawData() und toNSData().

short QByteArray::toShort(bool *ok = nullptr, int base = 10) const

Gibt das Byte-Array zurück, das unter Verwendung der Basis base in ein short konvertiert wurde; die Standardbasis ist 10. Die Basen 0 sowie 2 bis 36 werden unterstützt, wobei für Ziffern über 9 Buchstaben verwendet werden; A steht für 10, B für 11 und so weiter.

Ist ` base ` gleich 0, wird die Basis automatisch anhand der folgenden Regeln ermittelt: Beginnt das Byte-Array mit „0x“, wird davon ausgegangen, dass es hexadezimal ist (Basis 16); ansonsten wird bei Beginn mit „0b“ davon ausgegangen, dass es sich um Binärzahlen (Basis 2) handelt; andernfalls wird bei Beginn mit „0“ davon ausgegangen, dass es sich um Oktalzahlen (Basis 8) handelt; andernfalls wird davon ausgegangen, dass es sich um Dezimalzahlen handelt.

Gibt 0 zurück, wenn die Konvertierung fehlschlägt.

Ist ` ok ` nicht ` nullptr`, wird ein Fehler gemeldet, indem *`ok ` auf ` false` gesetzt wird, und ein Erfolg, indem *`ok ` auf ` true` gesetzt wird.

Siehe auch number().

std::string QByteArray::toStdString() const

Gibt ein std::string-Objekt zurück, das die in diesem „ QByteArray “ enthaltenen Daten enthält.

Dieser Operator ist vor allem nützlich, um ein ` QByteArray ` an eine Funktion zu übergeben, die ein `std::string`-Objekt akzeptiert.

Siehe auch ` fromStdString()` und ` QString::toStdString()`.

uint QByteArray::toUInt(bool *ok = nullptr, int base = 10) const

Gibt das Byte-Array zurück, das unter Verwendung der Basis base in ein „ unsigned int “ konvertiert wurde; standardmäßig ist dies die Basis 10. Die Basen 0 sowie 2 bis 36 werden unterstützt, wobei für Ziffern über 9 Buchstaben verwendet werden: A steht für 10, B für 11 und so weiter.

Ist ` base ` gleich 0, wird die Basis automatisch anhand der folgenden Regeln ermittelt: Beginnt das Byte-Array mit „0x“, wird davon ausgegangen, dass es hexadezimal (Basis 16) ist; ansonsten wird bei Beginn mit „0b“ davon ausgegangen, dass es sich um Binärzahlen (Basis 2) handelt; andernfalls wird bei Beginn mit „0“ davon ausgegangen, dass es sich um Oktalzahlen (Basis 8) handelt; andernfalls wird davon ausgegangen, dass es sich um Dezimalzahlen handelt.

Gibt 0 zurück, wenn die Konvertierung fehlschlägt.

Ist ` ok ` nicht ` nullptr`, wird ein Fehler gemeldet, indem *`ok ` auf ` false` gesetzt wird, und ein Erfolg, indem *`ok ` auf ` true` gesetzt wird.

Siehe auch number().

ulong QByteArray::toULong(bool *ok = nullptr, int base = 10) const

Gibt das Byte-Array zurück, das unter Verwendung der Basis base in ein „ unsigned long int “ konvertiert wurde, wobei die Standardbasis 10 ist. Die Basen 0 sowie 2 bis 36 werden unterstützt, wobei für Ziffern über 9 Buchstaben verwendet werden; A steht für 10, B für 11 und so weiter.

Ist ` base ` gleich 0, wird die Basis automatisch anhand der folgenden Regeln ermittelt: Beginnt das Byte-Array mit „0x“, wird davon ausgegangen, dass es hexadezimal (Basis 16) ist; ansonsten wird bei Beginn mit „0b“ davon ausgegangen, dass es sich um binäre Zahlen (Basis 2) handelt; ansonsten wird bei Beginn mit „0“ davon ausgegangen, dass es sich um oktale Zahlen (Basis 8) handelt; andernfalls wird davon ausgegangen, dass es sich um dezimale Zahlen handelt.

Gibt 0 zurück, wenn die Konvertierung fehlschlägt.

Ist ` ok ` nicht ` nullptr`, wird ein Fehler gemeldet, indem *`ok ` auf ` false` gesetzt wird, und ein Erfolg, indem *`ok ` auf ` true` gesetzt wird.

Siehe auch number().

qulonglong QByteArray::toULongLong(bool *ok = nullptr, int base = 10) const

Gibt das Byte-Array zurück, das unter Verwendung der Basis base in ein unsigned long long konvertiert wurde; standardmäßig ist dies 10. Die Basen 0 sowie 2 bis 36 werden unterstützt, wobei für Ziffern über 9 Buchstaben verwendet werden; A steht für 10, B für 11 und so weiter.

Ist ` base ` gleich 0, wird die Basis automatisch anhand der folgenden Regeln ermittelt: Beginnt das Byte-Array mit „0x“, wird es als hexadezimal (Basis 16) angesehen; ansonsten wird bei Beginn mit „0b“ davon ausgegangen, dass es sich um Binärzahlen (Basis 2) handelt; ansonsten wird bei Beginn mit „0“ davon ausgegangen, dass es sich um Oktalzahlen (Basis 8) handelt; andernfalls wird davon ausgegangen, dass es sich um Dezimalzahlen handelt.

Gibt 0 zurück, wenn die Konvertierung fehlschlägt.

Ist ` ok ` nicht ` nullptr`, wird ein Fehler gemeldet, indem *`ok ` auf ` false` gesetzt wird, und ein Erfolg, indem *`ok ` auf ` true` gesetzt wird.

Siehe auch number().

ushort QByteArray::toUShort(bool *ok = nullptr, int base = 10) const

Gibt das Byte-Array zurück, das unter Verwendung der Basis base in ein „ unsigned short “ konvertiert wurde; die Standardbasis ist 10. Die Basen 0 sowie 2 bis 36 werden unterstützt, wobei für Ziffern über 9 Buchstaben verwendet werden; A steht für 10, B für 11 und so weiter.

Ist ` base ` gleich 0, wird die Basis automatisch anhand der folgenden Regeln ermittelt: Beginnt das Byte-Array mit „0x“, wird davon ausgegangen, dass es hexadezimal (Basis 16) ist; ansonsten wird bei Beginn mit „0b“ davon ausgegangen, dass es sich um Binärzahlen (Basis 2) handelt; andernfalls wird bei Beginn mit „0“ davon ausgegangen, dass es sich um Oktalzahlen (Basis 8) handelt; andernfalls wird davon ausgegangen, dass es sich um Dezimalzahlen handelt.

Gibt 0 zurück, wenn die Konvertierung fehlschlägt.

Ist ` ok ` nicht ` nullptr`, wird ein Fehler gemeldet, indem *`ok ` auf ` false` gesetzt wird, und ein Erfolg, indem *`ok ` auf ` true` gesetzt wird.

Siehe auch number().

QByteArray QByteArray::toUpper() const

Gibt eine Kopie des Byte-Arrays zurück, in der jeder kleine ASCII-Buchstabe in einen Großbuchstaben umgewandelt wurde.

Beispiel:

QByteArray x("Qt by THE QT COMPANY");
QByteArray y = x.toUpper();
// y == "QT BY THE QT COMPANY"

Siehe auch isUpper(), toLower() und Character Case.

QByteArray QByteArray::trimmed() const

Gibt eine Kopie dieses Byte-Arrays zurück, bei der Leerzeichen am Anfang und am Ende entfernt wurden.

Bei den Leerzeichen handelt es sich um diejenigen, für die die Standard-C++-Funktion ` isspace() ` in der C-Locale den Wert ` true ` zurückgibt; dies sind die ASCII-Zeichen Tabulator `'\t'`, Zeilenvorschub `'\n'`, Wagenrücklauf `'\r'`, vertikaler Tabulator `'\v'`, Seitenvorschub `'\f'` und Leerzeichen `' '`.

Beispiel:

QByteArray ba("  lots\t of\nwhitespace\r\n ");
ba = ba.trimmed();
// ba == "lots\t of\nwhitespace";

Im Gegensatz zu ` simplified()` belässt `trimmed()` interne Leerzeichen unverändert.

Siehe auch „ simplified()“, „ QChar::SpecialCharacter “ und „ Spacing Characters “.

void QByteArray::truncate(qsizetype pos)

Kürzt das Byte-Array an der Indexposition pos ab.

Liegt pos außerhalb des Array-Endes, geschieht nichts.

Beispiel:

QByteArray ba("Stockholm");
ba.truncate(5);             // ba == "Stock"

Siehe auch chop(), resize() und first().

Gibt einen Zeiger auf die im Byte-Array gespeicherten Daten zurück. Der Zeiger kann verwendet werden, um auf die Bytes zuzugreifen, aus denen das Array besteht. Die Daten werden durch „\0 “ abgeschlossen.

Der Zeiger bleibt gültig, solange keine Trennung erfolgt und der „ QByteArray “ nicht verändert wird.

Dieser Operator ist vor allem nützlich, um ein Byte-Array an eine Funktion zu übergeben, die ein ` const char *` akzeptiert.

Sie können diesen Operator deaktivieren, indem Sie bei der Kompilierung Ihrer Anwendungen „ QT_NO_CAST_FROM_BYTEARRAY “ definieren.

Hinweis: Ein ` QByteArray ` kann beliebige Byte-Werte speichern, einschließlich `'\0`s, aber die meisten Funktionen, die ` char * `-Argumente entgegennehmen, gehen davon aus, dass die Daten am ersten `'\0` enden, auf das sie stoßen.

Siehe auch ` constData()`.

[noexcept, since 6.10] QByteArray::operator std::string_view() const

Wandelt dieses „ QByteArray “-Objekt in ein „ std::string_view “-Objekt um. Die zurückgegebene String-Ansicht erstreckt sich über das gesamte Byte-Array.

Diese Funktion wurde in Qt 6.10 eingeführt.

QByteArray &QByteArray::operator+=(const QByteArray &ba)

Fügt das Byte-Array „ ba “ an das Ende dieses Byte-Arrays an und gibt eine Referenz auf dieses Byte-Array zurück.

Beispiel:

QByteArray x("free");
QByteArray y("dom");
x += y;
// x == "freedom"

Hinweis: „ QByteArray “ ist eine implizit gemeinsam genutzte Klasse. Wenn Sie also an ein leeres Byte-Array anhängen, nutzt dieses Byte-Array lediglich die in „ ba “ enthaltenen Daten. In diesem Fall erfolgt kein Kopieren der Daten, was konstante Zeit in Anspruch nimmt. Wird eine gemeinsam genutzte Instanz geändert, wird sie kopiert (Copy-on-Write), was lineare Zeit in Anspruch nimmt.

Ist das Byte-Array, an das angehängt wird, nicht leer, wird eine tiefe Kopie der Daten erstellt, was lineare Zeit in Anspruch nimmt.

Dieser Vorgang verursacht in der Regel keinen Zuweisungsaufwand, da ` QByteArray ` am Ende der Daten zusätzlichen Speicherplatz vorab zuweist, sodass das Array ohne erneute Zuweisung bei jedem Anhängen vergrößert werden kann.

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

QByteArray &QByteArray::operator+=(char ch)

Fügt das Byte- ch s an das Ende dieses Byte-Arrays an und gibt eine Referenz auf dieses Byte-Array zurück.

QByteArray &QByteArray::operator+=(const char *str)

Fügt die durch „\0 “ begrenzte Zeichenkette „ str “ an das Ende dieses Byte-Arrays an und gibt eine Referenz auf dieses Byte-Array zurück.

[noexcept] QByteArray &QByteArray::operator=(QByteArray &&other)

Weist „ other “ dieser „ QByteArray “-Instanz zu.

[noexcept] QByteArray &QByteArray::operator=(const QByteArray &other)

Weist diesem Byte-Array den Wert „ other “ zu und gibt eine Referenz auf dieses Byte-Array zurück.

QByteArray &QByteArray::operator=(const char *str)

Weist diesem Byte-Array den Wert „ str “ zu.

str Es wird davon ausgegangen, dass „is“ auf eine null-terminierte Zeichenkette zeigt, deren Länge dynamisch ermittelt wird.

char &QByteArray::operator[](qsizetype i)

Gibt das Byte an der Indexposition „ i “ als bearbeitbare Referenz zurück.

i muss eine gültige Indexposition im Byte-Array sein (d. h. 0 <= i < size()).

Beispiel:

QByteArray ba("Hello, world");
cout << ba[0]; // prints H
ba[7] = 'W';
// ba == "Hello, World"

Siehe auch ` at()`.

char QByteArray::operator[](qsizetype i) const

Genau wie unter (i).