QByteArray Class

Documentation des fonctions membres

[constexpr noexcept] QByteArray::QByteArray()

Crée un tableau d'octets vide.

Voir aussi isEmpty().

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

Crée un tableau d'octets initialisé avec les données de la vue de 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)

Crée un tableau d'octets contenant les size premiers octets du tableau data.

Si data est égal à 0, un tableau d’octets nul est créé.

Si size est négatif, data est supposé pointer vers une chaîne terminée par «\0 » et sa longueur est déterminée dynamiquement.

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

Voir également fromRawData().

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

Crée 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)

Crée un tableau d'octets de taille size, chaque octet étant défini sur ch.

Voir aussi fill().

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

Crée une copie de ` other`.

Cette opération s'effectue en temps constant, car QByteArray est implicitement partagé. Cela rend très rapide le retour d'un QByteArray depuis une fonction. Si une instance partagée est modifiée, elle sera copiée (copie à l'écriture), ce qui prend un temps linéaire.

Voir également operator=().

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

Crée une instance de `QByteArray` par copie, de sorte qu'elle pointe vers le même objet que celui vers lequel poin other.

[noexcept] QByteArray::~QByteArray()

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

Cela revient à utiliser insert(size(), ba).

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

Si le tableau d’octets auquel on ajoute des éléments 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éalloue de l’espace supplémentaire à la fin des données, ce qui lui permet de s’étendre sans avoir à réallouer l’intégralité 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'ch d'octets à ce tableau d'octets.

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

Ajoute la chaîne «\0 », terminée par un « ' », str à ce tableau d'octets.

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

Ajoute les premiers len octets, à partir de l'adresse 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 terminée par «\0 » et la longueur à copier sera déterminée automatiquement à l’aide de la fonction ` qstrlen()`.

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

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

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

Si count est négatif ou égal à zéro, 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 à celle 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 la plage 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 compris dans l’intervalle [first, last).

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

Contraintes

Ne participe à la résolution des surcharges que 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 un nombre 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 également fill().

char QByteArray::at(qsizetype i) const

Renvoie l'octet situé à l'index i dans le tableau d'octets.

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

Voir également operator[]().

char &QByteArray::back()

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

Cette fonction est fournie à des fins de compatibilité avec la STL.

Voir également front(), at() et operator[]().

char QByteArray::back() const

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

Cette fonction est fournie à des fins de compatibilité avec la STL.

Voir également front(), at() et operator[]().

QByteArray::iterator QByteArray::begin()

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

Voir également ` constBegin()` et ` end()`.

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

qsizetype QByteArray::capacity() const

Renvoie le nombre maximal d'octets pouvant être stockés dans le tableau d'octets sans nécessiter de réallocation.

Cette fonction a pour seul but de permettre un réglage fin de l'utilisation de la mémoire par QByteArray. En général, vous n'aurez que très rarement besoin d'appeler cette fonction. Si vous souhaitez connaître le nombre d'octets contenus dans le tableau d'octets, appelez size().

Voir également reserve() et squeeze().

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

Renvoie un itérateur de type STL de type const pointant vers le premier octet du tableau d'octets.

Voir également ` begin()` et ` cend()`.

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

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

Voir également ` cbegin()` et ` end()`.

void QByteArray::chop(qsizetype n)

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

Si la valeur de ` n ` est supérieure à ` 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 situés le plus à gauche de ce tableau d'octets, à savoir : size() - len.

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

void QByteArray::clear()

Efface le contenu du tableau d'octets et le remet à zéro.

Voir également resize() et isNull().

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

Renvoie un entier inférieur, égal ou supérieur à zéro selon que cette QByteArray se situe avant, à la même position ou après la QByteArrayView bv . La comparaison tient compte de 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 de type STL constant pointant vers le premier octet du tableau d'octets.

Voir également ` begin()` et ` constEnd()`.

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

Renvoie un pointeur vers les données constantes stockées dans le tableau d'octets. Ce pointeur permet d'accéder aux octets qui composent le tableau. Les données sont terminées par «\0 », sauf si l'objet ` QByteArray ` a été créé à partir de données brutes.

Le pointeur reste valide tant qu’aucun détachement n’a lieu et que l’objet ` QByteArray ` n’est pas modifié.

Cette fonction est principalement utile pour transmettre 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 prenant des arguments de type « char * » supposent que les données se terminent au premier «\0 » rencontré.

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

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

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

Voir également ` 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 analysée par « bv » ; sinon, renvoie « false ».

Cette fonction a été introduite dans Qt 6.0.

Voir également 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 analysée par la fonction ` bv ` dans ce tableau d’octets.

Cette fonction a été introduite dans Qt 6.0.

Voir également ` contains()` et ` indexOf()`.

qsizetype QByteArray::count(char ch) const

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

Voir également ` contains()` et ` indexOf()`.

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

Renvoie un itérateur inversé de type STL (const) pointant vers le premier octet du tableau d'octets, dans l'ordre inverse.

Voir également ` begin()`, ` rbegin()` et ` rend()`.

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

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

Voir également ` end()`, ` rend()` et ` rbegin()`.

char *QByteArray::data()

Renvoie un pointeur vers les données stockées dans le tableau d'octets. Ce pointeur peut être utilisé pour accéder aux octets qui composent le tableau et les modifier. Les données sont terminées par «\0 », c'est-à-dire que le nombre d'octets accessibles à partir du pointeur renvoyé est égal à size() + 1, y compris le caractère de fin «\0 ».

Exemple :

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

Le pointeur reste valide tant qu’aucun détachement n’a lieu et que la chaîne « QByteArray » n’est pas modifiée.

Pour un accès en lecture seule, la fonction ` constData()` est plus rapide car elle ne provoque 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 effectue une copie du char* renvoyé par data(), mais il va corrompre le tas et provoquer un plantage 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é d’espace correcte :

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 les «\0 », mais la plupart des fonctions qui prennent des arguments de type 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 type STL pointant juste après le dernier octet du tableau d'octets.

Voir également ` 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 décrite à l'adresse 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 également 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 de le tableau d'octets les caractères compris dans l'intervalle semi-ouvert [ first, last ). Renvoie un itérateur pointant vers le caractère référencé par last avant la suppression.

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 pointant vers le caractère situé immédiatement après celui qui a été supprimé.

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 sur la valeur ` ch`. Si la valeur de ` size ` est différente de -1 (valeur 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 n premiers 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 également 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 (valeur par défaut), 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 se poursuivre avec les caractères suivants. Si options contient AbortOnBase64DecodingErrors, le décodage s'arrête dès le premier caractère non valide.

Par exemple :

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é fournie 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 (valeur par défaut), 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 se poursuivre avec les caractères suivants. Si options contient AbortOnBase64DecodingErrors, le décodage s'arrête dès le premier caractère non valide.

Par exemple :

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 indicateur précisant si le décodage a réussi. Si l’option AbortOnBase64DecodingErrors a été fournie et que les données d’entrée étaient invalides, le contenu des données décodées n’est pas spécifié.

Voir également toBase64().

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

Crée un nouvel objet ` QByteArray ` contenant une copie de l'objet `CFData` ` data`.

Voir également fromRawCFData(), fromRawData(), toRawCFData() et toCFData().

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

Crée un nouvel objet ` QByteArray ` contenant une copie de l'`Uint8Array` ` uint8array`.

Cette fonction transfère des données depuis un tampon de données JavaScript — qui n’est pas accessible depuis le code C++ — vers la mémoire du tas gérée par un objet ` QByteArray`. L’objet `Uint8Array` peut être libéré une fois que cette fonction a renvoyé une valeur et qu’une copie a été effectuée.

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

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

Cette fonction renvoie un QByteArray nul si la taille de l’Uint8Array dépasse la capacité maximale de l’ QByteArray, ou si l’argument uint8array n’est pas de type Uint8Array.

Cette fonction a été introduite dans Qt 6.5.

Voir également ` toEcmaUint8Array()`.

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

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

Par exemple :

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

Voir également toHex().

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

Crée un nouvel objet ` QByteArray ` contenant une copie de l'objet `NSData` ` data`.

Voir également fromRawNSData(), fromRawData(), toNSData() et toRawNSData().

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

Décode les données de type « input » à partir d'un encodage en pourcentage au format URI/URL.

Renvoie 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 à `input.percentDecoded` (pourcent).

Par exemple :

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

Voir également 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)

Crée un objet ` QByteArray ` qui utilise les octets de l'objet `CFData` data.

dataLes octets de l’ ne sont pas copiés.

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

Voir également fromCFData(), fromRawData(), toRawCFData() et toCFData().

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

Construit un objet ` QByteArray ` qui utilise les ` size ` premiers octets 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 cet objet ` QByteArray ` et toutes ses copies non modifiées existeront. En d’autres termes, étant donné que 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 ni le modifier directement tant que l’instance QByteArray renvoyée et ses copies existent. Cependant, QByteArray ne prend pas possession de data; par conséquent, le destructeur QByteArray ne supprimera jamais l’objet brut data, même lorsque le dernier QByteArray faisant référence à data est détruit.

Toute tentative ultérieure de modification du contenu de l’objet QByteArray renvoyé ou de toute copie qui en a été faite entraînera la création d’une copie profonde du tableau data avant que la modification ne soit effectuée. Cela garantit que le tableau brut data lui-même ne sera jamais modifié par QByteArray.

Voici un exemple illustrant comment lire des données à l’aide d’un ` QDataStream ` sur des données brutes en mémoire sans copier ces dernières dans un ` 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 également setRawData(), data(), constData(), nullTerminate() et nullTerminated().

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

Crée un objet ` QByteArray ` qui utilise les octets de l'data` de type `NSData`.

dataLes octets de l'objet `NSData` ne sont pas copiés.

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

Voir également fromNSData(), fromRawData(), toRawNSData() et toNSData().

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

Renvoie une copie de la chaîne « str » sous la forme d'un objet « QByteArray ».

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

char &QByteArray::front()

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

Cette fonction est fournie à des fins de compatibilité avec la STL.

Voir également back(), at() et operator[]().

char QByteArray::front() const

Renvoie le premier octet du tableau d'octets. Équivalent à ` at(0)`.

Cette fonction est fournie à des fins de compatibilité avec la STL.

Voir également back(), at() et operator[]().

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

Renvoie l'index du début de la première occurrence de la séquence d'octets analysée par ` bv ` dans ce tableau d'octets, en effectuant une recherche vers l'avant à partir de l'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 également lastIndexOf(), contains() et count().

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

Renvoie l'index du début de la première occurrence de l'ch de l'octet dans ce tableau d'octets, en effectuant une recherche vers l'avant à partir de l'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 également lastIndexOf() et contains().

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

Insère « data » à l'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 situés aux index i et supérieurs d’au moins une position plus loin dans la mémoire.

Ce tableau s'agrandit pour accueillir l'insertion. Si i se trouve au-delà de la fin du tableau, celui-ci est d'abord étendu avec des caractères d'espacement pour atteindre cette position i.

Cette fonction a été introduite dans Qt 6.0.

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

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

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

Ce tableau s'agrandit pour accueillir l'insertion. Si i se trouve au-delà de la fin du tableau, celui-ci est d'abord étendu avec des caractères d'espacement pour atteindre cette position i.

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

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

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

Ce tableau s'agrandit pour accueillir l'insertion. Si i se trouve au-delà de la fin du tableau, celui-ci est d'abord prolongé par des caractères d'espacement afin d'atteindre cette position i.

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

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

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

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

Ce tableau s’agrandit pour accueillir l’insertion. Si i se trouve au-delà de la fin du tableau, celui-ci est d’abord étendu avec des caractères d’espacement pour atteindre cette position i.

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

Insère len octets, à partir de data, à la position i dans le tableau d'octets.

Ce tableau s'agrandit pour accueillir l'insertion. Si i se trouve au-delà de la fin du tableau, celui-ci est d'abord étendu avec des caractères d'espacement pour atteindre cette adresse i.

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

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

Ce tableau s'agrandit pour accueillir l'insertion. Si i se trouve au-delà de la fin du tableau, celui-ci est d'abord étendu avec des caractères d'espacement pour atteindre cet i.

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

Renvoie « true » si la taille du tableau d'octets est égale à 0 ; sinon, 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 résultat après application de la fonction ` toLower()`.

Notez que cela ne signifie pas que le tableau d’octets ne contient que des lettres minuscules, mais simplement qu’il ne contient aucune lettre majuscule ASCII.

Voir également isUpper() et toLower().

[noexcept] bool QByteArray::isNull() const

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

Exemple :

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

Qt fait la distinction entre les tableaux d'octets nuls et les tableaux d'octets vides pour des raisons historiques. Pour la plupart des applications, ce qui importe, c'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 également isEmpty().

bool QByteArray::isUpper() const

Renvoie ` true ` si ce tableau d'octets est en majuscules, c'est-à-dire s'il est identique à son résultat après application de la fonction ` toUpper()`.

Notez que cela ne signifie pas que le tableau d’octets ne contient que des lettres majuscules, mais simplement qu’il ne contient aucune lettre minuscule ASCII.

Voir également isLower() et toUpper().

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

Renvoie « true » si ce tableau d'octets contient des données valides encodées en UTF-8, 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 également first(), sliced(), endsWith(), chopped(), chop(), truncate() et slice().

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

Renvoie l'index du début de la dernière occurrence de la séquence d'octets analysée par ` bv ` dans ce tableau d'octets, en effectuant une recherche vers l'arrière à partir de l'index ` from`.

Si from est égal à -1, la recherche commence au dernier caractère ; s’il est égal à -2, elle commence à l’avant-dernier caractère, et ainsi de suite.

Renvoie -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 également indexOf(), contains() et count().

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

Renvoie l'index correspondant au début de la dernière occurrence de la séquence d'octets analysée par la fonction ` bv ` dans ce tableau d'octets, en effectuant une recherche vers l'arrière à partir de la fin du tableau. Renvoie -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 également indexOf(), contains() et count().

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

Renvoie l'index du début de la dernière occurrence de l'ch d'octets dans ce tableau d'octets, en effectuant une recherche vers l'arrière à partir de l'index from. Si from est égal à -1 (valeur par défaut), la recherche commence à partir du dernier octet (à l'index size() - 1). Renvoie -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 len premiers octets de ce tableau d'octets.

Si vous savez que len ne peut pas être hors limites, utilisez plutôt first() dans votre nouveau code, car cette fonction est plus rapide.

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

QByteArray Renvoie un tableau de bytes vide si len est inférieur à 0.

Voir également 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 contenant ce tableau d'octets complété par l'octet fill.

Si truncate est faux et que la valeur de size() du tableau d’octets est supérieure à width, alors le tableau d’octets renvoyé est une copie de ce tableau d’octets.

Si truncate est vrai et que la valeur de size() du tableau d’octets est supérieure à width, tous les octets de la copie du tableau d’octets situés après la position width sont supprimés, puis la copie est renvoyée.

Exemple :

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

Voir aussi rightJustified().

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

Identique à ` size()`.

Elle renvoie le nombre maximal d'éléments que le tableau d'octets peut théoriquement contenir. En pratique, ce nombre peut être bien inférieur, car il est limité par la quantité de mémoire disponible sur 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 plutôt sliced() dans votre nouveau code, car cette méthode est plus rapide.

Si len est égal à -1 (valeur par défaut), ou si pos + len est supérieur ou égal à size(), la fonction renvoie un tableau d’octets contenant tous les octets situés entre la position pos et la fin du tableau d’octets.

Voir également 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 terminées par un caractère nul, cette méthode effectuera une copie profonde des données et les terminera par un caractère nul.

Un tableau de chaînes de caractères ( QByteArray ) est terminé par un caractère null 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 poser problème lors de l'appel de méthodes qui attendent une chaîne terminée par un caractère null (par exemple, l'API C).

Cette fonction a été introduite dans Qt 6.10.

Voir également nullTerminated(), fromRawData() et setRawData().

Renvoie une copie de ce tableau d'octets qui est toujours terminée par un caractère nul. Voir nullTerminate().

Ces fonctions ont été introduites dans Qt 6.10.

Voir également 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 chaîne de caractères.

Renvoie un tableau d'octets contenant une chaîne de caractères représentant n, en utilisant la base spécifiée base (dix par défaut). Les bases comprises entre 2 et 36 sont prises en charge, les lettres étant utilisées pour les chiffres supérieurs à 9 : A correspond à dix, B à 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 également toLongLong().

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

Voir également toULongLong().

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

Voir également toUInt().

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

Voir également 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 chaîne de caractères.

Renvoie un tableau d’octets contenant une chaîne de caractères représentant n, avec une format et une precision données, dont les significations sont identiques à celles de QLocale::toString(double, char, int). Par exemple :

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

Voir également toDouble() et QLocale::FloatingPointPrecisionOption.

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

Décode l'encodage en pourcentage de type URI/URL.

Renvoie 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 également 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)

Ajoute la vue du tableau d'octets ba au début de 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éalloue de l'espace supplémentaire au début des données, ce qui permet à celles-ci de s'étendre sans avoir à réallouer l'intégralité du tableau à chaque fois.

Exemple :

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

Cela revient à appeler insert(0, ba).

Voir également append() et insert().

QByteArray &QByteArray::prepend(char ch)

Ajoute l'ch d'octets au début de ce tableau d'octets.

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

Ajoute « ba » au début de ce tableau d'octets.

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

Ajoute au début de ce tableau d'octets la chaîne «\0 », terminée par « ' » str.

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

Ajoute à cet tableau d'octets les octets de la chaîne « len » à partir de l'adresse « str ». Les octets ajoutés peuvent inclure des octets « '\0 ».

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

Ajoute à cet tableau d'octets count copies de l'ch.

void QByteArray::push_back(const QByteArray &other)

Cette fonction est fournie à des fins de compatibilité avec la STL. Elle équivaut à `append(other)`.

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

Equivalent à append(str).

Cette fonction a été introduite dans Qt 6.0.

void QByteArray::push_back(char ch)

Equivalent à append(ch).

void QByteArray::push_back(const char *str)

Equivalent à append(str).

void QByteArray::push_front(const QByteArray &other)

Cette fonction est fournie à des fins de compatibilité avec la STL. Elle équivaut à `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 type STL pointant vers le premier octet du tableau d'octets, dans l'ordre inverse.

Voir également 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 l'index pos, et renvoie une référence au tableau.

Si pos est hors de la plage autorisée, rien ne se passe. Si pos est valide, mais que pos + len est supérieur à la taille du tableau, celui-ci est tronqué à la position pos.

Exemple :

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

La suppression d’éléments préserve la capacité du tableau et ne réduit pas la quantité de mémoire allouée. Pour se débarrasser de la capacité excédentaire 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 situé à l'index pos. Si pos est hors limites (c'est-à-dire si pos >= size()), cette fonction ne fait rien.

Cette fonction a été introduite dans Qt 6.5.

Voir également 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 également ` remove()`.

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

Supprime de le tableau d'octets tous les octets pour lesquels le prédicat pred renvoie « 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 également remove().

QByteArray::reverse_iterator QByteArray::rend()

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

Voir également ` 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étée le nombre d'times s spécifié.

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 les len octets à partir de l'index pos par le tableau d'octets after, puis 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 toutes les occurrences 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 toutes les occurrences du tableau d'octets 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, à partir de before, par les octets asize, à partir de after. Étant donné que les tailles des chaînes sont indiquées par bsize et asize, celles-ci peuvent contenir des octets «\0 » et ne doivent pas nécessairement se terminer par «\0 ».

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

Remplace les octets len à partir de l'index pos par les octets alen à partir de l'index after. Les octets insérés peuvent inclure des octets de type «\0 ».

void QByteArray::reserve(qsizetype size)

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

Si vous connaissez à l’avance la taille du tableau d’octets, vous pouvez appeler cette fonction ; en appelant souvent ` resize()`, vous obtiendrez probablement de meilleures performances.

En cas de doute sur l’espace nécessaire, il est généralement préférable d’utiliser une borne supérieure telle que ` size`, ou une estimation haute de la taille la plus probable, si une borne supérieure stricte s’avère nettement plus grande que celle-ci. Si ` size ` est une sous-estimation, le tableau s’agrandira selon les besoins une fois la taille réservée dépassée, ce qui peut entraîner une allocation plus importante que ne l’aurait été votre meilleure surestimation et ralentira l’opération qui la déclenche.

Le seul objectif de cette fonction est de fournir un moyen d’ajuster avec précision l’utilisation de la mémoire par ` QByteArray`. En général, vous n’aurez que très rarement besoin d’appeler cette fonction.

Voir également squeeze() et capacity().

void QByteArray::resize(qsizetype size)

Définit 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érieure à la taille actuelle, les octets situés 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)

Définit la taille du tableau d'octets à newSize octets.

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

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

Cette fonction a été introduite dans Qt 6.4.

Voir également 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 len derniers octets de ce tableau d'octets.

Si vous savez que ` len ` ne peut pas dépasser les limites, utilisez plutôt ` last()` dans votre nouveau code, car cette fonction est plus rapide.

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

Renvoie un tableau « QByteArray » vide si « len » est inférieur à 0.

Voir également : 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 contenant 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, alors 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`, alors 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ésente le nombre entier n sous forme de chaîne de caractères.

Définit ce tableau d'octets comme 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, les lettres étant utilisées pour les chiffres supérieurs à 9 ; A correspond à dix, B à 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 également toLong().

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

Voir également toLongLong().

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

Voir également toULongLong().

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

Voir également toShort().

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

Voir également toUInt().

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

Voir également toULong().

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

Voir également toUShort().

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

Représente le nombre à virgule flottante n sous forme de chaîne de caractères.

Définit ce tableau d’octets comme une chaîne de caractères représentant n, avec une format et une precision données (dont les significations sont les mêmes que pour QLocale::toString(double, char, int)), et renvoie une référence à ce tableau d’octets.

Voir également toDouble() et QLocale::FloatingPointPrecisionOption.

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

Représente le nombre à virgule flottante n sous forme de chaîne de caractères.

Définit ce tableau d’octets sur une chaîne représentant n, avec une format et une precision données (dont les significations sont les mêmes que pour QLocale::toString(double, char, int)), et renvoie une référence à ce tableau d’octets.

Voir également toFloat() et QLocale::FloatingPointPrecisionOption.

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

Réinitialise l’ QByteArray pour qu’il utilise les premiers size octets du tableau data. Les octets ne sont pas copiés. La variable QByteArray contiendra le pointeur data. L’appelant garantit que data ne sera ni supprimé ni modifié tant que ce QByteArray et toutes ses copies non modifiées existeront.

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

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

void QByteArray::shrink_to_fit()

Cette fonction est fournie à des fins de compatibilité avec la STL. Elle équivaut à ` 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 laquelle chaque séquence de caractères d'espacement internes est remplacée par un seul espace.

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 page «\f » et espace « ».

Exemple :

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

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

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

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

Le dernier octet du tableau d’octets se trouve à la position size() - 1. De plus, QByteArray garantit que l’octet situé à la position size() est toujours «\0 », ce qui vous permet d’utiliser la valeur de retour de data() et constData() comme arguments de fonctions qui attendent des chaînes terminées par «\0 ». Si l’objet ` QByteArray ` a été créé à partir d’un ` raw data ` qui ne comprenait pas l’octet de terminaison «\0 » en fin de chaîne, alors ` QByteArray ` ne l’ajoute pas automatiquement, sauf si une copie profonde est 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 et s'étende sur n octets, puis 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 également sliced(), first(), last(), chopped(), chop() et truncate().

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

Modifie ce tableau d'octets en commençant à la position pos, jusqu'à la fin de celui-ci, et renvoie une référence à ce tableau d'octets.

Cette fonction a été introduite dans Qt 6.8.

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

Renvoie un tableau d'octets contenant les octets d'n 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 également 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 celui-ci.

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-tableaux à chaque occurrence d’ sep, puis renvoie la liste de ces sous-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 au stockage des données du tableau.

Cette fonction a pour seul objectif de permettre d'ajuster avec précision l'utilisation de la mémoire par QByteArray. En général, vous n'aurez que très rarement besoin d'appeler cette fonction.

Voir également 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 décrite à l'adresse 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 également 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)

Permute cet tableau d'octets avec other. Cette opération est très rapide et ne rencontre jamais d'échec.

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

Renvoie une copie du tableau d'octets, encodée à 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 encoder les données en Base64 est défini dans la RFC 4648.

Voir également fromBase64().

CFDataRef QByteArray::toCFData() const

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

L'appelant est propriétaire de l'objet CFData et est chargé de le libérer.

Voir également toRawCFData(), fromCFData(), fromRawCFData() et fromRawData().

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

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

Renvoie l'infini si la conversion provoque un débordement, ou 0,0 si la conversion échoue pour d'autres raisons (par exemple, un sous-débordement).

Si ok n'est pas nullptr, l'échec est signalé en définissant *ok sur false, et la réussite en définissant *ok sur 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 en début et en fin de chaîne.

Voir également number().

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

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

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

Les objets JavaScript possèdent une copie des données, et cet QByteArray peut être supprimé 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 également fromEcmaUint8Array().

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

Renvoie le tableau d'octets converti en une valeur de type ` float `.

Renvoie l'infini si la conversion entraîne un débordement, ou 0,0 si la conversion échoue pour d'autres raisons (par exemple, un sous-débordement).

Si ok n'est pas nullptr, l'échec est signalé en définissant *ok sur false, et la réussite en définissant *ok sur 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 en début et en fin de chaîne.

Voir également number().

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

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

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

Si ` separator ` n'est pas «\0 », le caractère de séparation est inséré entre les octets hexadécimaux.

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 une valeur « int » en utilisant la base base, qui est de 10 par défaut. Les bases 0 et 2 à 36 sont prises en charge, les lettres étant utilisées pour les chiffres supérieurs à 9 ; A correspond à 10, B à 11, et ainsi de suite.

Si ` base ` est égal à 0, la base est déterminée automatiquement selon les règles suivantes : si le tableau d'octets commence par « 0x », il est considéré comme hexadécimal (base 16) ; sinon, s’il commence par « 0b », il est considéré comme binaire (base 2) ; sinon, s’il commence par « 0 », il est considéré comme octal (base 8) ; dans tous les autres cas, il est considéré comme décimal.

Renvoie 0 si la conversion échoue.

Si ` ok ` n’est pas ` nullptr`, l’échec est signalé en définissant *`ok ` sur ` false`, et la réussite en définissant *`ok ` sur ` 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 également number().

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

Renvoie le tableau d'octets converti en un entier de type « long » en utilisant la base base, qui est de 10 par défaut. Les bases 0 et 2 à 36 sont prises en charge, les lettres étant utilisées pour les chiffres supérieurs à 9 ; A correspond à 10, B à 11, et ainsi de suite.

Si ` base ` est égal à 0, la base est déterminée automatiquement selon les règles suivantes : si le tableau d’octets commence par « 0x », il est considéré comme hexadécimal (base 16) ; sinon, s’il commence par « 0b », il est considéré comme binaire (base 2) ; sinon, s’il commence par « 0 », il est considéré comme octal (base 8) ; dans le cas contraire, il est considéré comme décimal.

Renvoie 0 si la conversion échoue.

Si ` ok ` n’est pas ` nullptr`, l’échec est signalé en définissant *`ok ` sur ` false`, et la réussite en définissant *`ok ` sur ` 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 également number().

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

Renvoie le tableau d'octets converti en un nombre « long long » en utilisant la base base, qui est de 10 par défaut. Les bases 0 et 2 à 36 sont prises en charge, les lettres étant utilisées pour les chiffres supérieurs à 9 ; A correspond à 10, B à 11, et ainsi de suite.

Si ` base ` est égal à 0, la base est déterminée automatiquement selon les règles suivantes : si le tableau d'octets commence par « 0x », il est considéré comme hexadécimal (base 16) ; sinon, s’il commence par « 0b », il est considéré comme binaire (base 2) ; sinon, s’il commence par « 0 », il est considéré comme octal (base 8) ; dans le cas contraire, il est considéré comme décimal.

Renvoie 0 si la conversion échoue.

Si ` ok ` n’est pas ` nullptr`, l’échec est signalé en définissant *`ok ` sur ` false`, et la réussite en définissant *`ok ` sur ` true`.

Voir également 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 également isLower(), toUpper() et Character Case.

NSData *QByteArray::toNSData() const

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

L'objet NSData est libéré automatiquement.

Voir également fromNSData(), fromRawNSData(), fromRawData() et toRawNSData().

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

Renvoie une copie de ce tableau d'octets encodée en pourcentage, au format 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 font pas partie des catégories suivantes :

LETTRES (« a » à « z » et « A » à « Z ») / CHIFFRES (0 à 9) / « - » / « . » / « _ » / « ~ »

Pour empêcher l'encodage de certains octets, transmettez-les à exclude. Pour forcer l'encodage de certains octets, transmettez-les à include. Le caractère « percent » est toujours encodé.

Exemple :

QByteArray text = "{une chaîne suspecte ?}";
QByteArray ba = text.toPercentEncoding("{}", "s");
qDebug("%s", ba.constData());
// affiche « {a fi%73hy %73tring%3F} »

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

Voir également fromPercentEncoding() et QUrl::toPercentEncoding().

CFDataRef QByteArray::toRawCFData() const

Crée un objet CFData qui utilise les octets de l'QByteArray.

Les octets de l'QByteArray ne sont pas copiés.

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

Voir également toCFData(), fromRawCFData(), fromCFData() et fromRawData().

NSData *QByteArray::toRawNSData() const

Crée un objet NSData qui utilise les octets de l'QByteArray.

Les octets de l'QByteArray ne sont pas copiés.

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

Voir également fromRawNSData(), fromNSData(), fromRawData() et toNSData().

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

Renvoie le tableau d'octets converti en un tableau de type « short » en utilisant la base base, qui est égale à 10 par défaut. Les bases 0 et 2 à 36 sont prises en charge ; les chiffres supérieurs à 9 sont représentés par des lettres : A correspond à 10, B à 11, et ainsi de suite.

Si ` base ` est égal à 0, la base est déterminée automatiquement selon les règles suivantes : si le tableau d'octets commence par « 0x », il est considéré comme hexadécimal (base 16) ; sinon, s’il commence par « 0b », il est considéré comme binaire (base 2) ; sinon, s’il commence par « 0 », il est considéré comme octal (base 8) ; dans tous les autres cas, il est considéré comme décimal.

Renvoie 0 si la conversion échoue.

Si ` ok ` n'est pas ` nullptr`, l'échec est signalé en définissant *`ok ` sur ` false`, et la réussite en définissant *`ok ` sur ` true`.

Voir également number().

std::string QByteArray::toStdString() const

Renvoie un objet std::string contenant les données de cet QByteArray.

Cet opérateur est particulièrement utile pour transmettre un ` QByteArray ` à une fonction qui accepte un objet `std::string`.

Voir également fromStdString() et QString::toStdString().

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

Renvoie le tableau d'octets converti en un unsigned int en utilisant la base base, qui est égale à 10 par défaut. Les bases 0 et 2 à 36 sont prises en charge ; les chiffres supérieurs à 9 sont représentés par des lettres : A correspond à 10, B à 11, et ainsi de suite.

Si ` base ` est égal à 0, la base est déterminée automatiquement selon les règles suivantes : si le tableau d’octets commence par « 0x », il est considéré comme hexadécimal (base 16) ; sinon, s’il commence par « 0b », il est considéré comme binaire (base 2) ; sinon, s’il commence par « 0 », il est considéré comme octal (base 8) ; dans le cas contraire, il est considéré comme décimal.

Renvoie 0 si la conversion échoue.

Si ` ok ` n’est pas ` nullptr`, l’échec est signalé en définissant *`ok ` sur ` false`, et la réussite en définissant *`ok ` sur ` true`.

Voir également number().

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

Renvoie le tableau d'octets converti en un objet ` unsigned long int ` en utilisant la base base, qui est égale à 10 par défaut. Les bases 0 et 2 à 36 sont prises en charge, les lettres étant utilisées pour les chiffres supérieurs à 9 ; A correspond à 10, B à 11, et ainsi de suite.

Si base est égal à 0, la base est déterminée automatiquement selon les règles suivantes : si le tableau d’octets commence par « 0x », il est considéré comme hexadécimal (base 16) ; sinon, s’il commence par « 0b », il est considéré comme binaire (base 2) ; sinon, s’il commence par « 0 », il est considéré comme octal (base 8) ; dans tous les autres cas, il est considéré comme décimal.

Renvoie 0 si la conversion échoue.

Si ` ok ` n’est pas ` nullptr`, l’échec est signalé en définissant *`ok ` sur ` false`, et la réussite en définissant *`ok ` sur ` true`.

Voir également number().

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

Renvoie le tableau d’octets converti en un objet ` unsigned long long ` en utilisant la base base, qui est 10 par défaut. Les bases 0 et 2 à 36 sont prises en charge ; les chiffres supérieurs à 9 sont représentés par des lettres : A correspond à 10, B à 11, et ainsi de suite.

Si ` base ` est égal à 0, la base est déterminée automatiquement selon les règles suivantes : si le tableau d’octets commence par « 0x », il est considéré comme hexadécimal (base 16) ; sinon, s’il commence par « 0b », il est considéré comme binaire (base 2) ; sinon, s’il commence par « 0 », il est considéré comme octal (base 8) ; dans le cas contraire, il est considéré comme décimal.

Renvoie 0 si la conversion échoue.

Si ` ok ` n'est pas ` nullptr`, l'échec est signalé en définissant *`ok ` sur ` false`, et la réussite en définissant *`ok ` sur ` true`.

Voir également number().

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

Renvoie le tableau d'octets converti en un objet ` unsigned short ` en utilisant la base base, qui est égale à 10 par défaut. Les bases 0 et 2 à 36 sont prises en charge ; les chiffres supérieurs à 9 sont représentés par des lettres : A correspond à 10, B à 11, et ainsi de suite.

Si ` base ` est égal à 0, la base est déterminée automatiquement selon les règles suivantes : si le tableau d’octets commence par « 0x », il est considéré comme hexadécimal (base 16) ; sinon, s’il commence par « 0b », il est considéré comme binaire (base 2) ; sinon, s’il commence par « 0 », il est considéré comme octal (base 8) ; sinon, il est considéré comme décimal.

Renvoie 0 si la conversion échoue.

Si ` ok ` n’est pas ` nullptr`, l’échec est signalé en définissant *`ok ` sur ` false`, et la réussite en définissant *`ok ` sur ` true`.

Voir également number().

QByteArray QByteArray::toUpper() const

Renvoie une copie du tableau d'octets dans laquelle chaque lettre ASCII minuscule est convertie en majuscule.

Exemple :

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

Voir également 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 page «\f » et espace « ».

Exemple :

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

Contrairement à la fonction ` simplified()`, la fonction `trimmed()` laisse les espaces internes inchangés.

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

void QByteArray::truncate(qsizetype pos)

Tronque le tableau d'octets à l'index pos.

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

Exemple :

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

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

Renvoie un pointeur vers les données stockées dans le tableau d'octets. Ce 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’aucun détachement n’a lieu et que le QByteArray n’est pas modifié.

Cet opérateur est particulièrement utile pour transmettre 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 : une variable de type ` QByteArray ` peut stocker n’importe quelle valeur d’octet, y compris les chaînes « '\0 », mais la plupart des fonctions prenant des arguments de type ` char * ` supposent que les données se terminent au premier « '\0 » qu’elles rencontrent.

Voir aussi constData().

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

Convertit cet objet ` QByteArray ` en un objet ` std::string_view `. La vue de chaîne renvoyée couvrira l'intégralité 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 des éléments à un tableau d’octets vide, ce dernier partagera simplement les données contenues dans ba. Dans ce cas, aucune copie des données n’est effectuée, ce qui prend un temps constant. Si une instance partagée est modifiée, elle sera copiée (copie à l’écriture), ce qui prend un temps linéaire.

Si le tableau d’octets auquel on ajoute des éléments n’est pas vide, une copie profonde des données est effectuée, ce qui prend un temps linéaire.

Cette opération ne souffre généralement pas de surcharge d’allocation, car ` QByteArray ` préalloue de l’espace supplémentaire à la fin des données afin qu’elles puissent s’étendre sans réallocation à chaque opération d’ajout.

Voir également append() et prepend().

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

Ajoute l'ch d'octets à 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 par un « ' », str à la fin de ce tableau d’octets et renvoie une référence à ce tableau d’octets.

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

Cette opération attribue l'other à cette instance QByteArray.

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

Attribue la valeur « other » à ce tableau d'octets et renvoie une référence à ce tableau d'octets.

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

Attribue la valeur « str » à ce tableau d'octets.

str est supposé pointer vers une chaîne terminée par un caractère nul, et sa longueur est déterminée dynamiquement.

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

Renvoie l'octet situé à l'index i sous forme de référence modifiable.

i i doit être une position d'index valide dans le tableau d'octets (c'est-à-dire 0 <= < ()). 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

Comme sur (i).