QByteArray Class

Documentation des fonctions membres

[constexpr noexcept] QByteArray::QByteArray()

Construit un tableau d'octets vide.

Voir également isEmpty().

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

Construit un tableau d'octets initialisé avec les données de la vue tableau d'octets.

Le QByteArray sera nul si et seulement si v est nul.

Cette fonction a été introduite dans Qt 6.8.

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

Construit un tableau d'octets contenant les premiers size octets du tableau data.

Si data vaut 0, un tableau d'octets nul est construit.

Si size est négatif, data est supposé pointer vers une chaîne de caractères terminée par '\0' et sa longueur est déterminée dynamiquement.

QByteArray fait une copie profonde des données de la chaîne.

Voir également fromRawData().

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

Construit un tableau d'octets de taille size dont le contenu n'est pas initialisé.

Par exemple :

QByteArray buffer(123, Qt::Uninitialized);

QByteArray::QByteArray(qsizetype size, char ch)

Construit un tableau d'octets de taille size dont chaque octet vaut ch.

Voir aussi fill().

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

Construit une copie de other.

Cette opération prend un temps constant, car le QByteArray est implicitement partagé. Cela rend le retour d'un QByteArray à partir d'une fonction très rapide. Si une instance partagée est modifiée, elle sera copiée (copy-on-write), ce qui prend un temps linéaire.

Voir également operator=().

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

Move-construit une instance de QByteArray, en la faisant pointer sur le même objet que other.

[noexcept] QByteArray::~QByteArray()

Détruit le tableau d'octets.

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

Ajoute le tableau d'octets ba à la fin de ce tableau d'octets.

Exemple :

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

C'est la même chose que insert(size(), ba).

Remarque : QByteArray est une classe implicitement partagée. Par conséquent, si vous ajoutez à un tableau d'octets vide, le tableau d'octets partagera simplement les données contenues dans ba. Dans ce cas, aucune copie de données n'est effectuée, ce qui prend un temps constant. Si une instance partagée est modifiée, elle sera copiée (copy-on-write), ce qui prend un temps linéaire.

Si le tableau d'octets auquel la fonction append est appliquée n'est pas vide, une copie profonde des données est effectuée, ce qui prend un temps linéaire.

La fonction append() est généralement très rapide(temps constant), car QByteArray préaffecte de l'espace supplémentaire à la fin des données, ce qui lui permet de croître sans avoir à réaffecter l'ensemble du tableau à chaque fois.

Voir également operator+=(), prepend() et insert().

QByteArray &QByteArray::append(QByteArrayView data)

Ajoute data à ce tableau d'octets.

QByteArray &QByteArray::append(char ch)

Ajoute l'octet ch à ce tableau d'octets.

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

Ajoute la chaîne '\0'-terminée str à ce tableau d'octets.

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

Ajoute les premiers len octets commençant par str à ce tableau d'octets et renvoie une référence à ce tableau d'octets. Les octets ajoutés peuvent inclure des octets '\0'.

Si len est négatif, str sera considéré comme une chaîne de caractères terminée par '\0' et la longueur à copier sera déterminée automatiquement à l'aide de qstrlen().

Si len est égal à zéro ou si str est nul, rien n'est ajouté au tableau d'octets. Assurez-vous que len n' est pas plus long que str.

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

Ajoute count copies de l'octet ch à ce tableau d'octets et renvoie une référence à ce tableau d'octets.

Si count est négatif ou nul, rien n'est ajouté au tableau d'octets.

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

Remplace le contenu de ce tableau d'octets par une copie de v et renvoie une référence à ce tableau d'octets.

La taille de ce tableau d'octets sera égale à la taille de v.

Cette fonction n'alloue de la mémoire que si la taille de v dépasse la capacité de ce tableau d'octets ou si ce tableau d'octets est partagé.

Cette fonction a été introduite dans Qt 6.6.

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

Remplace le contenu de ce tableau d'octets par une copie des éléments de l'intervalle de l'itérateur [first, last) et renvoie une référence à ce tableau d'octets.

La taille de ce tableau d'octets sera égale au nombre d'éléments dans l'intervalle [first, last).

Cette fonction n'allouera de la mémoire que si le nombre d'éléments dans l'intervalle dépasse la capacité de ce tableau d'octets ou si ce tableau d'octets est partagé.

Contraintes

Participe à la résolution des surcharges uniquement si InputIterator répond aux exigences d'un LegacyInputIterator.

Cette fonction a été introduite dans Qt 6.6.

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

Remplace le contenu de ce tableau d'octets par n copies de c et renvoie une référence à ce tableau d'octets.

La taille de ce tableau d'octets sera égale à n, qui doit être non négatif.

Cette fonction n'allouera de la mémoire que si n dépasse la capacité de ce tableau d'octets ou si ce tableau d'octets est partagé.

Cette fonction a été introduite dans Qt 6.6.

Voir aussi fill().

char QByteArray::at(qsizetype i) const

Renvoie l'octet à la position d'index i dans le tableau d'octets.

i doit être une position d'index valide dans le tableau d'octets (c'est-à-dire 0 <= i < size()).

Voir aussi operator[]().

char &QByteArray::back()

Renvoie une référence au dernier octet du tableau d'octets. Identique à operator[](size() - 1).

Cette fonction est fournie pour la compatibilité STL.

Voir aussi front(), at() et operator[]().

char QByteArray::back() const

Renvoie le dernier octet du tableau d'octets. Identique à at(size() - 1).

Cette fonction est fournie pour la compatibilité STL.

Voir aussi front(), at() et operator[]().

QByteArray::iterator QByteArray::begin()

Renvoie un itérateur de style STL pointant sur le premier octet du tableau d'octets.

Voir aussi constBegin() et end().

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

qsizetype QByteArray::capacity() const

Renvoie le nombre maximum d'octets pouvant être stockés dans le tableau d'octets sans forcer une réallocation.

Le seul but de cette fonction est de fournir un moyen d'affiner l'utilisation de la mémoire par QByteArray. En général, vous n'aurez que rarement besoin d'appeler cette fonction. Si vous voulez savoir combien d'octets se trouvent dans le tableau d'octets, appelez size().

Voir également reserve() et squeeze().

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

Renvoie un itérateur constant de style STL pointant sur le premier octet du tableau d'octets.

Voir aussi begin() et cend().

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

Renvoie un itérateur constant de style STL pointant juste après le dernier octet du tableau d'octets.

Voir aussi cbegin() et end().

void QByteArray::chop(qsizetype n)

Supprime n octets de la fin du tableau d'octets.

Si n est supérieur à size(), le résultat est un tableau d'octets vide.

Exemple :

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

Voir également truncate(), resize() et first().

Renvoie un tableau d'octets contenant les octets size() - len les plus à gauche de ce tableau d'octets.

Voir aussi endsWith(), first(), last(), sliced(), chop(), truncate() et slice().

void QByteArray::clear()

Efface le contenu du tableau d'octets et le rend nul.

Voir aussi resize() et isNull().

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

Renvoie un nombre entier inférieur, égal ou supérieur à zéro selon que ce QByteArray est classé avant, à la même position que ou après le QByteArrayView bv . La comparaison est effectuée en fonction de la sensibilité à la casse cs.

Cette fonction a été introduite dans Qt 6.0.

Voir également operator== et Character Case.

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

Renvoie un itérateur constant de style STL pointant sur le premier octet du tableau d'octets.

Voir aussi begin() et constEnd().

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

Renvoie un pointeur sur les données constantes stockées dans le tableau d'octets. Le pointeur peut être utilisé pour accéder aux octets qui composent le tableau. Les données sont '\0'-terminées sauf si l'objet QByteArray a été créé à partir de données brutes.

Le pointeur reste valide tant qu'il n'y a pas de détachement et que l'objet QByteArray n'est pas modifié.

Cette fonction est surtout utile pour passer un tableau d'octets à une fonction qui accepte un const char *.

Remarque : un QByteArray peut stocker n'importe quelle valeur d'octet, y compris des '\0', mais la plupart des fonctions qui prennent des arguments char * supposent que les données se terminent au premier '\0' qu'elles rencontrent.

Voir également data(), operator[]() et fromRawData().

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

Renvoie un itérateur constant de style STL pointant juste après le dernier octet du tableau d'octets.

Voir aussi constBegin() et end().

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

Renvoie true si ce tableau d'octets contient une occurrence de la séquence d'octets vue par bv; sinon, renvoie false.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi indexOf() et count().

bool QByteArray::contains(char ch) const

Renvoie true si le tableau d'octets contient l'octet ch; sinon, renvoie false.

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

Renvoie le nombre d'occurrences (pouvant se chevaucher) de la séquence d'octets visualisée par bv dans ce tableau d'octets.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi contains() et indexOf().

qsizetype QByteArray::count(char ch) const

Renvoie le nombre d'occurrences de l'octet ch dans le tableau d'octets.

Voir aussi contains() et indexOf().

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

Renvoie un itérateur inverse de style STL constant pointant sur le premier octet du tableau d'octets, dans l'ordre inverse.

Voir aussi begin(), rbegin(), et rend().

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

Renvoie un itérateur inverse de style STL constant pointant juste après le dernier octet du tableau d'octets, dans l'ordre inverse.

Voir aussi end(), rend(), et rbegin().

char *QByteArray::data()

Renvoie un pointeur sur les données stockées dans le tableau d'octets. Le pointeur peut être utilisé pour accéder et modifier les octets qui composent le tableau. Les données sont terminées par '\0', c'est-à-dire que le nombre d'octets auxquels vous pouvez accéder après le pointeur retourné est size() + 1, y compris le terminateur '\0'.

Exemple :

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

Le pointeur reste valide tant qu'il n'y a pas de détachement et que le site QByteArray n'est pas modifié.

Pour un accès en lecture seule, constData() est plus rapide car il n'y a jamais de copie profonde.

Cette fonction est surtout utile pour passer un tableau d'octets à une fonction qui accepte un const char *.

L'exemple suivant fait une copie du char* renvoyé par data(), mais il corrompra le tas et provoquera un crash car il n'alloue pas d'octet pour le '\0' à la fin :

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

Celui-ci alloue la quantité correcte d'espace :

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

Remarque : un QByteArray peut stocker n'importe quelle valeur d'octet, y compris des '\0', mais la plupart des fonctions qui prennent des arguments char * supposent que les données se terminent au premier '\0' qu'elles rencontrent.

Voir également constData() et operator[]().

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

QByteArray::iterator QByteArray::end()

Renvoie un itérateur de style STL pointant juste après le dernier octet du tableau d'octets.

Voir aussi begin() et constEnd().

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

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

Renvoie true si ce tableau d'octets se termine par la séquence d'octets visualisée par bv; sinon, renvoie false.

Exemple :

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

Cette fonction a été introduite dans Qt 6.0.

Voir aussi startsWith() et last().

bool QByteArray::endsWith(char ch) const

Renvoie true si ce tableau d'octets se termine par l'octet ch; sinon, renvoie false.

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

Supprime du tableau d'octets les caractères de l'intervalle semi-ouvert [ first, last ). Renvoie un itérateur vers le caractère référencé par last avant l'effacement.

Cette fonction a été introduite dans Qt 6.1.

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

Supprime le caractère indiqué par it du tableau d'octets. Renvoie un itérateur vers le caractère situé immédiatement après le caractère effacé.

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

Cette fonction a été introduite dans Qt 6.5.

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

Définit chaque octet du tableau d'octets à ch. Si size est différent de -1 (par défaut), le tableau d'octets est préalablement redimensionné à la taille size.

Exemple :

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

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

Voir aussi resize().

Renvoie les premiers n octets du tableau d'octets.

Exemple :

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

Ces fonctions ont été introduites dans Qt 6.0.

Voir aussi last(), sliced(), startsWith(), chopped(), chop(), truncate() et slice().

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

Renvoie une copie décodée du tableau Base64 base64, en utilisant les options définies par options. Si options contient IgnoreBase64DecodingErrors (par défaut), la validité de l'entrée n'est pas vérifiée ; les caractères invalides de l'entrée sont ignorés, ce qui permet au processus de décodage de continuer avec les caractères suivants. Si options contient AbortOnBase64DecodingErrors, le décodage s'arrête au premier caractère invalide.

Par exemple, l'algorithme utilisé pour décoder le code de base est le suivant

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>"

L'algorithme utilisé pour décoder les données encodées en Base64 est défini dans la RFC 4648.

Renvoie les données décodées ou, si l'option AbortOnBase64DecodingErrors a été passée et que les données d'entrée étaient invalides, un tableau d'octets vide.

Voir également toBase64() et fromBase64Encoding().

Décode le tableau Base64 base64, en utilisant les options définies par options. Si options contient IgnoreBase64DecodingErrors (par défaut), la validité de l'entrée n'est pas vérifiée ; les caractères invalides de l'entrée sont ignorés, ce qui permet au processus de décodage de continuer avec les caractères suivants. Si options contient AbortOnBase64DecodingErrors, le décodage s'arrête au premier caractère invalide.

Par exemple, l'algorithme utilisé pour décoder le code de base est le suivant

void process(const QByteArray &);

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

L'algorithme utilisé pour décoder les données encodées en Base64 est défini dans la RFC 4648.

Renvoie un objet QByteArrayFromBase64Result, contenant les données décodées et un drapeau indiquant si le décodage a réussi. Si l'option AbortOnBase64DecodingErrors a été passée et que les données d'entrée n'étaient pas valides, le contenu des données décodées n'est pas spécifié.

Voir aussi toBase64().

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

Construit un nouveau QByteArray contenant une copie du CFData data.

Voir aussi fromRawCFData(), fromRawData(), toRawCFData() et toCFData().

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

Construit un nouveau QByteArray contenant une copie du Uint8Array uint8array.

Cette fonction transfère les données d'un tampon de données JavaScript - qui n'est pas adressable à partir du code C++ - vers la mémoire du tas appartenant à un QByteArray. Le Uint8Array peut être libéré une fois que cette fonction est retournée et qu'une copie a été faite.

L'argument uint8array doit être un emscripten::val référençant un objet Uint8Array, par exemple obtenu à partir d'une variable JavaScript globale :

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

Cette fonction renvoie une valeur nulle QByteArray si la taille du tableau Uint8 dépasse la capacité maximale de QByteArray, ou si l'argument uint8array n'est pas de type tableau Uint8.

Cette fonction a été introduite dans Qt 6.5.

Voir aussi toEcmaUint8Array().

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

Renvoie une copie décodée du tableau codé en hexadécimal hexEncoded. La validité de l'entrée n'est pas vérifiée ; les caractères non valides de l'entrée sont ignorés, ce qui permet au processus de décodage de continuer avec les caractères suivants.

Par exemple :

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

Voir aussi toHex().

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

Construit un nouveau QByteArray contenant une copie de la NSData data.

Voir aussi fromRawNSData(), fromRawData(), toNSData() et toRawNSData().

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

Décode input à partir d'un codage en pourcentage de type URI/URL.

Retourne un tableau d'octets contenant le texte décodé. Le paramètre percent permet d'utiliser un caractère différent de '%' (par exemple, '_' ou '=') comme caractère d'échappement. Équivalent à l'entrée.percentDecoded(pourcentage).

Par exemple :

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

Voir aussi percentDecoded().

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

Cette fonction a été introduite dans Qt 6.11.

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

Construit un QByteArray qui utilise les octets du CFData data.

Les octets de data ne sont pas copiés.

L'appelant garantit que les données CFData ne seront ni supprimées ni modifiées tant que cet objet QByteArray existera.

Voir aussi fromCFData(), fromRawData(), toRawCFData() et toCFData().

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

Construit un QByteArray qui utilise les premiers octets size du tableau data. Les octets ne sont pas copiés. Le QByteArray contiendra le pointeur data. L'appelant garantit que data ne sera ni supprimé ni modifié tant que ce QByteArray et ses copies existent et n'ont pas été modifiés. En d'autres termes, comme QByteArray est une classe implicitement partagée et que l'instance renvoyée par cette fonction contient le pointeur data, l'appelant ne doit pas supprimer data ou la modifier directement tant que QByteArray et ses copies existent. Cependant, QByteArray n'est pas propriétaire de data, de sorte que le destructeur QByteArray ne supprimera jamais le data brut, même si le dernier QByteArray faisant référence à data est détruit.

Toute tentative ultérieure de modification du contenu du tableau QByteArray retourné ou de toute copie effectuée à partir de celui-ci entraînera la création d'une copie profonde du tableau data avant de procéder à la modification. Cela garantit que le tableau data brut ne sera jamais modifié par QByteArray.

Voici un exemple de lecture de données à l'aide de QDataStream sur des données brutes en mémoire sans copier les données brutes dans QByteArray:

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

Voir aussi setRawData(), data(), constData(), nullTerminate() et nullTerminated().

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

Construit un QByteArray qui utilise les octets du NSData data.

Les octets de data ne sont pas copiés.

L'appelant garantit que la NSData ne sera ni supprimée ni modifiée tant que cet objet QByteArray existera.

Voir aussi fromNSData(), fromRawData(), toRawNSData() et toNSData().

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

Renvoie une copie de la chaîne str sous forme de QByteArray.

Voir aussi toStdString() et QString::fromStdString().

char &QByteArray::front()

Renvoie une référence au premier octet du tableau d'octets. Identique à operator[](0).

Cette fonction est fournie pour la compatibilité STL.

Voir aussi back(), at() et operator[]().

char QByteArray::front() const

Renvoie le premier octet du tableau d'octets. Identique à at(0).

Cette fonction est fournie pour la compatibilité STL.

Voir aussi back(), at() et operator[]().

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

Renvoie la position d'index du début de la première occurrence de la séquence d'octets vue par bv dans ce tableau d'octets, en cherchant vers l'avant à partir de la position d'index from. Renvoie -1 si aucune correspondance n'est trouvée.

Exemple :

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

Cette fonction a été introduite dans Qt 6.0.

Voir aussi lastIndexOf(), contains() et count().

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

Renvoie la position d'index du début de la première occurrence de l'octet ch dans ce tableau d'octets, en effectuant une recherche vers l'avant à partir de la position d'index from. Renvoie -1 si aucune correspondance n'est trouvée.

Exemple :

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

Voir aussi lastIndexOf() et contains().

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

Insère data à la position d'index i et renvoie une référence à ce tableau d'octets.

Exemple :

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

Pour les grands tableaux d'octets, cette opération peut être lente(temps linéaire), car elle nécessite de déplacer tous les octets aux indices i et supérieurs d'au moins une position supplémentaire dans la mémoire.

Ce tableau s'agrandit pour tenir compte de l'insertion. Si i est au-delà de la fin du tableau, le tableau est d'abord étendu avec des caractères d'espacement pour atteindre i.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi append(), prepend(), replace() et remove().

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

Insère data à la position d'index i et renvoie une référence à ce tableau d'octets.

Ce tableau s'agrandit pour tenir compte de l'insertion. Si i est au-delà de la fin du tableau, le tableau est d'abord étendu avec des caractères d'espacement pour atteindre i.

Voir également append(), prepend(), replace() et remove().

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

Insère s à la position d'index i et renvoie une référence à ce tableau d'octets.

Ce tableau s'agrandit pour tenir compte de l'insertion. Si i est au-delà de la fin du tableau, le tableau est d'abord étendu avec des caractères d'espacement pour atteindre i.

Cette fonction est équivalente à insert(i, QByteArrayView(s))

Voir aussi append(), prepend(), replace() et remove().

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

Insère l'octet ch à la position d'index i dans le tableau d'octets.

Ce tableau s'agrandit pour tenir compte de l'insertion. Si i est au-delà de la fin du tableau, le tableau est d'abord étendu avec des caractères d'espacement pour atteindre i.

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

Insère len octets, en commençant par data, à la position i dans le tableau d'octets.

Ce tableau s'agrandit pour tenir compte de l'insertion. Si i est au-delà de la fin du tableau, le tableau est d'abord étendu avec des caractères d'espacement pour atteindre i.

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

Insère count copies de l'octet ch à la position d'index i dans le tableau d'octets.

Ce tableau s'agrandit pour tenir compte de l'insertion. Si i est au-delà de la fin du tableau, le tableau est d'abord étendu avec des caractères d'espacement pour atteindre i.

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

Renvoie true si le tableau d'octets a une taille de 0 ; sinon, il renvoie false.

Exemple :

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

Voir aussi size().

bool QByteArray::isLower() const

Renvoie true si ce tableau d'octets est en minuscules, c'est-à-dire s'il est identique à son pliage toLower().

Notez que cela ne signifie pas que le tableau d'octets ne contient que des lettres minuscules, mais seulement qu'il ne contient pas de lettres majuscules ASCII.

Voir aussi isUpper() et toLower().

[noexcept] bool QByteArray::isNull() const

Renvoie true si ce tableau d'octets est nul ; sinon, il renvoie false.

Exemple :

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

Qt fait une distinction entre les tableaux d'octets nuls et les tableaux d'octets vides pour des raisons historiques. Pour la plupart des applications, l'important est de savoir si un tableau d'octets contient ou non des données, ce qui peut être déterminé à l'aide de isEmpty().

Voir aussi isEmpty().

bool QByteArray::isUpper() const

Renvoie true si ce tableau d'octets est en majuscules, c'est-à-dire s'il est identique à son pliage toUpper().

Notez que cela ne signifie pas que le tableau d'octets ne contient que des lettres majuscules, mais seulement qu'il ne contient pas de lettres ASCII minuscules.

Voir aussi isLower() et toUpper().

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

Renvoie true si ce tableau d'octets contient des données encodées UTF-8 valides, ou false dans le cas contraire.

Cette fonction a été introduite dans Qt 6.3.

Renvoie les derniers n octets du tableau d'octets.

Exemple :

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

Ces fonctions ont été introduites dans Qt 6.0.

Voir aussi first(), sliced(), endsWith(), chopped(), chop(), truncate() et slice().

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

Renvoie la position d'index du début de la dernière occurrence de la séquence d'octets visualisée par bv dans ce tableau d'octets, en effectuant une recherche à rebours à partir de la position d'index from.

Si from vaut -1, la recherche commence au dernier caractère ; s'il vaut -2, à l'avant-dernier caractère, et ainsi de suite.

Retourne -1 si aucune correspondance n'est trouvée.

Exemple :

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

Cette fonction a été introduite dans Qt 6.0.

Voir aussi indexOf(), contains(), et count().

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

Renvoie la position d'index du début de la dernière occurrence de la séquence d'octets vue par bv dans ce tableau d'octets, en effectuant une recherche à rebours à partir de la fin du tableau d'octets. Retourne -1 si aucune correspondance n'est trouvée.

Exemple :

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

Cette fonction a été introduite dans Qt 6.2.

Voir aussi indexOf(), contains(), et count().

qsizetype QByteArray::lastIndexOf(char ch, qsizetype from = -1) const

Renvoie la position d'index du début de la dernière occurrence de l'octet ch dans ce tableau d'octets, en effectuant une recherche à rebours à partir de la position d'index from. Si from est égal à -1 (valeur par défaut), la recherche commence au dernier octet (à l'index size() - 1). Retourne -1 si aucune correspondance n'est trouvée.

Exemple :

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

Voir également indexOf() et contains().

Renvoie un tableau d'octets contenant les premiers len octets de ce tableau d'octets.

Si vous savez que len ne peut pas être hors limites, utilisez first() à la place dans votre nouveau code, car c'est plus rapide.

Le tableau d'octets entier est renvoyé si len est supérieur à size().

Retourne un QByteArray vide si len est plus petit que 0.

Voir aussi first(), last(), startsWith(), chopped(), chop() et truncate().

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

Renvoie un tableau d'octets de taille width qui contient ce tableau d'octets complété par l'octet fill.

Si truncate est faux et que size() du tableau d'octets est supérieur à width, le tableau d'octets renvoyé est une copie de ce tableau d'octets.

Si truncate est vrai et que size() du tableau d'octets est supérieur à width, tous les octets d'une copie du tableau d'octets après la position width sont supprimés et la copie est renvoyée.

Exemple :

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

Voir également rightJustified().

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

Identique à size().

Il renvoie le nombre maximum d'éléments que le tableau d'octets peut théoriquement contenir. En pratique, ce nombre peut être beaucoup plus petit, limité par la quantité de mémoire disponible dans le système.

Ces fonctions ont été introduites dans Qt 6.8.

Renvoie un tableau d'octets contenant len octets de ce tableau d'octets, à partir de la position pos.

Si vous savez que pos et len ne peuvent pas être hors limites, utilisez sliced() à la place dans votre nouveau code, car c'est plus rapide.

Si len est -1 (par défaut), ou si pos + len >= size(), renvoie un tableau d'octets contenant tous les octets à partir de la position pos jusqu'à la fin du tableau d'octets.

Voir aussi first(), last(), sliced(), chopped(), chop(), truncate() et slice().

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

Si les données de ce tableau d'octets ne sont pas null-terminées, cette méthode fera une copie profonde des données et les rendra null-terminées.

Un QByteArray est null-terminé par défaut, cependant dans certains cas (par exemple lors de l'utilisation de fromRawData()), les données ne se terminent pas nécessairement par un caractère \0, ce qui peut être un problème lors de l'appel de méthodes qui attendent une chaîne de caractères null-terminée (par exemple, l'API C).

Cette fonction a été introduite dans Qt 6.10.

Voir aussi nullTerminated(), fromRawData(), et setRawData().

Renvoie une copie de ce tableau d'octets dont la terminaison est toujours nulle. Voir nullTerminate().

Ces fonctions ont été introduites dans Qt 6.10.

Voir aussi nullTerminate(), fromRawData(), et setRawData().

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

Renvoie un tableau d'octets représentant le nombre entier n sous forme de texte.

Renvoie un tableau d'octets contenant une chaîne de caractères représentant n, en utilisant la valeur spécifiée base (dix par défaut). Les bases 2 à 36 sont prises en charge, en utilisant des lettres pour les chiffres au-delà de 9 : A est dix, B est onze et ainsi de suite.

Exemple :

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

Voir également setNum() et toInt().

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

Voir aussi toLong().

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

Voir aussi toLongLong().

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

Voir aussi toULongLong().

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

Voir aussi toUInt().

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

Voir aussi toULong().

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

Renvoie un tableau d'octets représentant le nombre à virgule flottante n sous forme de texte.

Renvoie un tableau d'octets contenant une chaîne de caractères représentant n, avec un format et un precision donnés, avec les mêmes significations que pour QLocale::toString(double, char, int). Par exemple, il s'agit d'une fonction surchargée :

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

Voir aussi toDouble() et QLocale::FloatingPointPrecisionOption.

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

Décode le codage en pourcentage de style URI/URL.

Retourne un tableau d'octets contenant le texte décodé. Le paramètre percent permet d'utiliser un caractère différent de '%' (par exemple, '_' ou '=') comme caractère d'échappement.

Par exemple :

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

Cette fonction a été introduite dans Qt 6.4.

Voir aussi toPercentEncoding() et QUrl::fromPercentEncoding().

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

Cette fonction a été introduite dans Qt 6.11.

QByteArray &QByteArray::prepend(QByteArrayView ba)

Prépare la vue du tableau d'octets ba à ce tableau d'octets et renvoie une référence à ce tableau d'octets.

Cette opération est généralement très rapide(temps constant), car QByteArray préaffecte de l'espace supplémentaire au début des données, ce qui lui permet de croître sans réaffecter l'ensemble du tableau à chaque fois.

Exemple :

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

C'est la même chose que insert(0, ba).

Voir également append() et insert().

QByteArray &QByteArray::prepend(char ch)

Prépare l'octet ch à ce tableau d'octets.

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

Ajoute ba à ce tableau d'octets.

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

Ajoute la chaîne '\0'-terminée str à ce tableau d'octets.

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

Ajoute à ce tableau d'octets les octets de len commençant par str. Les octets ajoutés peuvent inclure des octets '\0'.

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

Prépare count copies de l'octet ch à ce tableau d'octets.

void QByteArray::push_back(const QByteArray &other)

Cette fonction est fournie pour la compatibilité STL. Elle est équivalente à append(other).

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

Identique à append(str).

Cette fonction a été introduite dans Qt 6.0.

void QByteArray::push_back(char ch)

Identique à append(ch).

void QByteArray::push_back(const char *str)

Identique à append(str).

void QByteArray::push_front(const QByteArray &other)

Cette fonction est fournie pour la compatibilité STL. Elle est équivalente à prepend(other).

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

Identique à prepend(str).

Cette fonction a été introduite dans Qt 6.0.

void QByteArray::push_front(char ch)

Identique à prepend(ch).

void QByteArray::push_front(const char *str)

Identique à prepend(str).

QByteArray::reverse_iterator QByteArray::rbegin()

Renvoie un itérateur inversé de style STL pointant sur le premier octet du tableau d'octets, dans l'ordre inverse.

Voir aussi begin(), crbegin(), et rend().

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

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

Supprime len octets du tableau, à partir de la position d'index pos, et renvoie une référence au tableau.

Si pos est hors de portée, il ne se passe rien. Si pos est valide, mais que pos + len est plus grand que la taille du tableau, le tableau est tronqué à la position pos.

Exemple :

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

La suppression d'un élément préservera la capacité du tableau et ne réduira pas la quantité de mémoire allouée. Pour se débarrasser d'une capacité supplémentaire et libérer autant de mémoire que possible, appelez squeeze() après la dernière modification de la taille du tableau.

Voir également insert(), replace() et squeeze().

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

Supprime le caractère à l'index pos. Si pos est hors limites (c'est-à-dire pos >= size()), cette fonction ne fait rien.

Cette fonction a été introduite dans Qt 6.5.

Voir aussi remove().

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

Supprime le premier caractère de ce tableau d'octets. Si le tableau d'octets est vide, cette fonction ne fait rien.

Cette fonction a été introduite dans Qt 6.5.

Voir aussi remove().

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

Supprime du tableau d'octets tous les octets pour lesquels le prédicat pred renvoie la valeur true. Renvoie une référence au tableau d'octets.

Cette fonction a été introduite dans Qt 6.1.

Voir aussi remove().

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

Supprime le dernier caractère de ce tableau d'octets. Si le tableau d'octets est vide, cette fonction ne fait rien.

Cette fonction a été introduite dans Qt 6.5.

Voir aussi remove().

QByteArray::reverse_iterator QByteArray::rend()

Renvoie un itérateur inversé de style STL pointant juste après le dernier octet du tableau d'octets, dans l'ordre inverse.

Voir aussi end(), crend(), et rbegin().

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

QByteArray QByteArray::repeated(qsizetype times) const

Renvoie une copie de ce tableau d'octets répétant le nombre spécifié de times.

Si times est inférieur à 1, un tableau d'octets vide est renvoyé.

Exemple :

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

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

Remplace len octets à partir de la position d'index pos par le tableau d'octets after et renvoie une référence à ce tableau d'octets.

Exemple :

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

Voir aussi insert() et remove().

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

Remplace chaque occurrence du tableau d'octets before par le tableau d'octets after.

Exemple :

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

Cette fonction a été introduite dans Qt 6.0.

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

Remplace chaque occurrence de l'octet before par le tableau d'octets after.

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

Remplace chaque occurrence de l'octet before par l'octet after.

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

Remplace chaque occurrence des octets bsize commençant par before par les octets asize commençant par after. Les tailles des chaînes étant données par bsize et asize, elles peuvent contenir des octets "\0" et ne doivent pas nécessairement être terminées par "\0".

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

Remplace les octets len de la position d'index pos par des octets alen commençant à la position after. Les octets insérés peuvent inclure des octets '\0'.

void QByteArray::reserve(qsizetype size)

Tente d'allouer de la mémoire pour au moins size octets.

Si vous connaissez à l'avance la taille du tableau d'octets, vous pouvez appeler cette fonction, et si vous appelez souvent resize(), vous obtiendrez probablement de meilleures performances.

En cas de doute sur la quantité d'espace nécessaire, il est généralement préférable d'utiliser une borne supérieure comme size, ou une estimation élevée de la taille la plus probable, si une borne supérieure stricte serait beaucoup plus grande que cela. Si size est une sous-estimation, le tableau grandira selon les besoins une fois que la taille réservée sera dépassée, ce qui peut conduire à une allocation plus importante que ne l'aurait fait votre meilleure surestimation et ralentira l'opération qui la déclenche.

Le seul but de cette fonction est de fournir un moyen d'affiner l'utilisation de la mémoire par QByteArray. En général, vous n'aurez que rarement besoin d'appeler cette fonction.

Voir aussi squeeze() et capacity().

void QByteArray::resize(qsizetype size)

Fixe la taille du tableau d'octets à size octets.

Si size est supérieur à la taille actuelle, le tableau d'octets est étendu pour atteindre size octets, les octets supplémentaires étant ajoutés à la fin. Les nouveaux octets ne sont pas initialisés.

Si size est inférieur à la taille actuelle, les octets au-delà de la position size sont exclus du tableau d'octets.

Voir également size(), truncate() et squeeze().

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

Fixe la taille du tableau d'octets à newSize octets.

Si newSize est plus grand que la taille actuelle, le tableau d'octets est étendu pour atteindre newSize octets avec les octets supplémentaires ajoutés à la fin. Les nouveaux octets sont initialisés à c.

Si newSize est inférieur à la taille actuelle, les octets au-delà de la position newSize sont exclus du tableau d'octets.

Cette fonction a été introduite dans Qt 6.4.

Voir aussi size(), truncate() et squeeze().

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

Redimensionne le tableau d'octets à size octets. Si la taille du tableau d'octets augmente, les nouveaux octets ne sont pas initialisés.

Le comportement est identique à celui de resize(size).

Cette fonction a été introduite dans Qt 6.8.

Voir aussi resize().

Renvoie un tableau d'octets contenant les derniers len octets de ce tableau d'octets.

Si vous savez que len ne peut pas être hors limites, utilisez last() à la place dans votre nouveau code, car c'est plus rapide.

Le tableau d'octets entier est renvoyé si len est supérieur à size().

Retourne un QByteArray vide si len est plus petit que 0.

Voir aussi endsWith(), last(), first(), sliced(), chopped(), chop(), truncate(), et slice().

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

Renvoie un tableau d'octets de taille width qui contient l'octet fill suivi de ce tableau d'octets.

Si truncate est faux et que la taille du tableau d'octets est supérieure à width, le tableau d'octets renvoyé est une copie de ce tableau d'octets.

Si truncate est vrai et que la taille du tableau d'octets est supérieure à width, le tableau d'octets résultant est tronqué à la position width.

Exemple :

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

Voir aussi leftJustified().

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

Représenter le nombre entier n sous forme de texte.

Définit ce tableau d'octets en une chaîne représentant n en base base (dix par défaut) et renvoie une référence à ce tableau d'octets. Les bases 2 à 36 sont prises en charge, en utilisant des lettres pour les chiffres au-delà de 9 ; A est dix, B est onze et ainsi de suite.

Exemple :

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

Voir également number() et toInt().

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

Voir aussi toLong().

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

Voir aussi toLongLong().

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

Voir aussi toULongLong().

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

Voir aussi toShort().

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

Voir aussi toUInt().

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

Voir aussi toULong().

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

Voir aussi toUShort().

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

Représenter le nombre à virgule flottante n sous forme de texte.

Définit ce tableau d'octets en une chaîne de caractères représentant n, avec un format et un precision donnés (avec les mêmes significations que pour QString::number(double, char, int)), et renvoie une référence à ce tableau d'octets.

Voir aussi toDouble() et QLocale::FloatingPointPrecisionOption.

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

Représenter le nombre à virgule flottante n sous forme de texte.

Définit ce tableau d'octets en une chaîne de caractères représentant n, avec un format et un precision donnés (avec les mêmes significations que pour QString::number(double, char, int)), et renvoie une référence à ce tableau d'octets.

Voir aussi toFloat().

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

Réinitialise le site QByteArray pour qu'il utilise les premiers octets size du tableau data. Les octets ne sont pas copiés. Le site QByteArray contiendra le pointeur data. L'appelant garantit que data ne sera pas supprimé ou modifié tant que ce QByteArray et ses copies existent et n'ont pas été modifiés.

Cette fonction peut être utilisée à la place de fromRawData() pour réutiliser des objets QByteArray existants afin d'éviter les réallocations de mémoire.

Voir également fromRawData(), data(), constData(), nullTerminate() et nullTerminated().

void QByteArray::shrink_to_fit()

Cette fonction est fournie pour la compatibilité STL. Elle est équivalente à squeeze().

QByteArray QByteArray::simplified() const

Renvoie une copie de ce tableau d'octets dont les caractères d'espacement ont été supprimés au début et à la fin, et dans lequel chaque séquence de caractères d'espacement internes est remplacée par un espace unique.

Les caractères d'espacement sont ceux pour lesquels la fonction standard C++ isspace() renvoie true dans la locale C ; il s'agit des caractères ASCII tabulation '\t', saut de ligne '\n', retour chariot '\r', tabulation verticale '\v', saut de forme '\f', et espace ' '.

Exemple :

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

Voir aussi trimmed(), QChar::SpecialCharacter, et Spacing Characters.

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

Renvoie le nombre d'octets dans ce tableau d'octets.

Le dernier octet du tableau d'octets se trouve à la position size() - 1. En outre, QByteArray s'assure que l'octet à la position size() est toujours '\0', de sorte que vous puissiez utiliser la valeur de retour de data() et constData() comme arguments pour les fonctions qui attendent des chaînes terminées '\0'. Si l'objet QByteArray a été créé à partir d'un objet raw data qui n'incluait pas l'octet de terminaison '\0', QByteArray ne l'ajoute pas automatiquement, à moins qu'une copie profonde ne soit créée.

Exemple :

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

Voir également isEmpty() et resize().

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

Modifie ce tableau d'octets pour qu'il commence à la position pos, s'étend pour n octets, et renvoie une référence à ce tableau d'octets.

Exemple :

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

Cette fonction a été introduite dans Qt 6.8.

Voir aussi sliced(), first(), last(), chopped(), chop() et truncate().

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

Modifie ce tableau d'octets pour qu'il commence à la position pos, en l'étendant jusqu'à sa fin, et renvoie une référence à ce tableau d'octets.

Cette fonction a été introduite dans Qt 6.8.

Voir aussi sliced(), first(), last(), chopped(), chop() et truncate().

Renvoie un tableau d'octets contenant les n octets de cet objet à partir de la position pos.

Exemple :

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

Ces fonctions ont été introduites dans Qt 6.0.

Voir aussi first(), last(), chopped(), chop(), truncate() et slice().

Renvoie un tableau d'octets contenant les octets commençant à la position pos dans cet objet et s'étendant jusqu'à la fin de cet objet.

Ces fonctions ont été introduites dans Qt 6.0.

Voir également first(), last(), chopped(), chop(), truncate() et slice().

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

Divise le tableau d'octets en sous-ensembles à chaque fois que sep apparaît, et renvoie la liste de ces tableaux. Si sep ne correspond à aucun élément du tableau d'octets, split() renvoie une liste à un seul élément contenant ce tableau d'octets.

void QByteArray::squeeze()

Libère toute la mémoire qui n'est pas nécessaire pour stocker les données du tableau.

Le seul but de cette fonction est de fournir un moyen d'affiner l'utilisation de la mémoire de QByteArray. En général, vous n'aurez que rarement besoin d'appeler cette fonction.

Voir aussi reserve() et capacity().

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

Renvoie true si ce tableau d'octets commence par la séquence d'octets visualisée par bv; sinon, renvoie false.

Exemple :

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

Cette fonction a été introduite dans Qt 6.0.

Voir aussi endsWith() et first().

bool QByteArray::startsWith(char ch) const

Renvoie true si ce tableau d'octets commence par l'octet ch; sinon, renvoie false.

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

Échange ce tableau d'octets avec other. Cette opération est très rapide et n'échoue jamais.

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

Renvoie une copie du tableau d'octets, encodé à l'aide des options options.

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"

L'algorithme utilisé pour coder les données encodées en Base64 est défini dans la RFC 4648.

Voir aussi fromBase64().

CFDataRef QByteArray::toCFData() const

Crée un CFData à partir d'un QByteArray.

L'appelant est propriétaire de l'objet CFData et est responsable de sa libération.

Voir aussi toRawCFData(), fromCFData(), fromRawCFData() et fromRawData().

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

Renvoie le tableau d'octets converti en une valeur double.

Renvoie une infinité si la conversion déborde ou 0.0 si la conversion échoue pour d'autres raisons (par exemple, un débordement).

Si ok n'est pas nullptr, l'échec est signalé par l'affectation de *ok à false, et la réussite par l'affectation de *ok à true.

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

Cette fonction ignore les espaces blancs de début et de fin.

Voir aussi number().

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

Crée un tableau Uint8 à partir d'un QByteArray.

Cette fonction transfère des données de la mémoire vive appartenant à QByteArray vers un tampon de données JavaScript. La fonction alloue et copie dans un ArrayBuffer, et renvoie une vue Uint8Array sur ce tampon.

Les objets JavaScript possèdent une copie des données, et cette QByteArray peut être supprimée en toute sécurité une fois la copie effectuée.

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

Cette fonction a été introduite dans Qt 6.5.

Voir aussi fromEcmaUint8Array().

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

Renvoie le tableau d'octets converti en valeur float.

Renvoie une infinité si la conversion déborde ou 0.0 si la conversion échoue pour d'autres raisons (par exemple, un débordement).

Si ok n'est pas nullptr, l'échec est signalé par l'affectation de *ok à false, et la réussite par l'affectation de *ok à true.

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

Cette fonction ignore les espaces blancs de début et de fin.

Voir aussi number().

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

Renvoie une copie codée en hexadécimal du tableau d'octets.

Le codage hexadécimal utilise les chiffres de 0 à 9 et les lettres de a à f.

Si separator n'est pas '\0', le caractère de séparation est inséré entre les octets hexagonaux.

Exemple :

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

Voir aussi fromHex().

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

Renvoie le tableau d'octets converti en int en utilisant la base base, qui est dix par défaut. Les bases 0 et 2 à 36 sont supportées, en utilisant des lettres pour les chiffres au-delà de 9 ; A est dix, B est onze et ainsi de suite.

Si base vaut 0, la base est déterminée automatiquement à l'aide des règles suivantes : Si le tableau d'octets commence par "0x", il est supposé être hexadécimal (base 16) ; sinon, s'il commence par "0b", il est supposé être binaire (base 2) ; sinon, s'il commence par "0", il est supposé être octal (base 8) ; sinon, il est supposé être décimal.

Retourne 0 si la conversion échoue.

Si ok n'est pas nullptr, l'échec est signalé par la définition de *ok à false, et la réussite par la définition de *ok à 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

Voir aussi number().

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

Renvoie le tableau d'octets converti en long int en utilisant la base base, qui est dix par défaut. Les bases 0 et 2 à 36 sont supportées, en utilisant des lettres pour les chiffres au-delà de 9 ; A est dix, B est onze et ainsi de suite.

Si base vaut 0, la base est déterminée automatiquement à l'aide des règles suivantes : Si le tableau d'octets commence par "0x", il est supposé être hexadécimal (base 16) ; sinon, s'il commence par "0b", il est supposé être binaire (base 2) ; sinon, s'il commence par "0", il est supposé être octal (base 8) ; sinon, il est supposé être décimal.

Retourne 0 si la conversion échoue.

Si ok n'est pas nullptr, l'échec est signalé par la définition de *ok à false, et la réussite par la définition de *ok à true.

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

Voir aussi number().

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

Renvoie le tableau d'octets converti en long long en utilisant la base base, qui est dix par défaut. Les bases 0 et 2 à 36 sont supportées, en utilisant des lettres pour les chiffres au-delà de 9 ; A est dix, B est onze et ainsi de suite.

Si base vaut 0, la base est déterminée automatiquement à l'aide des règles suivantes : Si le tableau d'octets commence par "0x", il est supposé être hexadécimal (base 16) ; sinon, s'il commence par "0b", il est supposé être binaire (base 2) ; sinon, s'il commence par "0", il est supposé être octal (base 8) ; sinon, il est supposé être décimal.

Retourne 0 si la conversion échoue.

Si ok n'est pas nullptr, l'échec est signalé par la définition de *ok à false, et la réussite par la définition de *ok à true.

Voir aussi number().

QByteArray QByteArray::toLower() const

Renvoie une copie du tableau d'octets dans lequel chaque lettre ASCII majuscule a été convertie en minuscule.

Exemple :

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

Voir aussi isLower(), toUpper() et Character Case.

NSData *QByteArray::toNSData() const

Crée un NSData à partir d'un QByteArray.

L'objet NSData est libéré automatiquement.

Voir aussi fromNSData(), fromRawNSData(), fromRawData() et toRawNSData().

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

Renvoie une copie codée en pourcentage de ce tableau d'octets, dans le style URI/URL. Le paramètre percent vous permet de remplacer le caractère '%' par défaut par un autre.

Par défaut, cette fonction encode tous les octets qui ne sont pas de l'un des types suivants :

ALPHA ("a" à "z" et "A" à "Z") / DIGIT (0 à 9) / "-" / "." / "_" / "~"

Pour empêcher l'encodage des octets, passez-les à exclude. Pour forcer l'encodage des octets, passez-les à include. Le caractère percent est toujours encodé.

Exemple :

QByteArray text = "{une chaîne de caractères douteuse?}";QByteArray ba = text.toPercentEncoding("{}", "s") ;qDebug("%s", ba.constData());
// imprime "{a fi%73hy %73tring%3F}"

Le codage hexadécimal utilise les chiffres de 0 à 9 et les lettres majuscules de A à F.

Voir aussi fromPercentEncoding() et QUrl::toPercentEncoding().

CFDataRef QByteArray::toRawCFData() const

Construit un CFData qui utilise les octets de QByteArray.

Les octets de QByteArray ne sont pas copiés.

L'appelant garantit que l'adresse QByteArray ne sera ni supprimée ni modifiée tant que cet objet CFData existera.

Voir aussi toCFData(), fromRawCFData(), fromCFData() et fromRawData().

NSData *QByteArray::toRawNSData() const

Construit un NSData qui utilise les octets de QByteArray.

Les octets de QByteArray ne sont pas copiés.

L'appelant garantit que le QByteArray ne sera ni supprimé ni modifié tant que cet objet NSData existera.

Voir aussi fromRawNSData(), fromNSData(), fromRawData() et toNSData().

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

Renvoie le tableau d'octets converti en short en utilisant la base base, qui est dix par défaut. Les bases 0 et 2 à 36 sont supportées, en utilisant des lettres pour les chiffres au-delà de 9 ; A est dix, B est onze et ainsi de suite.

Si base vaut 0, la base est déterminée automatiquement à l'aide des règles suivantes : Si le tableau d'octets commence par "0x", il est supposé être hexadécimal (base 16) ; sinon, s'il commence par "0b", il est supposé être binaire (base 2) ; sinon, s'il commence par "0", il est supposé être octal (base 8) ; sinon, il est supposé être décimal.

Retourne 0 si la conversion échoue.

Si ok n'est pas nullptr, l'échec est signalé par la définition de *ok à false, et la réussite par la définition de *ok à true.

Voir aussi number().

std::string QByteArray::toStdString() const

Renvoie un objet std::string avec les données contenues dans cette QByteArray.

Cet opérateur est surtout utile pour passer un QByteArray à une fonction qui accepte un objet std::string.

Voir aussi fromStdString() et QString::toStdString().

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

Renvoie le tableau d'octets converti en unsigned int en utilisant la base base, qui est dix par défaut. Les bases 0 et 2 à 36 sont supportées, en utilisant des lettres pour les chiffres au-delà de 9 ; A est dix, B est onze et ainsi de suite.

Si base vaut 0, la base est déterminée automatiquement à l'aide des règles suivantes : Si le tableau d'octets commence par "0x", il est supposé être hexadécimal (base 16) ; sinon, s'il commence par "0b", il est supposé être binaire (base 2) ; sinon, s'il commence par "0", il est supposé être octal (base 8) ; sinon, il est supposé être décimal.

Retourne 0 si la conversion échoue.

Si ok n'est pas nullptr, l'échec est signalé par la définition de *ok à false, et la réussite par la définition de *ok à true.

Voir aussi number().

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

Renvoie le tableau d'octets converti en unsigned long int en utilisant la base base, qui est dix par défaut. Les bases 0 et 2 à 36 sont supportées, en utilisant des lettres pour les chiffres au-delà de 9 ; A est dix, B est onze et ainsi de suite.

Si base vaut 0, la base est déterminée automatiquement à l'aide des règles suivantes : Si le tableau d'octets commence par "0x", il est supposé être hexadécimal (base 16) ; sinon, s'il commence par "0b", il est supposé être binaire (base 2) ; sinon, s'il commence par "0", il est supposé être octal (base 8) ; sinon, il est supposé être décimal.

Retourne 0 si la conversion échoue.

Si ok n'est pas nullptr, l'échec est signalé par la définition de *ok à false, et la réussite par la définition de *ok à true.

Voir aussi number().

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

Renvoie le tableau d'octets converti en unsigned long long en utilisant la base base, qui est dix par défaut. Les bases 0 et 2 à 36 sont supportées, en utilisant des lettres pour les chiffres au-delà de 9 ; A est dix, B est onze et ainsi de suite.

Si base vaut 0, la base est déterminée automatiquement à l'aide des règles suivantes : Si le tableau d'octets commence par "0x", il est supposé être hexadécimal (base 16) ; sinon, s'il commence par "0b", il est supposé être binaire (base 2) ; sinon, s'il commence par "0", il est supposé être octal (base 8) ; sinon, il est supposé être décimal.

Retourne 0 si la conversion échoue.

Si ok n'est pas nullptr, l'échec est signalé par la définition de *ok à false, et la réussite par la définition de *ok à true.

Voir aussi number().

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

Renvoie le tableau d'octets converti en unsigned short en utilisant la base base, qui est dix par défaut. Les bases 0 et 2 à 36 sont supportées, en utilisant des lettres pour les chiffres au-delà de 9 ; A est dix, B est onze et ainsi de suite.

Si base vaut 0, la base est déterminée automatiquement à l'aide des règles suivantes : Si le tableau d'octets commence par "0x", il est supposé être hexadécimal (base 16) ; sinon, s'il commence par "0b", il est supposé être binaire (base 2) ; sinon, s'il commence par "0", il est supposé être octal (base 8) ; sinon, il est supposé être décimal.

Retourne 0 si la conversion échoue.

Si ok n'est pas nullptr, l'échec est signalé par la définition de *ok à false, et la réussite par la définition de *ok à true.

Voir aussi number().

QByteArray QByteArray::toUpper() const

Renvoie une copie du tableau d'octets dans lequel chaque lettre ASCII minuscule a été convertie en majuscule.

Exemple :

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

Voir aussi isUpper(), toLower() et Character Case.

QByteArray QByteArray::trimmed() const

Renvoie une copie de ce tableau d'octets dont les caractères d'espacement ont été supprimés au début et à la fin.

Les caractères d'espacement sont ceux pour lesquels la fonction standard C++ isspace() renvoie true dans la locale C ; il s'agit des caractères ASCII tabulation '\t', saut de ligne '\n', retour chariot '\r', tabulation verticale '\v', saut de forme '\f', et espace ' '.

Exemple :

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

Contrairement à simplified(), trimmed() laisse l'espacement interne inchangé.

Voir également simplified(), QChar::SpecialCharacter, et Spacing Characters.

void QByteArray::truncate(qsizetype pos)

Tronque le tableau d'octets à la position d'index pos.

Si pos est au-delà de la fin du tableau, rien ne se passe.

Exemple :

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

Voir aussi chop(), resize() et first().

Renvoie un pointeur sur les données stockées dans le tableau d'octets. Le pointeur peut être utilisé pour accéder aux octets qui composent le tableau. Les données sont terminées par '\0'.

Le pointeur reste valide tant qu'il n'y a pas de détachement et que le site QByteArray n'est pas modifié.

Cet opérateur est surtout utile pour passer un tableau d'octets à une fonction qui accepte un const char *.

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_BYTEARRAY lors de la compilation de vos applications.

Remarque : un QByteArray peut stocker n'importe quelle valeur d'octet, y compris des '\0', mais la plupart des fonctions qui prennent des arguments char * supposent que les données se terminent au premier '\0' qu'elles rencontrent.

Voir également constData().

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

Convertit cet objet QByteArray en un objet std::string_view. La vue de la chaîne renvoyée couvrira la totalité du tableau d'octets.

Cette fonction a été introduite dans Qt 6.10.

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

Ajoute le tableau d'octets ba à la fin de ce tableau d'octets et renvoie une référence à ce tableau d'octets.

Exemple :

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

Remarque : QByteArray est une classe implicitement partagée. Par conséquent, si vous ajoutez un tableau d'octets vide, le tableau d'octets partagera simplement les données contenues dans ba. Dans ce cas, aucune copie de données n'est effectuée, ce qui prend un temps constant. Si une instance partagée est modifiée, elle sera copiée (copy-on-write), ce qui prend un temps linéaire.

Si le tableau d'octets auquel il est ajouté n'est pas vide, une copie profonde des données est effectuée, en un temps linéaire.

Cette opération ne souffre généralement pas de surcharge d'allocation, car QByteArray préaffecte de l'espace supplémentaire à la fin des données afin qu'elles puissent croître sans avoir à être réaffectées à chaque opération d'ajout.

Voir également append() et prepend().

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

Ajoute l'octet ch à la fin de ce tableau d'octets et renvoie une référence à ce tableau d'octets.

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

Ajoute la chaîne '\0'-terminée str à la fin de ce tableau d'octets et renvoie une référence à ce tableau d'octets.

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

Move-assigne other à cette instance QByteArray.

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

Affecte other à ce tableau d'octets et renvoie une référence à ce tableau d'octets.

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

Affecte str à ce tableau d'octets.

str est supposé pointer vers une chaîne de caractères à terminaison nulle, et sa longueur est déterminée dynamiquement.

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

Renvoie l'octet à la position d'index i sous la forme d'une référence modifiable.

i doit être une position d'index valide dans le tableau d'octets (c'est-à-dire 0 <= i < size()).

Exemple :

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

Voir aussi at().

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

Identique à at(i).