QByteArray Class

Dokumentation der Mitgliedsfunktionen

Sie gibt die maximale Anzahl von Elementen zurück, die das Byte-Array theoretisch aufnehmen kann. In der Praxis kann die Anzahl viel kleiner sein, begrenzt durch die Menge an Speicher, die dem System zur Verfügung steht.

Diese Funktion wurde in Qt 6.8 eingeführt.

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 sind '\0'-terminiert.

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

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

Sie können diesen Operator deaktivieren, indem Sie QT_NO_CAST_FROM_BYTEARRAY definieren, wenn Sie Ihre Anwendungen kompilieren.

Hinweis: Ein QByteArray kann beliebige Byte-Werte einschließlich '\0' speichern, aber die meisten Funktionen, die char * Argumente annehmen, gehen davon aus, dass die Daten am ersten '\0' enden, auf den sie treffen.

Siehe auch constData().

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

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

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

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

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

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

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

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

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

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

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 der Grenzen liegen können, verwenden Sie stattdessen sliced() in neuem Code, da dies schneller ist.

Wenn len -1 ist (die Vorgabe) oder pos + len >= size(), wird ein Byte-Array zurückgegeben, das alle Bytes ab Position pos bis zum Ende des Byte-Arrays enthält.

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

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

Beispiel:

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

Diese Funktion wurde in Qt 6.0 eingeführt.

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

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

Beispiel:

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

Diese Funktion wurde in Qt 6.0 eingeführt.

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

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

Beispiel:

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

Diese Funktion wurde in Qt 6.0 eingeführt.

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

Dies ist eine überladene Funktion.

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

Diese Funktion wurde in Qt 6.0 eingeführt.

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

Gibt ein Byte-Array zurück, das die äußersten linken size() - len Bytes dieses Byte-Arrays enthält.

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

Dies ist eine überladene Funktion.

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

Ein Beispiel:

void process(const QByteArray &);

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

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

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

Siehe auch toBase64().

[constexpr noexcept] QByteArray::QByteArray()

Konstruiert ein leeres Byte-Array.

Siehe auch isEmpty().

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

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

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

Wenn size negativ ist, wird angenommen, dass data auf einen '\0'-terminierten String zeigt und seine Länge dynamisch bestimmt wird.

QByteArray erstellt eine tiefe Kopie der String-Daten.

Siehe auch fromRawData().

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

Konstruiert ein Byte-Array der Größe size mit uninitialisiertem Inhalt.

QByteArray::QByteArray(qsizetype size, char ch)

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

Siehe auch fill().

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

Konstruiert eine Kopie von other.

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

Siehe auch operator=().

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

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

[noexcept] QByteArray::~QByteArray()

Zerstört das Byte-Array.

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

Hängt das Byte-Array ba an das Ende dieses Byte-Arrays an.

Beispiel:

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

Dies ist dasselbe wie insert(size(), ba).

Hinweis: QByteArray ist eine implizit gemeinsam genutzte Klasse. Wenn Sie also an ein leeres Byte-Array anhängen, teilt das Byte-Array nur die Daten, die in ba gehalten werden. In diesem Fall werden keine Daten kopiert, was konstante Zeit benötigt. Wenn eine gemeinsam genutzte Instanz geändert wird, wird sie kopiert (copy-on-write), was lineare Zeit benötigt.

Wenn das Byte-Array, an das angehängt wird, nicht leer ist, wird eine Tiefenkopie der Daten durchgeführt, was lineare Zeit benötigt.

Die Funktion append() ist in der Regel sehr schnell(konstante Zeit), da QByteArray zusätzlichen Speicherplatz am Ende der Daten zuweist, so dass sie wachsen kann, ohne jedes Mal das gesamte Array neu zuzuweisen.

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

QByteArray &QByteArray::append(QByteArrayView data)

Dies ist eine überladene Funktion.

Hängt data an dieses Byte-Array an.

QByteArray &QByteArray::append(char ch)

Dies ist eine überladene Funktion.

Hängt das Byte ch an dieses Byte-Array an.

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

Dies ist eine überladene Funktion.

Hängt die '\0'-terminierte Zeichenkette str an dieses Byte-Array an.

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

Dies ist eine überladene Funktion.

Hängt die ersten len Bytes beginnend bei str an dieses Byte-Array an und gibt einen Verweis auf dieses Byte-Array zurück. Die angehängten Bytes können '\0'-Bytes enthalten.

Wenn len negativ ist, wird str als '\0'-terminierter String angenommen und die zu kopierende Länge wird automatisch mit qstrlen() bestimmt.

Wenn len gleich Null oder str gleich Null ist, wird nichts an das Byte-Array angehängt. Stellen Sie sicher, dass len nicht länger als str ist.

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

Dies ist eine überladene Funktion.

Hängt count Kopien des Bytes ch an dieses Byte-Array an und gibt eine Referenz auf dieses Byte-Array zurück.

Wenn count negativ oder Null ist, wird nichts an das Byte-Array angehängt.

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

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

Die Größe dieses Byte-Arrays ist gleich der Größe von v.

Diese Funktion weist nur dann Speicher zu, 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 Iteratorbereich [first, last) und gibt eine Referenz auf dieses Byte-Array zurück.

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

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

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 einen Verweis auf dieses Byte-Array zurück.

Die Größe dieses Byte-Arrays ist gleich n, die nicht negativ sein darf.

Diese Funktion weist nur dann Speicher zu, 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 einen Verweis auf das letzte Byte im Byte-Array zurück. Dasselbe wie 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. Dasselbe wie 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

Diese Funktion überlastet begin().

qsizetype QByteArray::capacity() const

Gibt die maximale Anzahl von Bytes zurück, die in dem Byte-Array gespeichert werden können, ohne eine Neuzuweisung zu erzwingen.

Der einzige Zweck dieser Funktion besteht darin, die Speichernutzung von QByteArray fein abzustimmen. Im Allgemeinen werden Sie diese Funktion nur selten aufrufen müssen. Wenn Sie wissen wollen, wie viele Bytes sich in dem Byte-Array befinden, rufen Sie size() auf.

Siehe auch reserve() und squeeze().

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

Gibt einen const STL-artigen Iterator 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 const STL-artigen Iterator 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.

Wenn n größer ist 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().

void QByteArray::clear()

Löscht den Inhalt des Byte-Arrays und macht ihn 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, gleich oder größer als Null ist, je nachdem, ob diese QByteArray vor, an der gleichen Position wie oder nach der QByteArrayView bv sortiert ist. Der Vergleich wird unter Berücksichtigung der Groß- und Kleinschreibung cs durchgeführt.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch operator== und Character Case.

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

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

Siehe auch begin() und constEnd().

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

Liefert einen Zeiger auf die in dem Byte-Array gespeicherten Konstanten-Daten. Der Zeiger kann verwendet werden, um auf die Bytes zuzugreifen, aus denen das Array besteht. Die Daten sind '\0'-terminiert, es sei denn, das Objekt QByteArray wurde aus Rohdaten erstellt.

Der Zeiger bleibt gültig, solange keine Abtrennung erfolgt und die 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 einschließlich '\0' speichern, aber die meisten Funktionen, die char * Argumente annehmen, gehen davon aus, dass die Daten am ersten '\0' enden, auf den sie treffen.

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

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

Gibt einen const STL-artigen Iterator 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 betrachteten Byte-Folge 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

Dies ist eine überladene Funktion.

Gibt true zurück, wenn das Byte-Array das Byte ch enthält; andernfalls gibt sie false zurück.

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

Gibt die Anzahl der (sich möglicherweise überschneidenden) Vorkommen der von bv betrachteten Bytefolge in diesem Byte-Array zurück.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch contains() und indexOf().

qsizetype QByteArray::count(char ch) const

Dies ist eine überladene Funktion.

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

Siehe auch contains() und indexOf().

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

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

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

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

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

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

char *QByteArray::data()

Gibt einen Zeiger auf die im Byte-Array gespeicherten Daten zurück. Mit dem Zeiger kann auf die Bytes, aus denen das Array besteht, zugegriffen und diese verändert werden. Die Daten sind '\0'-terminiert, d.h. die Anzahl der Bytes, auf die Sie nach dem zurückgegebenen Zeiger zugreifen können, ist size() + 1, einschließlich des '\0'-Terminators.

Beispiel:

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

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

Bei Nur-Lese-Zugriffen ist constData() schneller, da es nie zu einer Tiefenkopie kommt.

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

Das folgende Beispiel erstellt eine Kopie des von data() zurückgegebenen char*, aber es wird den Heap beschädigen und einen Absturz verursachen, weil es kein Byte für das '\0' am Ende zuweist:

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

Hier wird die richtige Menge an Speicherplatz zugewiesen:

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

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

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

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

Dies ist eine überladene Funktion.

QByteArray::iterator QByteArray::end()

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

Siehe auch begin() und constEnd().

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

Diese Funktion überlastet end().

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

Gibt true zurück, wenn dieses Byte-Array mit der von bv betrachteten Bytefolge 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

Dies ist eine überladene Funktion.

Gibt true zurück, wenn dieses Byte-Array mit dem Byte ch endet; andernfalls gibt sie false zurück.

[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 zu dem Zeichen zurück, auf das last vor dem Löschen verweist.

Diese Funktion wurde in Qt 6.1 eingeführt.

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

Dies ist eine überladene Funktion.

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

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 ist (die Vorgabe), wird das Byte-Array vorher auf die Größe size angepasst.

Beispiel:

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

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

Siehe auch resize().

[static] QByteArray QByteArray::fromBase64(const QByteArray &base64, QByteArray::Base64Options options = Base64Encoding)

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

Ein 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 Algorithmus zur Dekodierung von Base64-kodierten Daten ist in RFC 4648 definiert.

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

Siehe auch toBase64() und fromBase64Encoding().

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

Konstruiert eine neue QByteArray, die eine Kopie der CFData data enthält.

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

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

Konstruiert ein neues QByteArray, das eine Kopie des Uint8Array uint8array enthält.

Diese Funktion überträgt Daten aus einem JavaScript-Datenpuffer - der von C++-Code aus nicht adressierbar ist - in den Heap-Speicher, der einem QByteArray gehört. 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 z.B. aus einer globalen JavaScript-Variablen stammt:

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

Diese Funktion gibt eine 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, so dass der Dekodierungsprozess mit den nachfolgenden Zeichen fortgesetzt werden kann.

Zum Beispiel:

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

Siehe auch toHex().

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

Konstruiert eine neue QByteArray, die eine Kopie der NSData data enthält.

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

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

Dekodiert input aus der URI/URL-ähnlichen Prozentkodierung.

Gibt ein Byte-Array zurück, das den dekodierten Text enthält. Der Parameter percent erlaubt die Verwendung eines anderen Zeichens als "%" (z. B. "_" oder "=") als Escape-Zeichen. Äquivalent zu input.percentDecoded(Prozent).

Zum Beispiel:

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

Siehe auch percentDecoded().

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

Konstruiert eine QByteArray, die die Bytes der CFData data verwendet.

Die Bytes von data werden nicht kopiert.

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

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

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

Konstruiert ein QByteArray, das die ersten size Bytes des data Arrays verwendet. Die Bytes werden nicht kopiert. Der QByteArray enthält den Zeiger data. Der Aufrufer garantiert, dass data nicht gelöscht oder verändert wird, solange diese QByteArray und alle Kopien davon existieren, die nicht verändert wurden. 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 verändern, solange die zurückgegebene QByteArray und alle Kopien existieren. Allerdings übernimmt QByteArray nicht den Besitz von data, so dass der Destruktor QByteArray niemals den rohen data löschen wird, selbst wenn der letzte QByteArray, der auf data verweist, zerstört wird.

Ein anschließender Versuch, den Inhalt des zurückgegebenen QByteArray oder einer daraus erstellten Kopie zu ändern, führt dazu, dass eine Deep Copy des data Arrays erstellt wird, bevor die Änderung durchgeführt wird. Dadurch wird sichergestellt, dass das rohe Array data selbst niemals von QByteArray verändert wird.

Hier ist ein Beispiel dafür, wie man Daten mit einem QDataStream auf Rohdaten im Speicher liest, 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(), und constData().

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

Konstruiert eine QByteArray, die die Bytes der NSData data verwendet.

Die Bytes von data werden nicht kopiert.

Der Aufrufer garantiert, dass die NSData 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. Dasselbe wie 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 im Byte-Array zurück. Dasselbe wie 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 Beginns des ersten Vorkommens der von bv betrachteten Bytefolge in diesem Byte-Array zurück, wobei ab der Indexposition from vorwärts gesucht wird. 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

Dies ist eine überladene Funktion.

Gibt die Indexposition des Beginns des ersten Vorkommens des Byte ch in diesem Byte-Array zurück, wobei ab der Indexposition from vorwärts gesucht wird. 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 data an der Indexposition i ein und gibt einen Verweis 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 Zeit), da er erfordert, dass alle Bytes an den Indizes i und darüber um mindestens eine Position weiter im Speicher verschoben werden.

Dieses Array wächst, um das Einfügen zu ermöglichen. Wenn i über das Ende des Arrays hinausgeht, wird das Array zunächst mit Leerzeichen erweitert, um dieses 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 wächst, um das Einfügen zu ermöglichen. Wenn i hinter dem Ende des Arrays liegt, wird das Array zunächst mit Leerzeichen erweitert, um dieses 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 einen Verweis auf dieses Byte-Array zurück.

Dieses Array wächst, um das Einfügen zu ermöglichen. Wenn i über das Ende des Arrays hinausgeht, wird das Array zunächst mit Leerzeichen erweitert, um dieses i zu erreichen.

Die Funktion ist äquivalent zu insert(i, QByteArrayView(s))

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

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

Dies ist eine überladene Funktion.

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

Dieses Array wächst, um die Einfügung aufzunehmen. Wenn i über das Ende des Arrays hinausgeht, wird das Array zunächst mit Leerzeichen erweitert, um dieses i zu erreichen.

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

Dies ist eine überladene Funktion.

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

Dieses Array wächst, um das Einfügen zu ermöglichen. Wenn i über das Ende des Arrays hinausgeht, wird das Array zunächst mit Leerzeichen erweitert, um dieses i zu erreichen.

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

Dies ist eine überladene Funktion.

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

Dieses Array wächst, um das Einfügen zu ermöglichen. Wenn i über das Ende des Arrays hinausgeht, wird das Array zunächst mit Leerzeichen erweitert, um dieses i zu erreichen.

[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 Kleinbuchstaben enthält, d. h. wenn es mit seiner toLower()-Faltung identisch ist.

Beachten Sie, dass dies nicht bedeutet, dass das Byte-Array nur Kleinbuchstaben enthält, sondern nur, 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 wichtig, ob ein Byte-Array Daten enthält oder nicht, und dies kann mit isEmpty() ermittelt werden.

Siehe auch isEmpty().

bool QByteArray::isUpper() const

Gibt true zurück, wenn dieses Byte-Array in Großbuchstaben geschrieben ist, d. h. wenn es mit seiner toUpper()-Faltung identisch ist.

Beachten Sie, dass dies nicht bedeutet, dass das Byte-Array nur Großbuchstaben enthält, sondern nur, 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, oder andernfalls false.

Diese Funktion wurde in Qt 6.3 eingeführt.

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

Gibt die Indexposition des Beginns des letzten Vorkommens der durch bv angezeigten Bytefolge in diesem Byte-Array zurück, wobei ab der Indexposition from rückwärts gesucht wird.

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

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

Dies ist eine überladene Funktion.

Gibt die Indexposition des Beginns des letzten Vorkommens der von bv betrachteten Bytefolge in diesem Byte-Array zurück, wobei vom Ende des Byte-Arrays 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

Dies ist eine überladene Funktion.

Gibt die Indexposition des Beginns des letzten Vorkommens von Byte ch in diesem Byte-Array zurück, wobei ab Indexposition from rückwärts gesucht wird. Ist from gleich -1 (Standard), beginnt die Suche beim letzten Byte (bei Index 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().

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, das mit dem Byte fill aufgefüllt ist.

Wenn truncate falsch ist und size() des Byte-Arrays größer ist als width, dann ist das zurückgegebene Byte-Array eine Kopie dieses Byte-Arrays.

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

Beispiel:

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

Siehe auch rightJustified().

[noexcept] qsizetype QByteArray::length() const

Dasselbe wie size().

[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 repräsentiert, unter Verwendung der angegebenen base (standardmäßig zehn). Die Basen 2 bis 36 werden unterstützt, wobei Buchstaben für Ziffern jenseits von 9 verwendet werden: A ist zehn, B ist 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)

Dies ist eine überladene Funktion.

Siehe auch toLong().

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

Dies ist eine überladene Funktion.

Siehe auch toLongLong().

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

Dies ist eine überladene Funktion.

Siehe auch toULongLong().

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

Dies ist eine überladene Funktion.

Siehe auch toUInt().

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

Dies ist eine überladene Funktion.

Siehe auch toULong().

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

Dies ist eine überladene Funktion.

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

Gibt ein Byte-Array zurück, das eine Zeichenkette enthält, die n repräsentiert, mit einer gegebenen format und precision, mit den gleichen Bedeutungen wie für QString::number(double, char, int). Zum 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 URI/URL-ähnliche Prozentkodierung.

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.

Zum 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().

QByteArray &QByteArray::prepend(QByteArrayView ba)

Stellt die Byte-Array-Ansicht ba diesem Byte-Array voran und gibt einen Verweis auf dieses Byte-Array zurück.

Diese Operation ist typischerweise sehr schnell(konstante Zeit), da QByteArray zusätzlichen Platz am Anfang der Daten vorverteilt, so dass es wachsen kann, ohne jedes Mal das gesamte Array neu zuzuordnen.

Beispiel:

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

Dies ist dasselbe wie insert(0, ba).

Siehe auch append() und insert().

QByteArray &QByteArray::prepend(char ch)

Dies ist eine überladene Funktion.

Stellt das Byte ch diesem Byte-Array vor.

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

Dies ist eine überladene Funktion.

Stellt diesem Byte-Array ba vor.

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

Dies ist eine überladene Funktion.

Stellt die '\0'-terminierte Zeichenkette str diesem Byte-Array vor.

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

Dies ist eine überladene Funktion.

Stellt len Bytes ab str diesem Byte-Array vor. Die vorangestellten Bytes können '\0' Bytes enthalten.

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

Dies ist eine überladene Funktion.

Stellt count Kopien von Byte ch diesem Byte-Array vor.

void QByteArray::push_back(const QByteArray &other)

Diese Funktion ist aus Gründen der STL-Kompatibilität vorgesehen. Sie ist äquivalent zu append(other).

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

Dies ist eine überladene Funktion.

Dasselbe wie append(str).

Diese Funktion wurde in Qt 6.0 eingeführt.

void QByteArray::push_back(char ch)

Dies ist eine überladene Funktion.

Dasselbe wie append(ch).

void QByteArray::push_back(const char *str)

Dies ist eine überladene Funktion.

Dasselbe wie append(str).

void QByteArray::push_front(const QByteArray &other)

Diese Funktion ist aus Gründen der STL-Kompatibilität vorgesehen. Sie ist äquivalent zu prepend(other).

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

Dies ist eine überladene Funktion.

Dasselbe wie prepend(str).

Diese Funktion wurde in Qt 6.0 eingeführt.

void QByteArray::push_front(char ch)

Dies ist eine überladene Funktion.

Dasselbe wie prepend(ch).

void QByteArray::push_front(const char *str)

Dies ist eine überladene Funktion.

Dasselbe wie prepend(str).

QByteArray::reverse_iterator QByteArray::rbegin()

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

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

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

Dies ist eine überladene Funktion.

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

Entfernt len Bytes aus dem Array, beginnend an der Indexposition pos, und gibt einen Verweis auf das Array zurück.

Wenn pos außerhalb des Bereichs liegt, passiert nichts. Wenn pos gültig ist, aber pos + len größer als die Größe des Arrays ist, wird das Array an der Position pos abgeschnitten.

Beispiel:

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

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

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

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

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

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch remove().

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

Entfernt das erste Zeichen in diesem Byte-Array. Wenn das Byte-Array leer ist, tut diese Funktion nichts.

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, für die das Prädikat pred true zurückgibt, aus dem Byte-Array. 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 in diesem Byte-Array. Wenn das Byte-Array leer ist, tut diese Funktion nichts.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch remove().

QByteArray::reverse_iterator QByteArray::rend()

Gibt einen umgekehrten 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

Dies ist eine überladene Funktion.

QByteArray QByteArray::repeated(qsizetype times) const

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

Wenn times kleiner als 1 ist, 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 Bytes von len ab der Indexposition pos durch das Byte-Array after und gibt einen Verweis 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)

Dies ist eine überladene Funktion.

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)

Dies ist eine überladene Funktion.

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

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

Dies ist eine überladene Funktion.

Ersetzt jedes Vorkommen des Bytes before durch das Byte after.

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

Dies ist eine überladene Funktion.

Ersetzt jedes Vorkommen der bsize -Bytes ab before durch die asize -Bytes ab after. Da die Größen der Zeichenketten durch bsize und asize gegeben sind, können sie '\0' Bytes enthalten und müssen nicht '\0'-terminiert werden.

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

Dies ist eine überladene Funktion.

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

void QByteArray::reserve(qsizetype size)

Versucht, Speicher für mindestens size Bytes zuzuweisen.

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

Bei Zweifeln darüber, wie viel Platz benötigt wird, ist es in der Regel besser, eine Obergrenze wie size zu verwenden, oder eine hohe Schätzung der wahrscheinlichsten Größe, wenn eine strenge Obergrenze viel größer wäre als diese. Wenn size eine zu niedrige Schätzung ist, wird das Array nach Bedarf wachsen, sobald die reservierte Größe überschritten wird, was zu einer größeren Zuweisung führen kann, als es Ihre beste Überschätzung getan hätte, und die Operation, die sie auslöst, verlangsamen wird.

Der einzige Zweck dieser Funktion ist es, eine Möglichkeit zur Feinabstimmung der Speichernutzung von QByteArray zu bieten. Im Allgemeinen werden Sie diese Funktion nur selten aufrufen müssen.

Siehe auch squeeze() und capacity().

void QByteArray::resize(qsizetype size)

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

Wenn size größer als die aktuelle Größe ist, wird das Byte-Array auf size Bytes erweitert, wobei die zusätzlichen Bytes am Ende hinzugefügt werden. Die neuen Bytes sind uninitialisiert.

Wenn size kleiner als die aktuelle Größe ist, werden Bytes jenseits der Position size aus dem Byte-Array ausgeschlossen.

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

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

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

Wenn newSize größer als die aktuelle Größe ist, wird das Byte-Array auf newSize Bytes erweitert und die zusätzlichen Bytes am Ende hinzugefügt. Die neuen Bytes werden auf c initialisiert.

Wenn newSize kleiner als die aktuelle Größe ist, werden Bytes jenseits der Position newSize aus dem Byte-Array ausgeschlossen.

Diese Funktion wurde in Qt 6.4 eingeführt.

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

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

Ändert die Größe des Byte-Arrays auf size Bytes. Wenn die Größe des Byte-Arrays wächst, werden die neuen Bytes nicht initialisiert.

Das Verhalten ist identisch zu resize(size).

Diese Funktion wurde in Qt 6.8 eingeführt.

Siehe auch resize().

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.

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

Wenn truncate wahr ist und die Größe des Byte-Arrays größer ist als width, dann 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)

Stellt die ganze Zahl n als Text dar.

Setzt dieses Byte-Array auf eine Zeichenkette, die n in der Basis base (standardmäßig zehn) darstellt, und gibt einen Verweis auf dieses Byte-Array zurück. Die Basen 2 bis 36 werden unterstützt, wobei Buchstaben für Ziffern jenseits von 9 verwendet werden; A ist zehn, B ist elf 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)

Dies ist eine überladene Funktion.

Siehe auch toLong().

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

Dies ist eine überladene Funktion.

Siehe auch toLongLong().

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

Dies ist eine überladene Funktion.

Siehe auch toULongLong().

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

Dies ist eine überladene Funktion.

Siehe auch toShort().

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

Dies ist eine überladene Funktion.

Siehe auch toUInt().

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

Dies ist eine überladene Funktion.

Siehe auch toULong().

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

Dies ist eine überladene Funktion.

Siehe auch toUShort().

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

Dies ist eine überladene Funktion.

Stellt die Fließkommazahl n als Text dar.

Setzt dieses Byte-Array auf eine Zeichenkette, die n repräsentiert, mit einem gegebenen format und precision (mit denselben Bedeutungen wie für QString::number(double, char, int)), und gibt einen Verweis auf dieses Byte-Array zurück.

Siehe auch toDouble() und QLocale::FloatingPointPrecisionOption.

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

Dies ist eine überladene Funktion.

Stellt die Fließkommazahl n als Text dar.

Setzt dieses Byte-Array auf eine Zeichenkette, die n repräsentiert, mit einem gegebenen format und precision (mit denselben Bedeutungen wie für QString::number(double, char, int)), und gibt einen Verweis auf dieses Byte-Array zurück.

Siehe auch toFloat().

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

Setzt QByteArray zurück, um die ersten size Bytes des Arrays data zu verwenden. Die Bytes werden nicht kopiert. Der QByteArray enthält den Zeiger data. Der Aufrufer garantiert, dass data nicht gelöscht oder verändert wird, solange diese QByteArray und alle Kopien davon existieren, die nicht verändert worden sind.

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

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

void QByteArray::shrink_to_fit()

Diese Funktion ist aus Gründen der STL-Kompatibilität vorgesehen. Sie ist äquivalent zu 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 bei der jede Folge von internen Leerzeichen durch ein einzelnes Leerzeichen ersetzt wurde.

Es handelt sich dabei um diejenigen Zeichen, für die die C++-Standardfunktion isspace() in der C-Sprachumgebung true zurückgibt; dies sind die ASCII-Zeichen Tabulator '\t', Zeilenvorschub '\n', Wagenrücklauf '\r', vertikaler Tabulator '\v', Formfeed '\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.

[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. Außerdem stellt QByteArray sicher, dass das Byte an der Position size() immer '\0' ist, so dass Sie den Rückgabewert von data() und constData() als Argumente für Funktionen verwenden können, die Strings mit '\0'-Ende erwarten. Wenn das Objekt QByteArray aus einem raw data erstellt wurde, das das abschließende '\0'-Byte nicht enthielt, dann fügt QByteArray es nicht automatisch hinzu, es sei denn, es wird eine Deep Copy 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, erweitert um n Bytes und gibt einen Verweis 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)

Dies ist eine überladene Funktion.

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

Diese Funktion wurde in Qt 6.8 eingeführt.

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

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

Teilt das Byte-Array in Unterarrays auf, wo immer sep vorkommt, und gibt die Liste dieser Arrays zurück. Wenn sep nirgendwo im Byte-Array vorkommt, gibt split() eine Einzelelementliste zurück, die dieses Byte-Array enthält.

void QByteArray::squeeze()

Gibt jeglichen Speicher frei, der nicht zum Speichern der Daten des Arrays benötigt wird.

Der einzige Zweck dieser Funktion ist es, eine Möglichkeit zur Feinabstimmung der Speichernutzung von QByteArray zu bieten. Im Allgemeinen werden Sie diese Funktion nur selten 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 durch bv angezeigten Bytefolge 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

Dies ist eine überladene Funktion.

Gibt true zurück, wenn dieses Byte-Array mit dem Byte ch beginnt; andernfalls gibt sie false zurück.

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

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

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

Gibt eine Kopie des Byte-Arrays zurück, kodiert mit den Optionen options.

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

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

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

Siehe auch fromBase64().

CFDataRef QByteArray::toCFData() const

Erzeugt ein CFData aus einem QByteArray.

Der Aufrufer ist Eigentümer des CFData-Objekts und dafür verantwortlich, es wieder freizugeben.

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 eine Unendlichkeit zurück, wenn die Konvertierung überläuft, oder 0,0, wenn die Konvertierung aus anderen Gründen fehlschlägt (z. B. Unterlauf).

Wenn ok nicht nullptr ist, wird ein Fehler durch Setzen von *ok auf false und ein Erfolg durch Setzen von *ok auf true gemeldet.

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

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

Diese Funktion ignoriert führende und abschließende Leerzeichen.

Siehe auch number().

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

Erzeugt ein Uint8Array aus einem QByteArray.

Diese Funktion überträgt Daten aus dem Heap-Speicher von QByteArray in einen JavaScript-Datenpuffer. Die Funktion alloziert und kopiert in einen ArrayBuffer und gibt eine Uint8Array-Ansicht auf diesen Puffer zurück.

Die JavaScript-Objekte besitzen eine Kopie der Daten, und diese QByteArray kann sicher gelöscht werden, nachdem die Kopie erstellt wurde.

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

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch toEcmaUint8Array().

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

Gibt das in einen float -Wert konvertierte Byte-Array zurück.

Gibt eine Unendlichkeit zurück, wenn die Konvertierung überläuft, oder 0,0, wenn die Konvertierung aus anderen Gründen fehlschlägt (z. B. Unterlauf).

Wenn ok nicht nullptr ist, wird ein Fehler durch Setzen von *ok auf false und ein Erfolg durch Setzen von *ok auf true gemeldet.

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

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

Diese Funktion ignoriert führende und abschließende 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 Zahlen 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, was standardmäßig zehn ist. Die Basen 0 und 2 bis 36 werden unterstützt, wobei Buchstaben für Ziffern jenseits von 9 verwendet werden; A ist zehn, B ist elf und so weiter.

Wenn base gleich 0 ist, wird die Basis automatisch nach den folgenden Regeln ermittelt: Wenn das Byte-Array mit "0x" beginnt, wird angenommen, dass es hexadezimal (Basis 16) ist; andernfalls, wenn es mit "0b" beginnt, wird angenommen, dass es binär (Basis 2) ist; andernfalls, wenn es mit "0" beginnt, wird angenommen, dass es oktal (Basis 8) ist; andernfalls wird angenommen, dass es dezimal ist.

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

Wenn ok nicht nullptr ist, wird ein Fehler durch Setzen von *ok auf false und ein Erfolg durch Setzen von *ok auf true gemeldet.

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 eine long int konvertiert wurde, die standardmäßig zehn ist. Die Basen 0 und 2 bis 36 werden unterstützt, wobei Buchstaben für Ziffern jenseits von 9 verwendet werden; A ist zehn, B ist elf und so weiter.

Wenn base gleich 0 ist, wird die Basis automatisch nach den folgenden Regeln ermittelt: Wenn das Byte-Array mit "0x" beginnt, wird angenommen, dass es hexadezimal (Basis 16) ist; andernfalls, wenn es mit "0b" beginnt, wird angenommen, dass es binär (Basis 2) ist; andernfalls, wenn es mit "0" beginnt, wird angenommen, dass es oktal (Basis 8) ist; andernfalls wird angenommen, dass es dezimal ist.

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

Wenn ok nicht nullptr ist, wird ein Fehler durch Setzen von *ok auf false und ein Erfolg durch Setzen von *ok auf true gemeldet.

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 long long konvertiert wurde, die standardmäßig zehn ist. Die Basen 0 und 2 bis 36 werden unterstützt, wobei Buchstaben für Ziffern jenseits von 9 verwendet werden; A ist zehn, B ist elf und so weiter.

Wenn base gleich 0 ist, wird die Basis automatisch nach den folgenden Regeln bestimmt: Wenn das Byte-Array mit "0x" beginnt, wird angenommen, dass es hexadezimal (Basis 16) ist; andernfalls, wenn es mit "0b" beginnt, wird angenommen, dass es binär (Basis 2) ist; andernfalls, wenn es mit "0" beginnt, wird angenommen, dass es oktal (Basis 8) ist; andernfalls wird angenommen, dass es dezimal ist.

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

Wenn ok nicht nullptr ist, wird ein Fehler durch Setzen von *ok auf false und ein Erfolg durch Setzen von *ok auf true gemeldet.

Siehe auch number().

QByteArray QByteArray::toLower() const

Gibt eine Kopie des Byte-Arrays zurück, in dem jeder ASCII-Großbuchstabe in 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

Erzeugt eine NSData aus einer QByteArray.

Das NSData-Objekt wird automatisch wieder freigegeben.

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

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

Gibt eine prozentual kodierte Kopie dieses Byte-Arrays im URI/URL-Stil zurück. Mit dem Parameter percent können Sie das Standardzeichen "%" durch ein anderes ersetzen.

Standardmäßig kodiert diese Funktion alle Bytes, die nicht eines der folgenden sind:

ALPHA ("a" bis "z" und "A" bis "Z") / DIGIT (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 = "{ein fischiger String?}";QByteArray ba = text.toPercentEncoding("{}", "s");qDebug("%s", ba.constData());
// druckt "{a fi%73hy %73tring%3F}"

Die Hex-Codierung verwendet die Zahlen 0-9 und die Großbuchstaben A-F.

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

CFDataRef QByteArray::toRawCFData() const

Konstruiert ein CFData, das die Bytes von QByteArray verwendet.

Die Bytes von QByteArray werden nicht kopiert.

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

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

NSData *QByteArray::toRawNSData() const

Konstruiert eine NSData, die die Bytes der QByteArray verwendet.

Die Bytes von QByteArray werden nicht kopiert.

Der Aufrufer garantiert, dass die 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 short konvertiert wurde, die standardmäßig zehn ist. Die Basen 0 und 2 bis 36 werden unterstützt, wobei Buchstaben für Ziffern jenseits von 9 verwendet werden; A ist zehn, B ist elf und so weiter.

Wenn base gleich 0 ist, wird die Basis automatisch nach den folgenden Regeln bestimmt: Wenn das Byte-Array mit "0x" beginnt, wird angenommen, dass es hexadezimal (Basis 16) ist; andernfalls, wenn es mit "0b" beginnt, wird angenommen, dass es binär (Basis 2) ist; andernfalls, wenn es mit "0" beginnt, wird angenommen, dass es oktal (Basis 8) ist; andernfalls wird angenommen, dass es dezimal ist.