QByteArray Class
La clase QByteArray proporciona una matriz de bytes. Más información...
| Encabezado: | #include <QByteArray> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
- Lista de todos los miembros, incluidos los miembros heredados
- Miembros obsoletos
- QByteArray forma parte de las clases compartidas implícitamente y de las clases para datos de cadena.
Nota: Todas las funciones de esta clase son reentrantes.
Comparaciones de QByteArray
| Categoría | Tipos comparables | Descripción |
|---|---|---|
| strong | QByteArray | |
| strong | const char *. | |
| strong | QChar, char16_t, QString, QStringView, QLatin1StringView y QUtf8StringView. | Al compararlos con tipos de cadena, el contenido se interpreta como UTF-8. |
Tipos públicos
| class | FromBase64Result |
| enum | Base64Option { Base64Encoding, Base64UrlEncoding, KeepTrailingEquals, OmitTrailingEquals, IgnoreBase64DecodingErrors, AbortOnBase64DecodingErrors } |
| flags | Base64Options |
| const_iterator | |
| const_reverse_iterator | |
| iterator | |
| reverse_iterator |
Funciones públicas
| QByteArray() | |
(since 6.8) | QByteArray(QByteArrayView v) |
| QByteArray(const char*data, qsizetype size = -1) | |
| QByteArray(qsizetype size, Qt::Initialization) | |
| QByteArray(qsizetype tamaño, char ch) | |
| QByteArray(const QByteArray&other) | |
| QByteArray(QByteArray&&other) | |
| ~QByteArray() | |
| QByteArray & | append(const QByteArray&ba) |
| QByteArray & | append(QByteArrayView datos) |
| QByteArray & | append(char ch) |
| QByteArray & | append(const char*str) |
| QByteArray & | append(const char*str, qsizetype len) |
| QByteArray & | append(qsizetype count, char ch) |
(since 6.6) QByteArray & | assign(QByteArrayView v) |
(since 6.6) QByteArray & | assign(InputIterator first, InputIterator last) |
(since 6.6) QByteArray & | assign(qsizetype n, char c) |
| char | at(qsizetype i) const |
| char & | back() |
| char | back() const |
| QByteArray::iterator | begin() |
| QByteArray::const_iterator | begin() const |
| qsizetype | capacity() const |
| QByteArray::const_iterator | cbegin() const |
| QByteArray::const_iterator | cend() const |
| void | chop(qsizetype n) |
| QByteArray | chopped(qsizetype len) && |
| QByteArray | chopped(qsizetype len) const & |
| void | clear() |
(since 6.0) int | compare(QByteArrayView bv, Qt::CaseSensitivity cs = Qt::CaseSensitive) const |
| QByteArray::const_iterator | constBegin() const |
| const char * | constData() const |
| QByteArray::const_iterator | constEnd() const |
(since 6.0) bool | contains(QByteArrayView bv) const |
| bool | contains(char ch) const |
(since 6.0) qsizetype | count(QByteArrayView bv) const |
| qsizetype | count(char ch) const |
| QByteArray::const_reverse_iterator | crbegin() const |
| QByteArray::const_reverse_iterator | crend() const |
| char * | data() |
| const char * | data() const |
| QByteArray::iterator | end() |
| QByteArray::const_iterator | end() const |
(since 6.0) bool | endsWith(QByteArrayView bv) const |
| bool | endsWith(char ch) const |
(since 6.1) QByteArray::iterator | erase(QByteArray::const_iterator first, QByteArray::const_iterator last) |
(since 6.5) QByteArray::iterator | erase(QByteArray::const_iterator it) |
| QByteArray & | fill(char ch, qsizetype size = -1) |
(since 6.0) QByteArray | first(qsizetype n) && |
(since 6.0) QByteArray | first(qsizetype n) const & |
| char & | front() |
| char | front() const |
(since 6.0) qsizetype | indexOf(QByteArrayView bv, qsizetype from = 0) const |
| qsizetype | indexOf(char ch, qsizetype from = 0) const |
(since 6.0) QByteArray & | insert(qsizetype i, QByteArrayView data) |
| QByteArray & | insert(qsizetype i, const QByteArray&data) |
| QByteArray & | insert(qsizetype i, const char*s) |
| QByteArray & | insert(qsizetype i, char ch) |
| QByteArray & | insert(qsizetype i, const char*data, qsizetype len) |
| QByteArray & | insert(qsizetype i, qsizetype count, char ch) |
| bool | isEmpty() const |
| bool | isLower() const |
| bool | isNull() const |
| bool | isUpper() const |
(since 6.3) bool | isValidUtf8() const |
(since 6.0) QByteArray | last(qsizetype n) && |
(since 6.0) QByteArray | last(qsizetype n) const & |
(since 6.0) qsizetype | lastIndexOf(QByteArrayView bv, qsizetype from) const |
(since 6.2) qsizetype | lastIndexOf(QByteArrayView bv) const |
| qsizetype | lastIndexOf(char ch, qsizetype from = -1) const |
| QByteArray | left(qsizetype len) && |
| QByteArray | left(qsizetype len) const & |
| QByteArray | leftJustified(qsizetype width, char fill = ' ', bool truncate = false) const |
| qsizetype | length() const |
(since 6.8) qsizetype | max_size() const |
| QByteArray | mid(qsizetype pos, qsizetype len = -1) && |
| QByteArray | mid(qsizetype pos, qsizetype len = -1) const & |
(since 6.10) QByteArray & | nullTerminate() |
(since 6.10) QByteArray | nullTerminated() && |
(since 6.10) QByteArray | nullTerminated() const & |
(since 6.4) QByteArray | percentDecoded(char percent = '%') const & |
(since 6.11) QByteArray | percentDecoded(char percent = '%') && |
| QByteArray & | prepend(QByteArrayView ba) |
| QByteArray & | prepend(char ch) |
| QByteArray & | prepend(const QByteArray&ba) |
| QByteArray & | prepend(const char*str) |
| QByteArray & | prepend(const char*str, qsizetype len) |
| QByteArray & | prepend(qsizetype count, char ch) |
| void | push_back(const QByteArray&other) |
(since 6.0) void | push_back(QByteArrayView str) |
| void | push_back(char ch) |
| void | push_back(const char*str) |
| void | push_front(const QByteArray&other) |
(since 6.0) void | push_front(QByteArrayView str) |
| void | push_front(char ch) |
| void | push_front(const char*str) |
| QByteArray::reverse_iterator | rbegin() |
| QByteArray::const_reverse_iterator | rbegin() const |
| QByteArray & | remove(qsizetype pos, qsizetype len) |
(since 6.5) QByteArray & | removeAt(qsizetype pos) |
(since 6.5) QByteArray & | removeFirst() |
(since 6.1) QByteArray & | removeIf(Predicado pred) |
(since 6.5) QByteArray & | removeLast() |
| QByteArray::reverse_iterator | rend() |
| QByteArray::const_reverse_iterator | rend() const |
| QByteArray | repeated(qsizetype veces) const |
| QByteArray & | replace(qsizetype pos, qsizetype len, QByteArrayView after) |
(since 6.0) QByteArray & | replace(QByteArrayView before, QByteArrayView after) |
| QByteArray & | replace(char antes, QByteArrayView después) |
| QByteArray & | replace(char antes, char después) |
| QByteArray & | replace(const char*antes, qsizetype bsize, const char*después, qsizetype asize) |
| QByteArray & | replace(qsizetype pos, qsizetype len, const char*after, qsizetype alen) |
| void | reserve(qsizetype size) |
| void | resize(qsizetype size) |
(since 6.4) void | resize(qsizetype newSize, char c) |
(since 6.8) void | resizeForOverwrite(qsizetype tamaño) |
| QByteArray | right(qsizetype len) && |
| QByteArray | right(qsizetype len) const & |
| QByteArray | rightJustified(qsizetype ancho, char relleno = ' ', bool truncar = false) const |
| QByteArray & | setNum(int n, int base = 10) |
| QByteArray & | setNum(long n, int base = 10) |
| QByteArray & | setNum(qlonglong n, int base = 10) |
| QByteArray & | setNum(qulonglong n, int base = 10) |
| QByteArray & | setNum(short n, int base = 10) |
| QByteArray & | setNum(uint n, int base = 10) |
| QByteArray & | setNum(ulong n, int base = 10) |
| QByteArray & | setNum(ushort n, int base = 10) |
| QByteArray & | setNum(double n, char formato = 'g', int precisión = 6) |
| QByteArray & | setNum(float n, char formato = 'g', int precisión = 6) |
| QByteArray & | setRawData(const char*data, qsizetype size) |
| void | shrink_to_fit() |
| QByteArray | simplified() const |
| qsizetype | size() const |
(since 6.8) QByteArray & | slice(qsizetype pos, qsizetype n) |
(since 6.8) QByteArray & | slice(qsizetype pos) |
(since 6.0) QByteArray | sliced(qsizetype pos, qsizetype n) && |
(since 6.0) QByteArray | sliced(qsizetype pos, qsizetype n) const & |
(since 6.0) QByteArray | sliced(qsizetype pos) && |
(since 6.0) QByteArray | sliced(qsizetype pos) const & |
| QList<QByteArray> | split(char sep) const |
| void | squeeze() |
(since 6.0) bool | startsWith(QByteArrayView bv) const |
| bool | startsWith(char ch) const |
| void | swap(QByteArray&other) |
| QByteArray | toBase64(QByteArray::Base64Options opciones = Base64Encoding) const |
| CFDataRef | toCFData() const |
| double | toDouble(bool*ok = nullptr) const |
(since 6.5) emscripten::val | toEcmaUint8Array() |
| float | toFloat(bool*ok = nullptr) const |
| QByteArray | toHex(char separador = '\0') const |
| int | toInt(bool*ok = nullptr, int base = 10) const |
| long | toLong(bool*ok = nullptr, int base = 10) const |
| qlonglong | toLongLong(bool*ok = nullptr, int base = 10) const |
| QByteArray | toLower() const |
| NSData * | toNSData() const |
| QByteArray | toPercentEncoding(const QByteArray&exclude = QByteArray(), const QByteArray&include = QByteArray(), char percent = '%') const |
| CFDataRef | toRawCFData() const |
| NSData * | toRawNSData() const |
| short | toShort(bool*ok = nullptr, int base = 10) const |
| std::string | toStdString() const |
| uint | toUInt(bool*ok = nullptr, int base = 10) const |
| ulong | toULong(bool*ok = nullptr, int base = 10) const |
| qulonglong | toULongLong(bool*ok = nullptr, int base = 10) const |
| ushort | toUShort(bool*ok = nullptr, int base = 10) const |
| QByteArray | toUpper() const |
| QByteArray | trimmed() const |
| void | truncate(qsizetype pos) |
| operator const char *() const | |
| operator const void *() const | |
(since 6.10) | operator std::string_view() const |
| QByteArray & | operator+=(const QByteArray&ba) |
| QByteArray & | operator+=(char ch) |
| QByteArray & | operator+=(const char*str) |
| QByteArray & | operator=(QByteArray&&other) |
| QByteArray & | operator=(const QByteArray&other) |
| QByteArray & | operator=(const char*str) |
| char & | operator[](qsizetype i) |
| char | operator[](qsizetype i) const |
Miembros públicos estáticos
| QByteArray | fromBase64(const QByteArray &base64, QByteArray::Base64Options options = Base64Encoding) |
| QByteArray::FromBase64Result | fromBase64Encoding(QByteArray &&base64, QByteArray::Base64Options options = Base64Encoding) |
| QByteArray::FromBase64Result | fromBase64Encoding(const QByteArray &base64, QByteArray::Base64Options options = Base64Encoding) |
| QByteArray | fromCFData(CFDataRef data) |
(since 6.5) QByteArray | fromEcmaUint8Array(emscripten::val uint8array) |
| QByteArray | fromHex(const QByteArray &hexEncoded) |
| QByteArray | fromNSData(const NSData *data) |
| QByteArray | fromPercentEncoding(const QByteArray &input, char percent = '%') |
(since 6.11) QByteArray | fromPercentEncoding(QByteArray &&input, char percent = '%') |
| QByteArray | fromRawCFData(CFDataRef data) |
| QByteArray | fromRawData(const char *data, qsizetype size) |
| QByteArray | fromRawNSData(const NSData *data) |
| QByteArray | fromStdString(const std::string &str) |
(since 6.8) qsizetype | maxSize() |
| QByteArray | number(int n, int base = 10) |
| QByteArray | number(long n, int base = 10) |
| QByteArray | number(qlonglong n, int base = 10) |
| QByteArray | number(qulonglong n, int base = 10) |
| QByteArray | number(uint n, int base = 10) |
| QByteArray | number(ulong n, int base = 10) |
| QByteArray | number(double n, char format = 'g', int precision = 6) |
Elementos no miembros relacionados
(since 6.1) qsizetype | erase(QByteArray &ba, const T &t) |
(since 6.1) qsizetype | erase_if(QByteArray &ba, Predicate pred) |
| quint16 | qChecksum(QByteArrayView data, Qt::ChecksumType standard = Qt::ChecksumIso3309) |
| QByteArray | qCompress(const QByteArray &data, int compressionLevel = -1) |
| QByteArray | qCompress(const uchar *data, qsizetype nbytes, int compressionLevel = -1) |
| QByteArray | qUncompress(const QByteArray &data) |
| QByteArray | qUncompress(const uchar *data, qsizetype nbytes) |
| int | qstrcmp(const char *str1, const char *str2) |
| char * | qstrcpy(char *dst, const char *src) |
| char * | qstrdup(const char *src) |
| int | qstricmp(const char *str1, const char *str2) |
| size_t | qstrlen(const char *str) |
| int | qstrncmp(const char *str1, const char *str2, size_t len) |
| char * | qstrncpy(char *dst, const char *src, size_t len) |
| int | qstrnicmp(const char *s1, const char *s2, size_t len) |
| size_t | qstrnlen(const char *str, size_t maxlen) |
| bool | operator!=(const QByteArray &lhs, const QByteArray &rhs) |
| bool | operator!=(const QByteArray &lhs, const char *const &rhs) |
| bool | operator!=(const char *const &lhs, const QByteArray &rhs) |
(since 6.4) QByteArray | operator""_ba(const char *str, size_t size) |
| QByteArray | operator+(const QByteArray &a1, const QByteArray &a2) |
(since 6.9) QByteArray | operator+(QByteArrayView lhs, const QByteArray &rhs) |
| QByteArray | operator+(char a1, const QByteArray &a2) |
(since 6.9) QByteArray | operator+(const QByteArray &lhs, QByteArrayView rhs) |
| QByteArray | operator+(const QByteArray &a1, char a2) |
| QByteArray | operator+(const QByteArray &a1, const char *a2) |
| QByteArray | operator+(const char *a1, const QByteArray &a2) |
| bool | operator<(const QByteArray &lhs, const QByteArray &rhs) |
| bool | operator<(const QByteArray &lhs, const char *const &rhs) |
| bool | operator<(const char *const &lhs, const QByteArray &rhs) |
| QDataStream & | operator<<(QDataStream &out, const QByteArray &ba) |
| bool | operator<=(const QByteArray &lhs, const QByteArray &rhs) |
| bool | operator<=(const QByteArray &lhs, const char *const &rhs) |
| bool | operator<=(const char *const &lhs, const QByteArray &rhs) |
| bool | operator==(const QByteArray &lhs, const QByteArray &rhs) |
| bool | operator==(const QByteArray &lhs, const char *const &rhs) |
| bool | operator==(const char *const &lhs, const QByteArray &rhs) |
| bool | operator>(const QByteArray &lhs, const QByteArray &rhs) |
| bool | operator>(const QByteArray &lhs, const char *const &rhs) |
| bool | operator>(const char *const &lhs, const QByteArray &rhs) |
| bool | operator>=(const QByteArray &lhs, const QByteArray &rhs) |
| bool | operator>=(const QByteArray &lhs, const char *const &rhs) |
| bool | operator>=(const char *const &lhs, const QByteArray &rhs) |
| QDataStream & | operator>>(QDataStream &in, QByteArray &ba) |
Macros
| QByteArrayLiteral(ba) | |
| QT_NO_CAST_FROM_BYTEARRAY | |
(since 6.8) | QT_NO_QSNPRINTF |
Descripción detallada
QByteArray se puede utilizar para almacenar tanto bytes sin procesar (incluidos los «\0 ») como cadenas tradicionales de 8 bits terminadas en «\0 ». Utilizar QByteArray resulta mucho más cómodo que utilizar « const char * ». En segundo plano, siempre garantiza que los datos vayan seguidos de un terminador «\0 » y utiliza el uso compartido implícito (copia al escribir) para reducir el uso de memoria y evitar copias innecesarias de datos.
Además de `QByteArray`, Qt también proporciona la clase ` QString ` para almacenar datos de cadena. En la mayoría de los casos, « QString » es la clase que conviene utilizar. Esta interpreta su contenido como texto Unicode (codificado en UTF-16), mientras que QByteArray pretende evitar suposiciones sobre la codificación o la semántica de los bytes que almacena (salvo en algunos casos heredados en los que utiliza ASCII). Además, QString se utiliza de forma generalizada en la API de Qt. Los dos casos principales en los que QByteArray resulta adecuado son cuando se necesitan almacenar datos binarios sin procesar y cuando el ahorro de memoria es fundamental (por ejemplo, con Qt para Linux embebido).
Una forma de inicializar un `QByteArray` es simplemente pasar un ` const char * ` a su constructor. Por ejemplo, el siguiente código crea una matriz de bytes de tamaño 5 que contiene los datos «Hello»:
QByteArray ba("Hello");Aunque el ` size()` es 5, la matriz de bytes también mantiene un byte adicional «\0 » al final, de modo que, si se utiliza una función que solicita un puntero a los datos subyacentes (por ejemplo, una llamada a ` data()`), se garantiza que los datos a los que apunta estén terminados en «\0 ».
QByteArray realiza una copia profunda de los datos « const char * », por lo que puedes modificarlos posteriormente sin sufrir efectos secundarios. (Si, por ejemplo, por motivos de rendimiento, no deseas realizar una copia profunda de los datos, utiliza en su lugar « QByteArray::fromRawData()»).
Otro método consiste en establecer el tamaño de la matriz mediante ` resize()` e inicializar los datos byte a byte. QByteArray utiliza índices basados en 0, al igual que las matrices de C++. Para acceder al byte situado en una posición de índice concreta, puedes utilizar el operador [](). En los arrays de bytes no const, el operador []() devuelve una referencia a un byte que puede utilizarse en el lado izquierdo de una asignación. Por ejemplo:
QByteArray ba;
ba.resize(5);
ba[0] = 0x3c;
ba[1] = 0xb8;
ba[2] = 0x64;
ba[3] = 0x18;
ba[4] = 0xca;Para el acceso de solo lectura, una sintaxis alternativa consiste en utilizar ` at()`:
for (qsizetype i = 0; i < ba.size(); ++i) {
if (ba.at(i) >= 'a' && ba.at(i) <= 'f')
cout << "Found character in range [a-f]" << endl;
}at() puede ser más rápido que el operador [](), ya que nunca provoca una copia profunda.
Para extraer muchos bytes a la vez, utiliza first(), last() o sliced().
Un QByteArray puede incrustar bytes «\0 ». La función size() siempre devuelve el tamaño de todo el array, incluidos los bytes «\0 » incrustados, pero excluyendo el byte de terminación «\0 » añadido por QByteArray. Por ejemplo:
QByteArray ba1("ca\0r\0t");
ba1.size(); // Returns 2.
ba1.constData(); // Returns "ca" with terminating \0.
QByteArray ba2("ca\0r\0t", 3);
ba2.size(); // Returns 3.
ba2.constData(); // Returns "ca\0" with terminating \0.
QByteArray ba3("ca\0r\0t", 4);
ba3.size(); // Returns 4.
ba3.constData(); // Returns "ca\0r" with terminating \0.
const char cart[] = {'c', 'a', '\0', 'r', '\0', 't'};
QByteArray ba4(QByteArray::fromRawData(cart, 6));
ba4.size(); // Returns 6.
ba4.constData(); // Returns "ca\0r\0t" without terminating \0.Si deseas obtener la longitud de los datos hasta el primer byte «\0 », excluido este, llama a qstrlen() sobre la matriz de bytes.
Tras una llamada a ` resize()`, los bytes recién asignados tienen valores indefinidos. Para establecer todos los bytes en un valor concreto, llama a ` fill()`.
Para obtener un puntero a los bytes reales, llama a data() o a constData(). Estas funciones devuelven un puntero al inicio de los datos. Se garantiza que el puntero seguirá siendo válido hasta que se llame a una función no const en el QByteArray. También se garantiza que los datos terminan con un byte «\0 », a menos que el QByteArray se haya creado a partir de raw data. Este byte «\0 » lo proporciona automáticamente QByteArray y no se cuenta en size().
QByteArray proporciona las siguientes funciones básicas para modificar los datos de bytes: ` append()`, ` prepend()`, ` insert()`, ` replace()` y ` remove()`. Por ejemplo:
QByteArray x("and");
x.prepend("rock "); // x == "rock and"
x.append(" roll"); // x == "rock and roll"
x.replace(5, 3, "&"); // x == "rock & roll"En el ejemplo anterior, los dos primeros argumentos de la función replace() son la posición a partir de la cual debe comenzar la sustitución y el número de bytes que deben sustituirse.
Cuando las funciones que modifican datos aumentan el tamaño del array, pueden provocar una reasignación de memoria para el objeto QByteArray. Cuando esto ocurre, QByteArray se expande más de lo que necesita inmediatamente, con el fin de disponer de espacio para una mayor expansión sin necesidad de reasignación hasta que el tamaño del array haya aumentado considerablemente.
Las funciones ` insert()`, ` remove()` y, al sustituir un submatriz por otra de diferente tamaño, ` replace()` pueden resultar lentas (tiempo lineal) con matrices grandes, ya que requieren desplazar muchos bytes de la matriz al menos una posición en memoria.
Si estás creando un `QByteArray` de forma gradual y sabes de antemano aproximadamente cuántos bytes contendrá, puedes llamar a ` reserve()`, indicando a `QByteArray` que preasigne una determinada cantidad de memoria. También puedes llamar a ` capacity()` para averiguar cuánta memoria ha asignado realmente el `QByteArray`.
Ten en cuenta que el uso de operadores y funciones no const puede provocar que QByteArray realice una copia profunda de los datos, debido al uso compartido implícito.
QByteArray proporciona iteradores al estilo de la STL (QByteArray::const_iterator y QByteArray::iterator). En la práctica, los iteradores resultan muy útiles al trabajar con algoritmos genéricos proporcionados por la biblioteca estándar de C++.
Nota: Los iteradores y las referencias a elementos individuales de QByteArray están sujetos a problemas de estabilidad. A menudo se invalidan cuando se invoca una operación que modifica QByteArray (por ejemplo, insert() o remove()). Cuando se requiera estabilidad y una funcionalidad similar a la de los iteradores, se deben utilizar índices en lugar de iteradores, ya que estos no están vinculados al estado interno de QByteArray y, por lo tanto, no se invalidan.
Nota: No se puede confiar en quelos iteradores sobre un QByteArray, ni las referencias a bytes individuales dentro de este, sigan siendo válidos cuando se invoque a cualquier método no const de QByteArray. Acceder a dicho iterador o referencia tras la llamada a un método no const da lugar a un comportamiento indefinido. Cuando se requiera estabilidad para la funcionalidad similar a la de un iterador, se deben utilizar índices en lugar de iteradores, ya que estos no están vinculados al estado interno de `QByteArray` y, por lo tanto, no se invalidan.
Si desea encontrar todas las apariciones de un byte concreto o una secuencia de bytes en un `QByteArray`, utilice ` indexOf()` o ` lastIndexOf()`. La primera busca hacia adelante a partir de una posición de índice dada, mientras que la segunda busca hacia atrás. Ambas devuelven la posición de índice de la secuencia de bytes si la encuentran; de lo contrario, devuelven -1. Por ejemplo, este es un bucle típico que busca todas las apariciones de una cadena concreta:
QByteArray ba("We must be <b>bold</b>, very <b>bold</b>");
qsizetype j = 0;
while ((j = ba.indexOf("<b>", j)) != -1) {
cout << "Found <b> tag at index position " << j << endl;
++j;
}Si simplemente quieres comprobar si un QByteArray contiene una secuencia de bytes concreta, utiliza contains(). Si quieres averiguar cuántas veces aparece una secuencia de bytes concreta en la matriz de bytes, utiliza count(). Si quieres sustituir todas las apariciones de un valor concreto por otro, utiliza una de las sobrecargas de ` replace()` con dos parámetros.
QByteArrayLos QByteArray se pueden comparar utilizando operadores sobrecargados como `operator<()`, `operator<=()`, `operator==()`, `operator>=()`, etc. La comparación se basa exclusivamente en los valores numéricos de los bytes y es muy rápida, pero no es lo que un ser humano esperaría. ` QString::localeAwareCompare()` es una mejor opción para ordenar cadenas de la interfaz de usuario.
Por razones históricas, QByteArray distingue entre una matriz de bytes nula y una matriz de bytes vacía. Una matriz de bytes nula es aquella que se inicializa mediante el constructor por defecto de QByteArray o pasando (const char *)0 al constructor. Una matriz de bytes vacía es cualquier matriz de bytes con tamaño 0. Una matriz de bytes nulos siempre está vacía, pero una matriz de bytes vacía no es necesariamente nula:
QByteArray().isNull(); // returns true
QByteArray().isEmpty(); // returns true
QByteArray("").isNull(); // returns false
QByteArray("").isEmpty(); // returns true
QByteArray("abc").isNull(); // returns false
QByteArray("abc").isEmpty(); // returns falseTodas las funciones, excepto isNull(), tratan los matrices de bytes nulos de la misma manera que los matrices de bytes vacíos. Por ejemplo, data() devuelve un puntero válido (no nullptr) a un byte «\0 » para un matriz de bytes nulos, y QByteArray() se considera igual a QByteArray(""). Recomendamos utilizar siempre isEmpty() y evitar isNull().
Tamaño máximo y condiciones de falta de memoria
El tamaño máximo de QByteArray depende de la arquitectura. La mayoría de los sistemas de 64 bits pueden asignar más de 2 GB de memoria, con un límite típico de 2^63 bytes. El valor real también depende de la sobrecarga necesaria para gestionar el bloque de datos. Por lo tanto, en plataformas de 32 bits puede esperarse un tamaño máximo de 2 GB menos la sobrecarga, y en plataformas de 64 bits, de 2^63 bytes menos la sobrecarga. El número de elementos que se pueden almacenar en un QByteArray es este tamaño máximo.
Cuando falla la asignación de memoria, QByteArray lanza una excepción de « std::bad_alloc » (memoria insuficiente) si la aplicación se ha compilado con soporte para excepciones. Las situaciones de falta de memoria en los contenedores de Qt son el único caso en el que Qt lanzará excepciones. Si las excepciones están desactivadas, el agotamiento de la memoria se considera un comportamiento indefinido.
Tenga en cuenta que el sistema operativo puede imponer límites adicionales a las aplicaciones que ocupan mucha memoria asignada, especialmente bloques grandes y contiguos. Dichas consideraciones, la configuración de dicho comportamiento o cualquier medida de mitigación quedan fuera del alcance de la API de QByteArray.
Funciones de la configuración regional C y ASCII
QByteArray gestiona los datos generalmente como bytes, sin suponer ninguna semántica; cuando sí supone semántica, utiliza la configuración regional C y la codificación ASCII. Las codificaciones Unicode estándar son compatibles con QString; otras codificaciones pueden ser compatibles utilizando QStringEncoder y QStringDecoder para convertir a Unicode. Para la interpretación del texto específica de la configuración regional, utilice QLocale o QString.
Cadenas C
\0Las cadenas tradicionales de C, también conocidas como cadenas terminadas en «\0 », son secuencias de bytes, especificadas por un punto de inicio e incluyendo implícitamente cada byte hasta, pero sin incluir, el primer byte « » posterior. Los métodos que aceptan dicho puntero, sin especificar una longitud, lo interpretarán como esta secuencia de bytes. Dicha secuencia, por su propia naturaleza, no puede contener un byte «\0 ».
Otras sobrecargas aceptan un puntero de inicio y un recuento de bytes; estas utilizan el número de bytes indicado, a partir de la dirección de inicio, independientemente de si alguno de ellos resulta ser un byte «\0 ». En algunos casos, cuando no existe ninguna sobrecarga que admita únicamente un puntero, pasar una longitud de -1 hará que el método utilice como longitud el desplazamiento del primer byte «\0 » situado después del puntero; solo se debe pasar una longitud de -1 si el método indica explícitamente que lo hace así (en cuyo caso suele tratarse de un argumento por defecto).
Caracteres de espaciado
Un requisito frecuente es eliminar los caracteres de espaciado de una matriz de bytes ('\n', '\t', ' ', etc.). Si deseas eliminar los espacios de ambos extremos de un QByteArray, utiliza trimmed(). Si además deseas sustituir cada secuencia de caracteres de espaciado por un único carácter de espacio dentro de la matriz de bytes, utiliza simplified(). Para estos fines solo se reconocen los caracteres de espaciado ASCII.
Conversiones entre números y cadenas
Las funciones que realizan conversiones entre tipos de datos numéricos y representaciones como cadenas se ejecutan en la configuración regional de C, independientemente de la configuración regional del usuario. Utilice QLocale para realizar conversiones que tengan en cuenta la configuración regional entre números y cadenas.
Distinción entre mayúsculas y minúsculas
En QByteArray, el concepto de mayúsculas y minúsculas, así como la comparación independiente de mayúsculas y minúsculas, se limita al ASCII. Los caracteres no ASCII se tratan como si no tuvieran distinción de mayúsculas y minúsculas, ya que su distinción depende de la codificación. Esto afecta a las funciones que admiten una opción de no distinguir entre mayúsculas y minúsculas o que cambian el registro de sus argumentos. Entre las funciones afectadas se incluyen compare(), isLower(), isUpper(), toLower() y toUpper().
Este problema no afecta a los QString, ya que representan los caracteres utilizando Unicode.
Véase también QByteArrayView, QString y QBitArray.
Documentación sobre tipos de miembros
enum QByteArray::Base64Option
flags QByteArray::Base64Options
Esta enumeración contiene las opciones disponibles para la codificación y descodificación de Base64. Base64 se define en el RFC 4648, con las siguientes opciones:
| Constante | Valor | Descripción |
|---|---|---|
QByteArray::Base64Encoding | 0 | (por defecto) El alfabeto Base64 habitual, denominado simplemente «base64» |
QByteArray::Base64UrlEncoding | 1 | Un alfabeto alternativo, denominado «base64url», que sustituye dos caracteres del alfabeto para facilitar su uso en las URL. |
QByteArray::KeepTrailingEquals | 0 | (por defecto) Mantiene los signos de igual de relleno al final de los datos codificados, de modo que el tamaño de los datos sea siempre un múltiplo de cuatro. |
QByteArray::OmitTrailingEquals | 2 | Omite añadir los signos de igualdad de relleno al final de los datos codificados. |
QByteArray::IgnoreBase64DecodingErrors | 0 | Al decodificar datos codificados en Base64, ignora los errores en la entrada; los caracteres no válidos simplemente se omiten. Este valor de enumeración se ha añadido en Qt 5.15. |
QByteArray::AbortOnBase64DecodingErrors | 4 | Al decodificar datos codificados en Base64, se detiene ante el primer error de decodificación. Este valor de enumeración se ha añadido en Qt 5.15. |
QByteArray::fromBase64Encoding() y QByteArray::fromBase64() ignoran las opciones KeepTrailingEquals y OmitTrailingEquals. Si se especifica la opción IgnoreBase64DecodingErrors, no señalarán errores en caso de que falten signos de igualdad finales o de que haya demasiados. Si, por el contrario, se especifica AbortOnBase64DecodingErrors, la entrada no debe tener relleno o debe tener la cantidad correcta de signos igual.
El tipo `Base64Options` es una definición de tipo (`typedef`) para ` QFlags<Base64Option>`. Almacena una combinación OR de valores de `Base64Option`.
QByteArray::const_iterator
Este `typedef` proporciona un iterador `const` al estilo STL para ` QByteArray`.
Véase también QByteArray::const_reverse_iterator y QByteArray::iterator.
QByteArray::const_reverse_iterator
Este `typedef` proporciona un iterador inverso constante al estilo STL para ` QByteArray`.
Véase también QByteArray::reverse_iterator y QByteArray::const_iterator.
QByteArray::iterator
Este `typedef` proporciona un iterador no constante al estilo STL para ` QByteArray`.
Véase también QByteArray::reverse_iterator y QByteArray::const_iterator.
QByteArray::reverse_iterator
Este `typedef` proporciona un iterador inverso no constante, al estilo de la STL, para ` QByteArray`.
Véase también QByteArray::const_reverse_iterator y QByteArray::iterator.
Documentación de las funciones miembro
[constexpr noexcept] QByteArray::QByteArray()
Crea una matriz de bytes vacía.
Véase también ` isEmpty()`.
[explicit, since 6.8] QByteArray::QByteArray(QByteArrayView v)
Crea una matriz de bytes inicializada con los datos de la vista de matriz de bytes.
El QByteArray será nulo si y solo si v es nulo.
Esta función se introdujo en Qt 6.8.
QByteArray::QByteArray(const char *data, qsizetype size = -1)
Crea una matriz de bytes que contiene los primeros size bytes de la matriz data.
Si data es 0, se crea una matriz de bytes nula.
Si size es negativo, se supone que data apunta a una cadena terminada en «\0 » y su longitud se determina dinámicamente.
QByteArray realiza una copia profunda de los datos de la cadena.
Véase también fromRawData().
QByteArray::QByteArray(qsizetype size, Qt::Initialization)
Crea una matriz de bytes de tamaño size con contenido sin inicializar.
Por ejemplo:
QByteArray buffer(123, Qt::Uninitialized);QByteArray::QByteArray(qsizetype size, char ch)
Crea una matriz de bytes de tamaño size, en la que cada byte se establece en ch.
Véase también fill().
[noexcept] QByteArray::QByteArray(const QByteArray &other)
Crea una copia de un ` other`.
Esta operación tarda un tiempo constante, ya que QByteArray se comparte implícitamente. Esto hace que devolver un QByteArray desde una función sea muy rápido. Si se modifica una instancia compartida, se copiará (copia al escribir), lo que lleva un tiempo lineal.
Véase también operator=().
[noexcept default] QByteArray::QByteArray(QByteArray &&other)
Crea una instancia de `QByteArray` mediante la operación «move», de modo que apunte al mismo objeto al que apuntaba « other ».
[noexcept] QByteArray::~QByteArray()
Elimina la matriz de bytes.
QByteArray &QByteArray::append(const QByteArray &ba)
Añade la matriz de bytes ba al final de esta matriz de bytes.
Ejemplo:
QByteArray x("free");
QByteArray y("dom");
x.append(y);
// x == "freedom"Esto equivale a insert(size(), ba).
Nota: QByteArray es una clase compartida implícitamente. Por lo tanto, si se añade contenido a una matriz de bytes vacía, esta simplemente compartirá los datos contenidos en ba. En este caso, no se realiza ninguna copia de los datos, por lo que el tiempo de ejecución es constante. Si se modifica una instancia compartida, se copiará (copia al escribir), lo que conlleva un tiempo de ejecución lineal.
Si la matriz de bytes a la que se añaden datos no está vacía, se realiza una copia profunda de los datos, lo que lleva un tiempo lineal.
La función `append()` suele ser muy rápida (tiempo constante), ya que ` QByteArray ` preasigna espacio adicional al final de los datos, de modo que puede crecer sin necesidad de reasignar toda la matriz cada vez.
Véanse también operator+=(), prepend() y insert().
QByteArray &QByteArray::append(QByteArrayView data)
Añade ` data ` a esta matriz de bytes.
Esta es una función sobrecargada.
QByteArray &QByteArray::append(char ch)
Añade el byte ch a esta matriz de bytes.
Esta es una función sobrecargada.
QByteArray &QByteArray::append(const char *str)
Añade la cadena « str », terminada con «\0 », a esta matriz de bytes.
Esta es una función sobrecargada.
QByteArray &QByteArray::append(const char *str, qsizetype len)
Añade los primeros len bytes, a partir de str, a esta matriz de bytes y devuelve una referencia a dicha matriz. Los bytes añadidos pueden incluir bytes de tipo «\0 ».
Si len es negativo, se asumirá que str es una cadena terminada en «\0 » y la longitud que se va a copiar se determinará automáticamente mediante qstrlen().
Si len es cero o str es nulo, no se añade nada a la matriz de bytes. Asegúrate de que len no sea más larga que str.
Esta es una función sobrecargada.
QByteArray &QByteArray::append(qsizetype count, char ch)
Añade count copias del byte ch a esta matriz de bytes y devuelve una referencia a dicha matriz.
Si count es negativo o cero, no se añade nada a la matriz de bytes.
Esta es una función sobrecargada.
[since 6.6] QByteArray &QByteArray::assign(QByteArrayView v)
Sustituye el contenido de esta matriz de bytes por una copia de v y devuelve una referencia a esta matriz de bytes.
El tamaño de esta matriz de bytes será igual al tamaño de v.
Esta función solo asigna memoria si el tamaño de v supera la capacidad de esta matriz de bytes o si esta matriz de bytes es compartida.
Esta función se introdujo en Qt 6.6.
[since 6.6] template <typename InputIterator, QByteArray::if_input_iterator<InputIterator> = true> QByteArray &QByteArray::assign(InputIterator first, InputIterator last)
Sustituye el contenido de esta matriz de bytes por una copia de los elementos del rango del iterador [first, last) y devuelve una referencia a esta matriz de bytes.
El tamaño de esta matriz de bytes será igual al número de elementos del rango [first, last).
Esta función solo asignará memoria si el número de elementos del rango supera la capacidad de esta matriz de bytes o si esta matriz de bytes es compartida.
Nota: El comportamiento es indefinido si alguno de los argumentos es un iterador sobre *this o si [first, last) no es un rango válido.
Restricciones
Participa en la resolución de sobrecargas solo si InputIterator cumple los requisitos de un LegacyInputIterator.
Esta función se introdujo en Qt 6.6.
[since 6.6] QByteArray &QByteArray::assign(qsizetype n, char c)
Sustituye el contenido de esta matriz de bytes por n copias de c y devuelve una referencia a esta matriz de bytes.
El tamaño de esta matriz de bytes será igual a ` n`, que debe ser un valor no negativo.
Esta función solo asignará memoria si ` n ` supera la capacidad de esta matriz de bytes o si esta matriz de bytes es compartida.
Esta función se introdujo en Qt 6.6.
Véase también ` fill()`.
char QByteArray::at(qsizetype i) const
Devuelve el byte situado en la posición de índice i de la matriz de bytes.
i Debe ser un índice válido en la matriz de bytes (es decir, 0 <= i < size()).
Véase también operator[]().
char &QByteArray::back()
Devuelve una referencia al último byte de la matriz de bytes. Es lo mismo que ` operator[](size() - 1)`.
Esta función se proporciona para garantizar la compatibilidad con STL.
Advertencia: Llamar a esta función sobre una matriz de bytes vacía da lugar a un comportamiento indefinido.
Véase también ` front()`, ` at()` y ` operator[]()`.
char QByteArray::back() const
Devuelve el último byte de la matriz de bytes. Equivale a ` at(size() - 1)`.
Esta función se proporciona por motivos de compatibilidad con la STL.
Advertencia: Llamar a esta función sobre una matriz de bytes vacía da lugar a un comportamiento indefinido.
Véase también front(), at() y operator[]().
QByteArray::iterator QByteArray::begin()
Devuelve un iterador de estilo STL que apunta al primer byte de la matriz de bytes.
Advertencia: El iterador devuelto deja de ser válido al desacoplarse o cuando se modifica el ` QByteArray `.
Véase también ` constBegin()` y ` end()`.
[noexcept] QByteArray::const_iterator QByteArray::begin() const
Esta función sobrecarga la función « QByteArray::begin()».
qsizetype QByteArray::capacity() const
Devuelve el número máximo de bytes que se pueden almacenar en la matriz de bytes sin forzar una reasignación.
El único propósito de esta función es proporcionar un medio para ajustar con precisión el uso de memoria de QByteArray. En general, rara vez necesitarás llamar a esta función. Si quieres saber cuántos bytes hay en la matriz de bytes, llama a size().
Nota: una matriz de bytes asignada estáticamente indicará una capacidad de 0, aunque no esté vacía.
Nota: La posicióndel espacio libre en el bloque de memoria asignado no está definida. En otras palabras, no se debe dar por sentado que la memoria libre se encuentre siempre después de los elementos inicializados.
Véanse también reserve() y squeeze().
[noexcept] QByteArray::const_iterator QByteArray::cbegin() const
Devuelve un iterador const al estilo STL que apunta al primer byte de la matriz de bytes.
Advertencia: El iterador devuelto deja de ser válido al desasociarse o cuando se modifica el objeto ` QByteArray `.
Véase también ` begin()` y ` cend()`.
[noexcept] QByteArray::const_iterator QByteArray::cend() const
Devuelve un iterador const al estilo STL que apunta justo después del último byte de la matriz de bytes.
Advertencia: El iterador devuelto deja de ser válido al desasociarse o cuando se modifica el ` QByteArray `.
Véase también ` cbegin()` y ` end()`.
void QByteArray::chop(qsizetype n)
Elimina n bytes del final de la matriz de bytes.
Si ` n ` es mayor que ` size()`, el resultado es una matriz de bytes vacía.
Ejemplo:
QByteArray ba("STARTTLS\r\n");
ba.chop(2); // ba == "STARTTLS"Véanse también truncate(), resize() y first().
QByteArray QByteArray::chopped(qsizetype len) &&
QByteArray QByteArray::chopped(qsizetype len) const &
Devuelve una matriz de bytes que contiene los bytes situados más a la izquierda ( size() - len ) de esta matriz de bytes.
Nota: El comportamiento es indefinido si len es negativo o mayor que size().
Véase también endsWith(), first(), last(), sliced(), chop(), truncate() y slice().
void QByteArray::clear()
Borra el contenido de la matriz de bytes y la deja vacía.
Véase también resize() y isNull().
[noexcept, since 6.0] int QByteArray::compare(QByteArrayView bv, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
Devuelve un número entero menor, igual o mayor que cero, dependiendo de si este QByteArray se ordena antes, en la misma posición o después de QByteArrayView bv . La comparación se realiza teniendo en cuenta las mayúsculas y minúsculas cs.
Esta función se introdujo en Qt 6.0.
Véase también operator== y Character Case.
[noexcept] QByteArray::const_iterator QByteArray::constBegin() const
Devuelve un iterador const al estilo STL que apunta al primer byte de la matriz de bytes.
Advertencia: El iterador devuelto deja de ser válido al desacoplarse o cuando se modifica el objeto ` QByteArray `.
Véase también ` begin()` y ` constEnd()`.
[noexcept] const char *QByteArray::constData() const
Devuelve un puntero a los datos const almacenados en la matriz de bytes. El puntero se puede utilizar para acceder a los bytes que componen la matriz. Los datos están terminados por «\0 », a menos que el objeto ` QByteArray ` se haya creado a partir de datos sin procesar.
El puntero sigue siendo válido siempre que no se produzca ninguna desconexión y no se modifique el ` QByteArray `.
Esta función resulta especialmente útil para pasar una matriz de bytes a una función que acepte un ` const char *`.
Nota: Un ` QByteArray ` puede almacenar cualquier valor de byte, incluidos los caracteres «\0 », pero la mayoría de las funciones que admiten argumentos ` char * ` asumen que los datos terminan en el primer carácter «\0 » que encuentran.
Véanse también data(), operator[]() y fromRawData().
[noexcept] QByteArray::const_iterator QByteArray::constEnd() const
Devuelve un iterador const al estilo STL que apunta justo después del último byte de la matriz de bytes.
Advertencia: El iterador devuelto queda invalidado al desacoplarse o cuando se modifica el objeto ` QByteArray `.
Véase también ` constBegin()` y ` end()`.
[since 6.0] bool QByteArray::contains(QByteArrayView bv) const
Devuelve ` true ` si esta matriz de bytes contiene alguna aparición de la secuencia de bytes analizada por ` bv`; en caso contrario, devuelve ` false`.
Esta función se introdujo en Qt 6.0.
Véase también indexOf() y count().
bool QByteArray::contains(char ch) const
Devuelve « true » si la matriz de bytes contiene el byte ch; en caso contrario, devuelve « false ».
Esta es una función sobrecargada.
[since 6.0] qsizetype QByteArray::count(QByteArrayView bv) const
Devuelve el número de apariciones (que pueden solaparse) de la secuencia de bytes analizada por « bv » en esta matriz de bytes.
Esta función se introdujo en Qt 6.0.
Véase también ` contains()` y ` indexOf()`.
qsizetype QByteArray::count(char ch) const
Devuelve el número de veces que aparece el byte ch en la matriz de bytes.
Esta es una función sobrecargada.
Véanse también « contains()» y « indexOf()».
[noexcept] QByteArray::const_reverse_iterator QByteArray::crbegin() const
Devuelve un iterador inverso constante al estilo STL que apunta al primer byte de la matriz de bytes, en orden inverso.
Advertencia: El iterador devuelto deja de ser válido al desacoplarse o cuando se modifica el ` QByteArray `.
Véase también ` begin()`, ` rbegin()` y ` rend()`.
[noexcept] QByteArray::const_reverse_iterator QByteArray::crend() const
Devuelve un iterador inverso constante al estilo STL que apunta justo después del último byte de la matriz de bytes, en orden inverso.
Advertencia: El iterador devuelto queda invalidado al desacoplarse o cuando se modifica el ` QByteArray `.
Véase también « end()», « rend()» y « rbegin()».
char *QByteArray::data()
Devuelve un puntero a los datos almacenados en la matriz de bytes. El puntero se puede utilizar para acceder y modificar los bytes que componen la matriz. Los datos están terminados por «\0 », es decir, el número de bytes a los que se puede acceder a partir del puntero devuelto es size() + 1, incluyendo el terminador «\0 ».
Ejemplo:
QByteArray ba("Hello world");
char *data = ba.data();
while (*data) {
cout << "[" << *data << "]" << endl;
++data;
}El puntero sigue siendo válido siempre que no se produzca ninguna desconexión y no se modifique el « QByteArray ».
Para el acceso de solo lectura, constData() es más rápida porque nunca provoca que se produzca una copia profunda.
Esta función resulta especialmente útil para pasar una matriz de bytes a una función que acepte un ` const char *`.
El siguiente ejemplo realiza una copia del char* devuelto por data(), pero dañará el montón y provocará un fallo del sistema, ya que no asigna un byte para el «\0 » al final:
QString tmp = "test";
QByteArray text = tmp.toLocal8Bit();
char *data = new char[text.size()];
strcpy(data, text.data());
delete [] data;Este ejemplo asigna la cantidad correcta de espacio:
QString tmp = "test";
QByteArray text = tmp.toLocal8Bit();
char *data = new char[text.size() + 1];
strcpy(data, text.data());
delete [] data;Nota: Un ` QByteArray ` puede almacenar cualquier valor de byte, incluidos los caracteres «\0 », pero la mayoría de las funciones que aceptan argumentos de tipo ` char * ` asumen que los datos terminan en el primer carácter «\0 » que encuentran.
Véase también constData() y operator[]().
[noexcept] const char *QByteArray::data() const
Esta es una función sobrecargada.
QByteArray::iterator QByteArray::end()
Devuelve un iterador de estilo STL que apunta justo después del último byte del array de bytes.
Advertencia: El iterador devuelto deja de ser válido al desacoplarse o cuando se modifica el ` QByteArray `.
Véase también ` begin()` y ` constEnd()`.
[noexcept] QByteArray::const_iterator QByteArray::end() const
Esta función sobrecarga la función « QByteArray::end()».
[since 6.0] bool QByteArray::endsWith(QByteArrayView bv) const
Devuelve ` true ` si esta matriz de bytes termina con la secuencia de bytes que se puede consultar en bv; en caso contrario, devuelve ` false`.
Ejemplo:
QByteArray url("http://qt-project.org/doc/qt-5.0/qtdoc/index.html");
if (url.endsWith(".html"))
{/*...*/}Esta función se introdujo en Qt 6.0.
Véase también startsWith() y last().
bool QByteArray::endsWith(char ch) const
Devuelve ` true ` si esta matriz de bytes termina con el byte ` ch`; en caso contrario, devuelve ` false`.
Esta es una función sobrecargada.
[since 6.1] QByteArray::iterator QByteArray::erase(QByteArray::const_iterator first, QByteArray::const_iterator last)
Elimina de la matriz de bytes los caracteres comprendidos en el intervalo semiabierto [ first, last ). Devuelve un iterador al carácter al que hace referencia last antes de la eliminación.
Esta función se introdujo en Qt 6.1.
[since 6.5] QByteArray::iterator QByteArray::erase(QByteArray::const_iterator it)
Elimina el carácter indicado por ` it ` de la matriz de bytes. Devuelve un iterador que apunta al carácter inmediatamente posterior al carácter eliminado.
QByteArray ba = "abcdefg";
auto it = ba.erase(ba.cbegin()); // ba is now "bcdefg" and it points to "b"Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.5.
QByteArray &QByteArray::fill(char ch, qsizetype size = -1)
Establece cada byte de la matriz de bytes en « ch ». Si « size » es distinto de -1 (el valor por defecto), la matriz de bytes se redimensiona previamente a «size size ».
Ejemplo:
QByteArray ba("Istambul");
ba.fill('o');
// ba == "oooooooo"
ba.fill('X', 2);
// ba == "XX"Véase también ` resize()`.
[since 6.0] QByteArray QByteArray::first(qsizetype n) &&
[since 6.0] QByteArray QByteArray::first(qsizetype n) const &
Devuelve los primeros n bytes de la matriz de bytes.
Nota: El comportamiento es indefinido cuando n < 0 o n > size().
Ejemplo:
QByteArray x("Pineapple");
QByteArray y = x.first(4);
// y == "Pine"Estas funciones se introdujeron en Qt 6.0.
Véase también last(), sliced(), startsWith(), chopped(), chop(), truncate() y slice().
[static] QByteArray QByteArray::fromBase64(const QByteArray &base64, QByteArray::Base64Options options = Base64Encoding)
Devuelve una copia descodificada de la matriz Base64 base64, utilizando las opciones definidas en options. Si options contiene IgnoreBase64DecodingErrors (el valor por defecto), no se comprueba la validez de la entrada; los caracteres no válidos de la entrada se omiten, lo que permite que el proceso de descodificación continúe con los caracteres siguientes. Si options contiene AbortOnBase64DecodingErrors, la descodificación se detendrá en el primer carácter no válido.
Por ejemplo:
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>"El algoritmo utilizado para decodificar datos codificados en Base64 se define en el RFC 4648.
Devuelve los datos decodificados o, si se ha pasado la opción AbortOnBase64DecodingErrors y los datos de entrada no eran válidos, una matriz de bytes vacía.
Nota: Se recomienda utilizarla función fromBase64Encoding() en el código nuevo.
Véase también toBase64() y fromBase64Encoding().
[static] QByteArray::FromBase64Result QByteArray::fromBase64Encoding(QByteArray &&base64, QByteArray::Base64Options options = Base64Encoding)
[static] QByteArray::FromBase64Result QByteArray::fromBase64Encoding(const QByteArray &base64, QByteArray::Base64Options options = Base64Encoding)
Decodifica la matriz Base64 base64, utilizando las opciones definidas en options. Si options contiene IgnoreBase64DecodingErrors (el valor por defecto), no se comprueba la validez de la entrada; los caracteres no válidos de la entrada se omiten, lo que permite que el proceso de decodificación continúe con los caracteres siguientes. Si options contiene AbortOnBase64DecodingErrors, la decodificación se detendrá en el primer carácter no válido.
Por ejemplo:
void process(const QByteArray &);
if (auto result = QByteArray::fromBase64Encoding(encodedData))
process(*result);El algoritmo utilizado para decodificar datos codificados en Base64 se define en el RFC 4648.
Devuelve un objeto `QByteArrayFromBase64Result`, que contiene los datos decodificados y un indicador que señala si la decodificación se ha realizado correctamente. Si se ha pasado la opción ` AbortOnBase64DecodingErrors ` y los datos de entrada no son válidos, no se especifica qué contienen los datos decodificados.
Véase también toBase64().
[static] QByteArray QByteArray::fromCFData(CFDataRef data)
Crea un nuevo objeto ` QByteArray ` que contiene una copia del objeto `CFData` ` data`.
Véase también fromRawCFData(), fromRawData(), toRawCFData() y toCFData().
[static, since 6.5] QByteArray QByteArray::fromEcmaUint8Array(emscripten::val uint8array)
Crea un nuevo objeto ` QByteArray ` que contiene una copia del `Uint8Array` ` uint8array`.
Esta función transfiere datos desde un búfer de datos de JavaScript —al que no se puede acceder desde código C++— a la memoria del montón propiedad de un ` QByteArray`. El `Uint8Array` puede liberarse una vez que esta función devuelva un valor y se haya realizado la copia.
El argumento uint8array debe ser un emscripten::val que haga referencia a un objeto Uint8Array, por ejemplo, obtenido de una variable global de JavaScript:
emscripten::val uint8array = emscripten::val::global("g_uint8array");
QByteArray byteArray = QByteArray::fromEcmaUint8Array(uint8array);Esta función devuelve un ` QByteArray ` nulo si el tamaño del `Uint8Array` supera la capacidad máxima de ` QByteArray`, o si el argumento ` uint8array ` no es de tipo `Uint8Array`.
Esta función se introdujo en Qt 6.5.
Véase también ` toEcmaUint8Array()`.
[static] QByteArray QByteArray::fromHex(const QByteArray &hexEncoded)
Devuelve una copia descodificada de la matriz codificada en hexadecimal hexEncoded. No se comprueba la validez de la entrada; los caracteres no válidos de la entrada se omiten, lo que permite que el proceso de descodificación continúe con los caracteres siguientes.
Por ejemplo:
QByteArray text = QByteArray::fromHex("517420697320677265617421");
text.data(); // returns "Qt is great!"Véase también toHex().
[static] QByteArray QByteArray::fromNSData(const NSData *data)
Crea un nuevo objeto ` QByteArray ` que contiene una copia del `NSData` ` data`.
Véanse también fromRawNSData(), fromRawData(), toNSData() y toRawNSData().
[static] QByteArray QByteArray::fromPercentEncoding(const QByteArray &input, char percent = '%')
Decodifica « input » a partir de la codificación porcentual al estilo URI/URL.
Devuelve una matriz de bytes que contiene el texto descodificado. El parámetro percent permite utilizar un carácter distinto de «%» (por ejemplo, «_» o «=») como carácter de escape. Equivalente a input.percentDecoded(porcentaje).
Por ejemplo:
QByteArray text = QByteArray::fromPercentEncoding("Qt%20is%20great%33");
qDebug("%s", text.data()); // reports "Qt is great!"Véase también percentDecoded().
[static, since 6.11] QByteArray QByteArray::fromPercentEncoding(QByteArray &&input, char percent = '%')
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.11.
[static] QByteArray QByteArray::fromRawCFData(CFDataRef data)
Crea un objeto ` QByteArray ` que utiliza los bytes del objeto `CFData` ` data`.
Los bytes del objeto ` data` no se copian.
El autor de la llamada garantiza que el CFData no se eliminará ni modificará mientras exista este objeto QByteArray.
Véanse también fromCFData(), fromRawData(), toRawCFData() y toCFData().
[static] QByteArray QByteArray::fromRawData(const char *data, qsizetype size)
Crea un objeto ` QByteArray ` que utiliza los primeros ` size ` bytes del array ` data `. Los bytes no se copian. La variable ` QByteArray ` contendrá el puntero ` data `. El llamante garantiza que ` data ` no se eliminará ni se modificará mientras existan este ` QByteArray ` y cualquier copia del mismo que no haya sido modificada. En otras palabras, dado que QByteArray es una clase implícitamente compartida y la instancia devuelta por esta función contiene el puntero data, el llamante no debe eliminar data ni modificarlo directamente mientras existan el QByteArray devuelto y cualquier copia del mismo. Sin embargo, QByteArray no asume la propiedad de data, por lo que el destructor QByteArray nunca eliminará el data sin procesar, ni siquiera cuando se destruya el último QByteArray que haga referencia a data.
Cualquier intento posterior de modificar el contenido del QByteArray devuelto, o de cualquier copia realizada a partir de él, provocará que se cree una copia profunda del data antes de realizar la modificación. Esto garantiza que el propio data nunca sea modificado por QByteArray.
A continuación se muestra un ejemplo de cómo leer datos utilizando un ` QDataStream ` sobre datos sin procesar en memoria sin copiar dichos datos a 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);
//...Advertencia: Una matriz de bytes creada con fromRawData() no termina en «\0 », a menos que los datos sin procesar contengan un byte «\0 » en la posición size. Aunque esto no supone ningún problema para QDataStream o funciones como indexOf(), pasar la matriz de bytes a una función que acepte un const char * y que se espere que termine en «\0 » dará error.
Véase también setRawData(), data(), constData(), nullTerminate() y nullTerminated().
[static] QByteArray QByteArray::fromRawNSData(const NSData *data)
Crea un objeto ` QByteArray ` que utiliza los bytes del objeto `NSData` ` data`.
Los bytes del ` data` no se copian.
El llamante garantiza que el NSData no se eliminará ni se modificará mientras exista este objeto QByteArray.
Véase también fromNSData(), fromRawData(), toRawNSData() y toNSData().
[static] QByteArray QByteArray::fromStdString(const std::string &str)
Devuelve una copia de la cadena « str » como un objeto « QByteArray ».
Véase también toStdString() y QString::fromStdString().
char &QByteArray::front()
Devuelve una referencia al primer byte de la matriz de bytes. Es lo mismo que ` operator[](0)`.
Esta función se proporciona para garantizar la compatibilidad con STL.
Advertencia: Llamar a esta función sobre una matriz de bytes vacía da lugar a un comportamiento indefinido.
Véase también back(), at() y operator[]().
char QByteArray::front() const
Devuelve el primer byte de la matriz de bytes. Es lo mismo que ` at(0)`.
Esta función se proporciona para garantizar la compatibilidad con STL.
Advertencia: Llamar a esta función sobre una matriz de bytes vacía da lugar a un comportamiento indefinido.
Véase también back(), at() y operator[]().
[since 6.0] qsizetype QByteArray::indexOf(QByteArrayView bv, qsizetype from = 0) const
Devuelve la posición del índice en la que comienza la primera aparición de la secuencia de bytes analizada por bv en esta matriz de bytes, buscando hacia adelante a partir de la posición del índice from. Devuelve -1 si no se encuentra ninguna coincidencia.
Ejemplo:
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 -1Esta función se introdujo en Qt 6.0.
Véase también lastIndexOf(), contains() y count().
qsizetype QByteArray::indexOf(char ch, qsizetype from = 0) const
Devuelve la posición del índice en la que comienza la primera aparición del byte ch en esta matriz de bytes, buscando hacia adelante a partir de la posición del índice from. Devuelve -1 si no se encuentra ninguna coincidencia.
Ejemplo:
QByteArray ba("ABCBA");
ba.indexOf("B"); // returns 1
ba.indexOf("B", 1); // returns 1
ba.indexOf("B", 2); // returns 3
ba.indexOf("X"); // returns -1Esta es una función sobrecargada.
Véase también lastIndexOf() y contains().
[since 6.0] QByteArray &QByteArray::insert(qsizetype i, QByteArrayView data)
Inserta « data » en la posición de índice « i » y devuelve una referencia a esta matriz de bytes.
Ejemplo:
QByteArray ba("Meal");
ba.insert(1, QByteArrayView("ontr"));
// ba == "Montreal"En el caso de matrices de bytes de gran tamaño, esta operación puede resultar lenta (tiempo lineal), ya que requiere desplazar todos los bytes situados en los índices i y superiores al menos una posición más allá en la memoria.
Este array se amplía para dar cabida a la inserción. Si i se encuentra más allá del final del array, este se amplía primero con caracteres de espacio hasta alcanzar este i.
Esta función se introdujo en Qt 6.0.
Véase también append(), prepend(), replace() y remove().
QByteArray &QByteArray::insert(qsizetype i, const QByteArray &data)
Inserta « data » en la posición de índice « i » y devuelve una referencia a esta matriz de bytes.
Esta matriz se amplía para dar cabida a la inserción. Si i se encuentra más allá del final de la matriz, esta se amplía primero con caracteres de espacio hasta alcanzar este i.
Véase también append(), prepend(), replace() y remove().
QByteArray &QByteArray::insert(qsizetype i, const char *s)
Inserta s en la posición de índice i y devuelve una referencia a esta matriz de bytes.
Esta matriz se amplía para dar cabida a la inserción. Si i se encuentra más allá del final de la matriz, esta se amplía primero con caracteres de espacio hasta alcanzar esta posición i.
La función es equivalente a insert(i, QByteArrayView(s))
Véase también append(), prepend(), replace() y remove().
QByteArray &QByteArray::insert(qsizetype i, char ch)
Inserta el byte ch en la posición de índice i de la matriz de bytes.
Esta matriz se amplía para dar cabida a la inserción. Si i se encuentra más allá del final de la matriz, esta se amplía primero con caracteres de espacio para llegar a esta posición i.
Esta es una función sobrecargada.
QByteArray &QByteArray::insert(qsizetype i, const char *data, qsizetype len)
Inserta len bytes, a partir de data, en la posición i de la matriz de bytes.
Esta matriz se amplía para dar cabida a la inserción. Si i se encuentra más allá del final de la matriz, esta se amplía primero con caracteres de espacio para alcanzar dicho i.
Se trata de una función sobrecargada.
QByteArray &QByteArray::insert(qsizetype i, qsizetype count, char ch)
Inserta count copias del byte ch en la posición de índice i de la matriz de bytes.
Esta matriz se amplía para dar cabida a la inserción. Si i se encuentra más allá del final de la matriz, esta se amplía primero con caracteres de espacio hasta alcanzar dicho i.
Esta es una función sobrecargada.
[constexpr noexcept] bool QByteArray::isEmpty() const
Devuelve ` true ` si la matriz de bytes tiene tamaño 0; en caso contrario, devuelve ` false`.
Ejemplo:
QByteArray().isEmpty(); // returns true
QByteArray("").isEmpty(); // returns true
QByteArray("abc").isEmpty(); // returns falseVéase también size().
bool QByteArray::isLower() const
Devuelve ` true ` si esta matriz de bytes está en minúsculas, es decir, si es idéntica a su representación tras aplicar la función ` toLower()`.
Ten en cuenta que esto no significa que la matriz de bytes solo contenga letras minúsculas, sino únicamente que no contiene letras mayúsculas ASCII.
Véanse también isUpper() y toLower().
[noexcept] bool QByteArray::isNull() const
Devuelve ` true ` si esta matriz de bytes es nula; en caso contrario, devuelve ` false`.
Ejemplo:
QByteArray().isNull(); // returns true
QByteArray("").isNull(); // returns false
QByteArray("abc").isNull(); // returns falseQt distingue entre matrices de bytes nulas y matrices de bytes vacías por razones históricas. Para la mayoría de las aplicaciones, lo que importa es si una matriz de bytes contiene datos o no, y esto se puede determinar utilizando isEmpty().
Véase también isEmpty().
bool QByteArray::isUpper() const
Devuelve ` true ` si esta matriz de bytes está en mayúsculas, es decir, si es idéntica a su representación tras aplicar la función ` toUpper()`.
Ten en cuenta que esto no significa que la matriz de bytes solo contenga letras mayúsculas, sino únicamente que no contiene letras minúsculas ASCII.
Véanse también isLower() y toUpper().
[noexcept, since 6.3] bool QByteArray::isValidUtf8() const
Devuelve ` true ` si esta matriz de bytes contiene datos válidos codificados en UTF-8; en caso contrario, devuelve ` false `.
Esta función se introdujo en Qt 6.3.
[since 6.0] QByteArray QByteArray::last(qsizetype n) &&
[since 6.0] QByteArray QByteArray::last(qsizetype n) const &
Devuelve los últimos n bytes de la matriz de bytes.
Nota: El comportamiento es indefinido cuando « n » < 0 o « n » > « size()».
Ejemplo:
QByteArray x("Pineapple");
QByteArray y = x.last(5);
// y == "apple"Estas funciones se introdujeron en Qt 6.0.
Véase también first(), sliced(), endsWith(), chopped(), chop(), truncate() y slice().
[since 6.0] qsizetype QByteArray::lastIndexOf(QByteArrayView bv, qsizetype from) const
Devuelve la posición en el índice del inicio de la última aparición de la secuencia de bytes analizada por bv en esta matriz de bytes, buscando hacia atrás desde la posición en el índice from.
Si from es -1, la búsqueda comienza en el último carácter; si es -2, en el penúltimo carácter, y así sucesivamente.
Devuelve -1 si no se encuentra ninguna coincidencia.
Ejemplo:
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 -1Nota: Al buscar una coincidencia de longitud 0 ( bv), la coincidencia situada al final de los datos queda excluida de la búsqueda si se utiliza un valor negativo para from, aunque normalmente se considere que -1 busca desde el final de la matriz de bytes: la coincidencia situada al final se encuentra después del último carácter, por lo que queda excluida. Para incluir dicha coincidencia vacía final, se debe especificar un valor positivo para from u omitir por completo el parámetro from.
Esta función se introdujo en Qt 6.0.
Véanse también indexOf(), contains() y count().
[since 6.2] qsizetype QByteArray::lastIndexOf(QByteArrayView bv) const
Devuelve la posición en el índice del inicio de la última aparición de la secuencia de bytes analizada por ` bv ` en esta matriz de bytes, buscando hacia atrás desde el final de la matriz. Devuelve -1 si no se encuentra ninguna coincidencia.
Ejemplo:
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 -1Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.2.
Véase también indexOf(), contains() y count().
qsizetype QByteArray::lastIndexOf(char ch, qsizetype from = -1) const
Devuelve la posición en el índice del inicio de la última aparición de byte ch en esta matriz de bytes, buscando hacia atrás a partir de la posición en el índice from. Si from es -1 (el valor por defecto), la búsqueda comienza en el último byte (en el índice size() - 1). Devuelve -1 si no se encuentra ninguna coincidencia.
Ejemplo:
QByteArray ba("ABCBA");
ba.lastIndexOf("B"); // returns 3
ba.lastIndexOf("B", 3); // returns 3
ba.lastIndexOf("B", 2); // returns 1
ba.lastIndexOf("X"); // returns -1Esta es una función sobrecargada.
Véase también indexOf() y contains().
QByteArray QByteArray::left(qsizetype len) &&
QByteArray QByteArray::left(qsizetype len) const &
Devuelve una matriz de bytes que contiene los primeros len bytes de esta matriz de bytes.
Si sabes que ` len ` no puede estar fuera de límites, utiliza ` first()` en lugar de esta función en el código nuevo, ya que es más rápida.
Se devuelve la totalidad de la matriz de bytes si ` len ` es mayor que ` size()`.
Devuelve un ` QByteArray ` vacío si ` len ` es menor que 0.
Véase también first(), last(), startsWith(), chopped(), chop() y truncate().
QByteArray QByteArray::leftJustified(qsizetype width, char fill = ' ', bool truncate = false) const
Devuelve una matriz de bytes de tamaño width que contiene esta matriz de bytes rellenada con el byte fill.
Si truncate es falso y el size() de la matriz de bytes es mayor que width, entonces la matriz de bytes devuelta es una copia de esta matriz de bytes.
Si truncate es verdadero y la función size() de la matriz de bytes es mayor que width, se eliminan todos los bytes de la copia de la matriz de bytes que se encuentren después de la posición width y se devuelve dicha copia.
Ejemplo:
QByteArray x("apple");
QByteArray y = x.leftJustified(8, '.'); // y == "apple..."Véase también rightJustified().
[constexpr noexcept] qsizetype QByteArray::length() const
Es lo mismo que « size()».
[static constexpr noexcept, since 6.8] qsizetype QByteArray::maxSize()
[constexpr noexcept, since 6.8] qsizetype QByteArray::max_size() const
Devuelve el número máximo de elementos que, en teoría, puede contener la matriz de bytes. En la práctica, este número puede ser mucho menor, ya que está limitado por la cantidad de memoria disponible en el sistema.
Estas funciones se introdujeron en Qt 6.8.
QByteArray QByteArray::mid(qsizetype pos, qsizetype len = -1) &&
QByteArray QByteArray::mid(qsizetype pos, qsizetype len = -1) const &
Devuelve una matriz de bytes que contiene len bytes de esta matriz de bytes, a partir de la posición pos.
Si sabes que pos y len no pueden estar fuera de límites, utiliza sliced() en lugar de esto en el código nuevo, ya que es más rápido.
Si len es -1 (el valor por defecto), o si pos + len >= size(), devuelve una matriz de bytes que contiene todos los bytes desde la posición pos hasta el final de la matriz de bytes.
Véase también first(), last(), sliced(), chopped(), chop(), truncate() y slice().
[since 6.10] QByteArray &QByteArray::nullTerminate()
Si los datos de esta matriz de bytes no están terminados en nulo, este método realizará una copia profunda de los datos y los terminará en nulo.
Un ` QByteArray ` termina en nulo por defecto; sin embargo, en algunos casos (por ejemplo, al utilizar ` fromRawData()`), los datos no terminan necesariamente con un carácter ` \0 `, lo que podría suponer un problema al llamar a métodos que esperan una cadena terminada en nulo (por ejemplo, la API de C).
Esta función se introdujo en Qt 6.10.
Véanse también nullTerminated(), fromRawData() y setRawData().
[since 6.10] QByteArray QByteArray::nullTerminated() &&
[since 6.10] QByteArray QByteArray::nullTerminated() const &
Devuelve una copia de esta matriz de bytes que siempre termina en nulo. Véase nullTerminate().
Estas funciones se introdujeron en Qt 6.10.
Véase también nullTerminate(), fromRawData() y setRawData().
[static] QByteArray QByteArray::number(int n, int base = 10)
Devuelve una matriz de bytes que representa el número entero n en forma de texto.
Devuelve una matriz de bytes que contiene una cadena que representa n, utilizando el base especificado (diez por defecto). Se admiten bases del 2 al 36, utilizando letras para los dígitos superiores a 9: A es diez, B es once y así sucesivamente.
Ejemplo:
int n = 63;
QByteArray::number(n); // returns "63"
QByteArray::number(n, 16); // returns "3f"
QByteArray::number(n, 16).toUpper(); // returns "3F"Nota: El formato del número no está localizado; se utiliza la configuración regional predeterminada de C, independientemente de la configuración regional del usuario. Utilice QLocale para realizar conversiones que tengan en cuenta la configuración regional entre números y cadenas.
Véase también setNum() y toInt().
[static] QByteArray QByteArray::number(long n, int base = 10)
Esta es una función sobrecargada.
Véase también toLong().
[static] QByteArray QByteArray::number(qlonglong n, int base = 10)
Esta es una función sobrecargada.
Véase también toLongLong().
[static] QByteArray QByteArray::number(qulonglong n, int base = 10)
Esta es una función sobrecargada.
Véase también toULongLong().
[static] QByteArray QByteArray::number(uint n, int base = 10)
Esta es una función sobrecargada.
Véase también toUInt().
[static] QByteArray QByteArray::number(ulong n, int base = 10)
Esta es una función sobrecargada.
Véase también toULong().
[static] QByteArray QByteArray::number(double n, char format = 'g', int precision = 6)
Devuelve una matriz de bytes que representa el número de coma flotante n en formato de texto.
Devuelve una matriz de bytes que contiene una cadena que representa n, con un format y un precision dados, con los mismos significados que para QLocale::toString(double, char, int). Por ejemplo:
QByteArray ba = QByteArray::number(12.3456, 'E', 3);
// ba == 1.235E+01Esta es una función sobrecargada.
Véanse también toDouble() y QLocale::FloatingPointPrecisionOption.
[since 6.4] QByteArray QByteArray::percentDecoded(char percent = '%') const &
Decodifica la codificación porcentual al estilo URI/URL.
Devuelve una matriz de bytes que contiene el texto descodificado. El parámetro percent permite utilizar un carácter distinto de «%» (por ejemplo, «_» o «=») como carácter de escape.
Por ejemplo:
QByteArray encoded("Qt%20is%20great%33");
QByteArray decoded = encoded.percentDecoded(); // Set to "Qt is great!"Nota: Si se introduce una entrada no válida (como una cadena que contenga la secuencia «%G5», que no es un número hexadecimal válido), la salida tampoco será válida. A modo de ejemplo: la secuencia «%G5» podría decodificarse como «W».
Esta función se introdujo en Qt 6.4.
Véanse también toPercentEncoding() y QUrl::fromPercentEncoding().
[since 6.11] QByteArray QByteArray::percentDecoded(char percent = '%') &&
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.11.
QByteArray &QByteArray::prepend(QByteArrayView ba)
Añade al principio de esta matriz de bytes la vista de matriz de bytes ba y devuelve una referencia a dicha matriz de bytes.
Esta operación suele ser muy rápida (tiempo constante), ya que QByteArray preasigna espacio adicional al principio de los datos, de modo que puede ampliarse sin necesidad de reasignar toda la matriz cada vez.
Ejemplo:
QByteArray x("ship");
QByteArray y("air");
x.prepend(y);
// x == "airship"Esto equivale a insert(0, ba).
Véase también append() y insert().
QByteArray &QByteArray::prepend(char ch)
Añade al principio de esta matriz de bytes el byte ch.
Esta es una función sobrecargada.
QByteArray &QByteArray::prepend(const QByteArray &ba)
Añade « ba » al principio de esta matriz de bytes.
Esta es una función sobrecargada.
QByteArray &QByteArray::prepend(const char *str)
Añade al principio de esta matriz de bytes la cadena « str », terminada con «\0 ».
Esta es una función sobrecargada.
QByteArray &QByteArray::prepend(const char *str, qsizetype len)
Añade al principio de esta matriz de bytes un len e de bytes a partir de la dirección str. Los bytes añadidos pueden incluir bytes del tipo «\0 ».
Esta es una función sobrecargada.
QByteArray &QByteArray::prepend(qsizetype count, char ch)
Añade al principio de esta matriz de bytes count copias de byte ch.
Esta es una función sobrecargada.
void QByteArray::push_back(const QByteArray &other)
Esta función se proporciona para garantizar la compatibilidad con la STL. Es equivalente a `append(other)`.
[since 6.0] void QByteArray::push_back(QByteArrayView str)
Es lo mismo que append(str).
Se trata de una función sobrecargada.
Esta función se introdujo en Qt 6.0.
void QByteArray::push_back(char ch)
Es lo mismo que `append(ch)`.
Esta es una función sobrecargada.
void QByteArray::push_back(const char *str)
Es lo mismo que `append(str)`.
Esta es una función sobrecargada.
void QByteArray::push_front(const QByteArray &other)
Esta función se proporciona para garantizar la compatibilidad con STL. Es equivalente a prepend(other).
[since 6.0] void QByteArray::push_front(QByteArrayView str)
Es lo mismo que prepend(str).
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.0.
void QByteArray::push_front(char ch)
Es lo mismo que prepend(ch).
Se trata de una función sobrecargada.
void QByteArray::push_front(const char *str)
Es lo mismo que «prepend(str)».
Se trata de una función sobrecargada.
QByteArray::reverse_iterator QByteArray::rbegin()
Devuelve un iterador inverso al estilo STL que apunta al primer byte del array de bytes, en orden inverso.
Advertencia: El iterador devuelto deja de ser válido al desacoplarse o cuando se modifica el ` QByteArray `.
Véase también begin(), crbegin() y rend().
[noexcept] QByteArray::const_reverse_iterator QByteArray::rbegin() const
Esta es una función sobrecargada.
QByteArray &QByteArray::remove(qsizetype pos, qsizetype len)
Elimina len bytes del array, empezando por el índice pos, y devuelve una referencia al array.
Si pos está fuera de rango, no ocurre nada. Si pos es válido, pero pos + len es mayor que el tamaño del array, este se trunca en la posición pos.
Ejemplo:
QByteArray ba("Montreal");
ba.remove(1, 4);
// ba == "Meal"La eliminación de elementos conservará la capacidad del array y no reducirá la cantidad de memoria asignada. Para liberarse de la capacidad sobrante y liberar tanta memoria como sea posible, llama a squeeze() tras el último cambio en el tamaño del array.
Véase también insert(), replace() y squeeze().
[since 6.5] QByteArray &QByteArray::removeAt(qsizetype pos)
Elimina el carácter en el índice pos. Si pos está fuera de límites (es decir, pos >= size()), esta función no realiza ninguna acción.
Esta función se introdujo en Qt 6.5.
Véase también remove().
[since 6.5] QByteArray &QByteArray::removeFirst()
Elimina el primer carácter de esta matriz de bytes. Si la matriz de bytes está vacía, esta función no realiza ninguna acción.
Esta función se introdujo en Qt 6.5.
Véase también remove().
[since 6.1] template <typename Predicate> QByteArray &QByteArray::removeIf(Predicate pred)
Elimina del array de bytes todos aquellos bytes para los que el predicado ` pred ` devuelva «true». Devuelve una referencia al array de bytes.
Esta función se introdujo en Qt 6.1.
Véase también remove().
[since 6.5] QByteArray &QByteArray::removeLast()
Elimina el último carácter de esta matriz de bytes. Si la matriz de bytes está vacía, esta función no realiza ninguna acción.
Esta función se introdujo en Qt 6.5.
Véase también ` remove()`.
QByteArray::reverse_iterator QByteArray::rend()
Devuelve un iterador inverso al estilo STL que apunta justo después del último byte de la matriz de bytes, en orden inverso.
Advertencia: El iterador devuelto queda invalidado al desasociarse o cuando se modifica la clase ` QByteArray `.
Véase también end(), crend() y rbegin().
[noexcept] QByteArray::const_reverse_iterator QByteArray::rend() const
Esta es una función sobrecargada.
QByteArray QByteArray::repeated(qsizetype times) const
Devuelve una copia de esta matriz de bytes repetida el número especificado de times.
Si times es menor que 1, se devuelve una matriz de bytes vacía.
Ejemplo:
QByteArray ba("ab");
ba.repeated(4); // returns "abababab"QByteArray &QByteArray::replace(qsizetype pos, qsizetype len, QByteArrayView after)
Sustituye los bytes « len » a partir de la posición de índice « pos » por la matriz de bytes « after », y devuelve una referencia a dicha matriz de bytes.
Ejemplo:
QByteArray x("Say yes!");
QByteArray y("no");
x.replace(4, 3, y);
// x == "Say no!"Véase también insert() y remove().
[since 6.0] QByteArray &QByteArray::replace(QByteArrayView before, QByteArrayView after)
Sustituye cada aparición de la matriz de bytes before por la matriz de bytes after.
Ejemplo:
QByteArray ba("colour behaviour flavour neighbour");
ba.replace(QByteArray("ou"), QByteArray("o"));
// ba == "color behavior flavor neighbor"Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.0.
QByteArray &QByteArray::replace(char before, QByteArrayView after)
Sustituye cada aparición del byte before por la matriz de bytes after.
Se trata de una función sobrecargada.
QByteArray &QByteArray::replace(char before, char after)
Sustituye cada aparición del byte before por el byte after.
Se trata de una función sobrecargada.
QByteArray &QByteArray::replace(const char *before, qsizetype bsize, const char *after, qsizetype asize)
Sustituye cada aparición de los bytes « bsize » que comienzan en « before » por los bytes « asize » que comienzan en « after ». Dado que los tamaños de las cadenas vienen dados por « bsize » y « asize », pueden contener bytes «'\0 » y no es necesario que terminen en «'\0 ».
Esta es una función sobrecargada.
QByteArray &QByteArray::replace(qsizetype pos, qsizetype len, const char *after, qsizetype alen)
Sustituye los bytes « len » a partir de la posición de índice « pos » por los bytes « alen » a partir de la posición « after ». Los bytes insertados pueden incluir bytes «'\0'».
Esta es una función sobrecargada.
void QByteArray::reserve(qsizetype size)
Intenta asignar memoria para, como mínimo, size bytes.
Si sabes de antemano cuál será el tamaño de la matriz de bytes, puedes llamar a esta función; además, si llamas a ` resize()` con frecuencia, es probable que obtengas un mejor rendimiento.
Si tienes dudas sobre cuánto espacio se necesitará, suele ser mejor utilizar un límite superior como ` size`, o una estimación alta del tamaño más probable, si un límite superior estricto fuera mucho mayor que este. Si size es una subestimación, la matriz crecerá según sea necesario una vez que se supere el tamaño reservado, lo que puede dar lugar a una asignación mayor que la que habría supuesto tu mejor sobreestimación y ralentizará la operación que la desencadena.
Advertencia: reserve () reserva memoria, pero no modifica el tamaño de la matriz de bytes. Acceder a datos más allá del final de la matriz de bytes es un comportamiento indefinido. Si necesitas acceder a memoria más allá del final actual de la matriz, utiliza resize().
El único propósito de esta función es proporcionar un medio para ajustar con precisión el uso de memoria de ` QByteArray`. En general, rara vez necesitarás llamar a esta función.
Véanse también squeeze() y capacity().
void QByteArray::resize(qsizetype size)
Establece el tamaño de la matriz de bytes en size bytes.
Si « size » es mayor que el tamaño actual, la matriz de bytes se amplía hasta alcanzar los « size » bytes, añadiéndose los bytes adicionales al final. Los nuevos bytes no están inicializados.
Si ` size ` es menor que el tamaño actual, los bytes más allá de la posición ` size ` se excluyen de la matriz de bytes.
Nota: Aunque resize() aumentará la capacidad si es necesario, nunca la reduce. Para eliminar el exceso de capacidad, utiliza squeeze().
Véanse también size(), truncate() y squeeze().
[since 6.4] void QByteArray::resize(qsizetype newSize, char c)
Establece el tamaño de la matriz de bytes en newSize bytes.
Si ` newSize ` es mayor que el tamaño actual, la matriz de bytes se amplía hasta alcanzar los ` newSize ` bytes, añadiéndose los bytes adicionales al final. Los nuevos bytes se inicializan con ` c`.
Si newSize es menor que el tamaño actual, los bytes más allá de la posición newSize se excluyen de la matriz de bytes.
Nota: Aunque resize() aumentará la capacidad si es necesario, nunca la reduce. Para eliminar el exceso de capacidad, utiliza squeeze().
Esta función se introdujo en Qt 6.4.
Véase también size(), truncate() y squeeze().
[since 6.8] void QByteArray::resizeForOverwrite(qsizetype size)
Cambia el tamaño de la matriz de bytes a size bytes. Si el tamaño de la matriz de bytes aumenta, los nuevos bytes no están inicializados.
El comportamiento es idéntico al de ` resize(size)`.
Esta función se introdujo en Qt 6.8.
Véase también ` resize()`.
QByteArray QByteArray::right(qsizetype len) &&
QByteArray QByteArray::right(qsizetype len) const &
Devuelve una matriz de bytes que contiene los últimos len bytes de esta matriz de bytes.
Si sabes que ` len ` no puede estar fuera de límites, utiliza ` last()` en lugar de esto en el código nuevo, ya que es más rápido.
Se devuelve la matriz de bytes completa si len es mayor que size().
Devuelve un ` QByteArray ` vacío si ` len ` es menor que 0.
Véase también endsWith(), last(), first(), sliced(), chopped(), chop(), truncate() y slice().
QByteArray QByteArray::rightJustified(qsizetype width, char fill = ' ', bool truncate = false) const
Devuelve una matriz de bytes de tamaño ` width ` que contiene el byte ` fill ` seguido de esta matriz de bytes.
Si truncate es falso y el tamaño de la matriz de bytes es mayor que width, la matriz de bytes devuelta es una copia de esta matriz de bytes.
Si truncate es verdadero y el tamaño de la matriz de bytes es mayor que width, la matriz de bytes resultante se trunca en la posición width.
Ejemplo:
QByteArray x("apple");
QByteArray y = x.rightJustified(8, '.'); // y == "...apple"Véase también leftJustified().
QByteArray &QByteArray::setNum(int n, int base = 10)
Representa el número entero n como texto.
Establece esta matriz de bytes como una cadena que representa n en base base (diez por defecto) y devuelve una referencia a esta matriz de bytes. Se admiten las bases del 2 al 36, utilizando letras para los dígitos superiores a 9; A es diez, B es once y así sucesivamente.
Ejemplo:
QByteArray ba;
int n = 63;
ba.setNum(n); // ba == "63"
ba.setNum(n, 16); // ba == "3f"Nota: El formato del número no está localizado; se utiliza la configuración regional predeterminada de C, independientemente de la configuración regional del usuario. Utilice QLocale para realizar conversiones que tengan en cuenta la configuración regional entre números y cadenas.
Véase también number() y toInt().
QByteArray &QByteArray::setNum(long n, int base = 10)
Esta es una función sobrecargada.
Véase también toLong().
QByteArray &QByteArray::setNum(qlonglong n, int base = 10)
Esta es una función sobrecargada.
Véase también toLongLong().
QByteArray &QByteArray::setNum(qulonglong n, int base = 10)
Esta es una función sobrecargada.
Véase también toULongLong().
QByteArray &QByteArray::setNum(short n, int base = 10)
Esta es una función sobrecargada.
Véase también toShort().
QByteArray &QByteArray::setNum(uint n, int base = 10)
Esta es una función sobrecargada.
Véase también toUInt().
QByteArray &QByteArray::setNum(ulong n, int base = 10)
Esta es una función sobrecargada.
Véase también toULong().
QByteArray &QByteArray::setNum(ushort n, int base = 10)
Esta es una función sobrecargada.
Véase también toUShort().
QByteArray &QByteArray::setNum(double n, char format = 'g', int precision = 6)
Representa el número de coma flotante n como texto.
Establece esta matriz de bytes como una cadena que representa n, con los parámetros format y precision (con los mismos significados que en QLocale::toString(double, char, int)), y devuelve una referencia a esta matriz de bytes.
Se trata de una función sobrecargada.
Véanse también toDouble() y QLocale::FloatingPointPrecisionOption.
QByteArray &QByteArray::setNum(float n, char format = 'g', int precision = 6)
Representa el número de coma flotante n como texto.
Establece esta matriz de bytes como una cadena que representa n, con un format y un precision dados (con los mismos significados que para QLocale::toString(double, char, int)), y devuelve una referencia a esta matriz de bytes.
Se trata de una función sobrecargada.
Véanse también toFloat() y QLocale::FloatingPointPrecisionOption.
QByteArray &QByteArray::setRawData(const char *data, qsizetype size)
Restablece el objeto ` QByteArray ` para que utilice los primeros ` size ` bytes del array ` data `. Los bytes no se copian. La variable ` QByteArray ` contendrá el puntero ` data `. El llamante garantiza que ` data ` no se eliminará ni se modificará mientras existan este ` QByteArray ` y cualquier copia del mismo que no haya sido modificada.
Esta función puede utilizarse en lugar de fromRawData() para reutilizar objetos QByteArray existentes y así ahorrar reasignaciones de memoria.
Véanse también fromRawData(), data(), constData(), nullTerminate() y nullTerminated().
void QByteArray::shrink_to_fit()
Esta función se ofrece para garantizar la compatibilidad con la STL. Es equivalente a squeeze().
QByteArray QByteArray::simplified() const
Devuelve una copia de esta matriz de bytes en la que se han eliminado los caracteres de espaciado del principio y del final, y en la que cada secuencia de caracteres de espaciado internos se ha sustituido por un único espacio.
Los caracteres de espaciado son aquellos para los que la función estándar de C++ ` isspace() ` devuelve ` true ` en la configuración regional C; se trata de los caracteres ASCII de tabulación «\t », salto de línea «\n », retorno de carro «\r », tabulación vertical «\v », avance de página «\f » y espacio « ».
Ejemplo:
QByteArray ba(" lots\t of\nwhitespace\r\n ");
ba = ba.simplified();
// ba == "lots of whitespace";Véase también trimmed(), QChar::SpecialCharacter y Spacing Characters.
[constexpr noexcept] qsizetype QByteArray::size() const
Devuelve el número de bytes que contiene esta matriz de bytes.
El último byte de la matriz de bytes se encuentra en la posición size() - 1. Además, QByteArray garantiza que el byte en la posición size() sea siempre «\0 », de modo que puedas utilizar el valor devuelto por data() y constData() como argumentos de funciones que esperan cadenas terminadas en «\0 ». Si el objeto ` QByteArray ` se creó a partir de un ` raw data ` que no incluía el byte de terminación «\0 » al final, entonces ` QByteArray ` no lo añade automáticamente a menos que se cree una copia profunda.
Ejemplo:
QByteArray ba("Hello");
qsizetype n = ba.size(); // n == 5
ba.data()[0]; // returns 'H'
ba.data()[4]; // returns 'o'
ba.data()[5]; // returns '\0'Véase también isEmpty() y resize().
[since 6.8] QByteArray &QByteArray::slice(qsizetype pos, qsizetype n)
Modifica esta matriz de bytes para que comience en la posición pos, con una extensión de n bytes, y devuelve una referencia a dicha matriz de bytes.
Nota: El comportamiento es indefinido si pos < 0, n < 0 o pos + n > size().
Ejemplo:
QByteArray x = "Five pineapples"_ba;
x.slice(5); // x == "pineapples"
x.slice(4, 3); // x == "app"Esta función se introdujo en Qt 6.8.
Véase también sliced(), first(), last(), chopped(), chop() y truncate().
[since 6.8] QByteArray &QByteArray::slice(qsizetype pos)
Modifica esta matriz de bytes para que comience en la posición pos y se extienda hasta su final, y devuelve una referencia a dicha matriz de bytes.
Nota: El comportamiento es indefinido si pos < 0 o si pos > size().
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.8.
Véase también sliced(), first(), last(), chopped(), chop() y truncate().
[since 6.0] QByteArray QByteArray::sliced(qsizetype pos, qsizetype n) &&
[since 6.0] QByteArray QByteArray::sliced(qsizetype pos, qsizetype n) const &
Devuelve una matriz de bytes que contiene los bytes n de este objeto, a partir de la posición pos.
Nota: El comportamiento es indefinido cuando pos < 0, n < 0 o pos + n > size().
Ejemplo:
QByteArray x("Five pineapples");
QByteArray y = x.sliced(5, 4); // y == "pine"
QByteArray z = x.sliced(5); // z == "pineapples"Estas funciones se introdujeron en Qt 6.0.
Véase también first(), last(), chopped(), chop(), truncate() y slice().
[since 6.0] QByteArray QByteArray::sliced(qsizetype pos) &&
[since 6.0] QByteArray QByteArray::sliced(qsizetype pos) const &
Devuelve una matriz de bytes que contiene los bytes que comienzan en la posición pos de este objeto y se extienden hasta el final del mismo.
Nota: El comportamiento es indefinido cuando pos < 0 o pos > size().
Estas funciones se introdujeron en Qt 6.0.
Véase también first(), last(), chopped(), chop(), truncate() y slice().
QList<QByteArray> QByteArray::split(char sep) const
Divide la matriz de bytes en submatrices cada vez que aparece sep, y devuelve la lista de dichas matrices. Si sep no coincide en ningún punto de la matriz de bytes, split() devuelve una lista de un solo elemento que contiene dicha matriz de bytes.
void QByteArray::squeeze()
Libera toda la memoria que no sea necesaria para almacenar los datos de la matriz.
El único propósito de esta función es proporcionar un medio para ajustar con precisión el uso de memoria de QByteArray. En general, rara vez necesitarás llamar a esta función.
Véanse también reserve() y capacity().
[since 6.0] bool QByteArray::startsWith(QByteArrayView bv) const
Devuelve « true » si esta matriz de bytes comienza con la secuencia de bytes que se puede consultar en bv; en caso contrario, devuelve « false ».
Ejemplo:
QByteArray url("ftp://ftp.qt-project.org/");
if (url.startsWith("ftp:"))
{/*...*/}Esta función se introdujo en Qt 6.0.
Véase también endsWith() y first().
bool QByteArray::startsWith(char ch) const
Devuelve ` true ` si esta matriz de bytes comienza con el byte ` ch`; en caso contrario, devuelve ` false`.
Esta es una función sobrecargada.
[noexcept] void QByteArray::swap(QByteArray &other)
Intercambia esta matriz de bytes con other. Esta operación es muy rápida y nunca falla.
QByteArray QByteArray::toBase64(QByteArray::Base64Options options = Base64Encoding) const
Devuelve una copia de la matriz de bytes, codificada utilizando las opciones « 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"El algoritmo utilizado para codificar datos en Base64 se define en el RFC 4648.
Véase también fromBase64().
CFDataRef QByteArray::toCFData() const
Crea un objeto CFData a partir de un objeto ` QByteArray`.
El autor de la llamada es el propietario del objeto CFData y se encarga de liberarlo.
Véase también toRawCFData(), fromCFData(), fromRawCFData() y fromRawData().
double QByteArray::toDouble(bool *ok = nullptr) const
Devuelve la matriz de bytes convertida a un valor de tipo « double ».
Devuelve infinito si se produce un desbordamiento durante la conversión, o 0,0 si la conversión falla por otros motivos (por ejemplo, un desbordamiento por debajo del rango).
Si ok no es nullptr, el error se notifica estableciendo *ok en false, y el éxito estableciendo *ok en 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 == falseAdvertencia: El contenido de « QByteArray » solo puede contener caracteres numéricos válidos, lo que incluye el signo más/menos, el carácter «e» utilizado en notación científica y el punto decimal. La inclusión de la unidad o de caracteres adicionales provoca un error de conversión.
Nota: La conversión del número se realiza en la configuración regional predeterminada de C, independientemente de la configuración regional del usuario. Utilice QLocale para realizar conversiones que tengan en cuenta la configuración regional entre números y cadenas.
Esta función ignora los espacios en blanco iniciales y finales.
Véase también number().
[since 6.5] emscripten::val QByteArray::toEcmaUint8Array()
Crea un `Uint8Array` a partir de un ` QByteArray`.
Esta función transfiere datos desde la memoria del montón (heap) que pertenece a un ` QByteArray ` a un búfer de datos de JavaScript. La función asigna memoria y copia los datos en un `ArrayBuffer`, y devuelve una vista `Uint8Array` de dicho búfer.
Los objetos de JavaScript poseen una copia de los datos, por lo que este ` QByteArray ` puede eliminarse de forma segura una vez realizada la copia.
QByteArray byteArray = "test";
emscripten::val uint8array = byteArray.toEcmaUint8Array();Esta función se introdujo en Qt 6.5.
Véase también fromEcmaUint8Array().
float QByteArray::toFloat(bool *ok = nullptr) const
Devuelve la matriz de bytes convertida a un valor de tipo « float ».
Devuelve infinito si se produce un desbordamiento durante la conversión, o 0,0 si la conversión falla por otros motivos (por ejemplo, un desbordamiento por debajo del rango).
Si ok no es nullptr, se notifica el error estableciendo *ok en false, y el éxito estableciendo *ok en 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 == falseAdvertencia: El contenido de « QByteArray » solo puede contener caracteres numéricos válidos, lo que incluye el signo más/menos, el carácter «e» utilizado en notación científica y el punto decimal. La inclusión de la unidad o de caracteres adicionales provoca un error de conversión.
Nota: La conversión del número se realiza en la configuración regional predeterminada de C, independientemente de la configuración regional del usuario. Utilice ` QLocale ` para realizar conversiones que tengan en cuenta la configuración regional entre números y cadenas.
Esta función ignora los espacios en blanco iniciales y finales.
Véase también number().
QByteArray QByteArray::toHex(char separator = '\0') const
Devuelve una copia codificada en hexadecimal de la matriz de bytes.
La codificación hexadecimal utiliza los números del 0 al 9 y las letras de la a a la f.
Si separator no es «\0 », se inserta el carácter separador entre los bytes hexadecimales.
Ejemplo:
QByteArray macAddress = QByteArray::fromHex("123456abcdef");
macAddress.toHex(':'); // returns "12:34:56:ab:cd:ef"
macAddress.toHex(0); // returns "123456abcdef"Véase también fromHex().
int QByteArray::toInt(bool *ok = nullptr, int base = 10) const
Devuelve la matriz de bytes convertida a un objeto ` int ` utilizando la base ` base`, que por defecto es diez. Se admiten las bases 0 y del 2 al 36, utilizando letras para los dígitos superiores a 9; A es diez, B es once, y así sucesivamente.
Si ` base ` es 0, la base se determina automáticamente siguiendo estas reglas: si la matriz de bytes comienza por «0x», se supone que es hexadecimal (base 16); en caso contrario, si empieza por «0b», se supone que es binario (base 2); si no, si empieza por «0», se supone que es octal (base 8); en cualquier otro caso, se supone que es decimal.
Devuelve 0 si la conversión falla.
Si ` ok ` no es ` nullptr`, el fallo se notifica estableciendo `*ok ` en ` false`, y el éxito estableciendo `*ok ` en ` 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 == falseNota: La conversión del número se realiza en la configuración regional predeterminada de C, independientemente de la configuración regional del usuario. Utiliza ` QLocale ` para realizar conversiones entre números y cadenas que tengan en cuenta la configuración regional.
Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.
Véase también number().
long QByteArray::toLong(bool *ok = nullptr, int base = 10) const
Devuelve la matriz de bytes convertida a un entero de tipo « long » utilizando la base base, que por defecto es diez. Se admiten las bases 0 y del 2 al 36, utilizando letras para los dígitos superiores a 9; A es diez, B es once, y así sucesivamente.
Si ` base ` es 0, la base se determina automáticamente siguiendo estas reglas: si la matriz de bytes comienza por «0x», se considera hexadecimal (base 16); en caso contrario, si empieza por «0b», se supone que es binario (base 2); si no, si empieza por «0», se supone que es octal (base 8); en cualquier otro caso, se supone que es decimal.
Devuelve 0 si la conversión falla.
Si ` ok ` no es ` nullptr`, el fallo se notifica estableciendo `*ok ` en ` false`, y el éxito estableciendo `*ok ` en ` 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 == falseNota: La conversión del número se realiza en la configuración regional predeterminada de C, independientemente de la configuración regional del usuario. Utiliza QLocale para realizar conversiones entre números y cadenas que tengan en cuenta la configuración regional.
Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.
Véase también number().
qlonglong QByteArray::toLongLong(bool *ok = nullptr, int base = 10) const
Devuelve la matriz de bytes convertida a un ` long long ` utilizando la base ` base`, que por defecto es diez. Se admiten las bases 0 y del 2 al 36, utilizando letras para los dígitos superiores a 9; A es diez, B es once, y así sucesivamente.
Si « base » es 0, la base se determina automáticamente siguiendo estas reglas: si la matriz de bytes comienza por «0x», se considera hexadecimal (base 16); en caso contrario, si empieza por «0b», se supone que es binario (base 2); si no, si empieza por «0», se supone que es octal (base 8); en cualquier otro caso, se supone que es decimal.
Devuelve 0 si la conversión falla.
Si ` ok ` no es ` nullptr`, el fallo se notifica estableciendo * `ok ` en ` false`, y el éxito estableciendo * `ok ` en ` true`.
Nota: La conversión del número se realiza en la configuración regional predeterminada de C, independientemente de la configuración regional del usuario. Utiliza QLocale para realizar conversiones entre números y cadenas que tengan en cuenta la configuración regional.
Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.
Véase también number().
QByteArray QByteArray::toLower() const
Devuelve una copia de la matriz de bytes en la que cada letra ASCII mayúscula se ha convertido a minúscula.
Ejemplo:
QByteArray x("Qt by THE QT COMPANY");
QByteArray y = x.toLower();
// y == "qt by the qt company"Véase también isLower(), toUpper() y Character Case.
NSData *QByteArray::toNSData() const
Crea un objeto `NSData` a partir de un objeto ` QByteArray`.
El objeto NSData se libera automáticamente.
Véase también fromNSData(), fromRawNSData(), fromRawData() y toRawNSData().
QByteArray QByteArray::toPercentEncoding(const QByteArray &exclude = QByteArray(), const QByteArray &include = QByteArray(), char percent = '%') const
Devuelve una copia de esta matriz de bytes codificada en formato porcentual, al estilo URI/URL. El parámetro ` percent ` permite sustituir el carácter predeterminado «%» por otro.
De forma predeterminada, esta función codificará todos los bytes que no sean uno de los siguientes:
ALFABÉTICOS (de «a» a «z» y de «A» a «Z») / DÍGITOS (del 0 al 9) / «-» / «.» / «_» / «~»
Para evitar que se codifiquen determinados bytes, pásalos a exclude. Para forzar la codificación de determinados bytes, pásalos a include. El carácter percent siempre se codifica.
Ejemplo:
QByteArray text = "{¿una cadena sospechosa?}";
QByteArray ba = text.toPercentEncoding("{}", "s");
qDebug("%s", ba.constData());
// muestra «{a fi%73hy %73tring%3F}»La codificación hexadecimal utiliza los números del 0 al 9 y las letras mayúsculas de la A a la F.
Véase también fromPercentEncoding() y QUrl::toPercentEncoding().
CFDataRef QByteArray::toRawCFData() const
Crea un objeto CFData que utiliza los bytes de QByteArray.
Los bytes de QByteArray no se copian.
El autor de la llamada garantiza que el ` QByteArray ` no se eliminará ni modificará mientras exista este objeto `CFData`.
Véase también ` toCFData()`, ` fromRawCFData()`, ` fromCFData()` y ` fromRawData()`.
NSData *QByteArray::toRawNSData() const
Crea un objeto NSData que utiliza los bytes de ` QByteArray`.
Los bytes de QByteArray no se copian.
El autor de la llamada garantiza que el QByteArray no se eliminará ni modificará mientras exista este objeto NSData.
Véase también fromRawNSData(), fromNSData(), fromRawData() y toNSData().
short QByteArray::toShort(bool *ok = nullptr, int base = 10) const
Devuelve la matriz de bytes convertida a un « short » utilizando la base base, que por defecto es diez. Se admiten las bases 0 y del 2 al 36, utilizando letras para los dígitos superiores a 9; A es diez, B es once, y así sucesivamente.
Si ` base ` es 0, la base se determina automáticamente siguiendo estas reglas: si la matriz de bytes comienza por «0x», se considera hexadecimal (base 16); en caso contrario, si empieza por «0b», se supone que es binario (base 2); si no, si empieza por «0», se supone que es octal (base 8); en cualquier otro caso, se supone que es decimal.
Devuelve 0 si la conversión falla.
Si ` ok ` no es ` nullptr`, el fallo se notifica estableciendo `*ok ` en ` false`, y el éxito estableciendo `*ok ` en ` true`.
Nota: La conversión del número se realiza en la configuración regional predeterminada de C, independientemente de la configuración regional del usuario. Utiliza QLocale para realizar conversiones entre números y cadenas que tengan en cuenta la configuración regional.
Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.
Véase también number().
std::string QByteArray::toStdString() const
Devuelve un objeto `std::string` con los datos contenidos en este ` QByteArray`.
Este operador resulta especialmente útil para pasar un ` QByteArray ` a una función que acepte un objeto `std::string`.
Véase también fromStdString() y QString::toStdString().
uint QByteArray::toUInt(bool *ok = nullptr, int base = 10) const
Devuelve la matriz de bytes convertida a un objeto ` unsigned int ` utilizando la base ` base`, que por defecto es diez. Se admiten las bases 0 y del 2 al 36, utilizando letras para los dígitos superiores a 9; A es diez, B es once, y así sucesivamente.
Si base es 0, la base se determina automáticamente siguiendo estas reglas: si la matriz de bytes comienza por «0x», se supone que es hexadecimal (base 16); en caso contrario, si empieza por «0b», se supone que es binario (base 2); de lo contrario, si empieza por «0», se supone que es octal (base 8); en cualquier otro caso, se supone que es decimal.
Devuelve 0 si la conversión falla.
Si ` ok ` no es ` nullptr`, el fallo se notifica estableciendo `*ok ` en ` false`, y el éxito estableciendo `*ok ` en ` true`.
Nota: La conversión del número se realiza en la configuración regional predeterminada de C, independientemente de la configuración regional del usuario. Utiliza QLocale para realizar conversiones entre números y cadenas que tengan en cuenta la configuración regional.
Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.
Véase también number().
ulong QByteArray::toULong(bool *ok = nullptr, int base = 10) const
Devuelve la matriz de bytes convertida a un ` unsigned long int ` utilizando la base ` base`, que por defecto es diez. Se admiten las bases 0 y del 2 al 36, utilizando letras para los dígitos superiores a 9; A es diez, B es once y así sucesivamente.
Si ` base ` es 0, la base se determina automáticamente siguiendo estas reglas: si la matriz de bytes comienza por «0x», se supone que es hexadecimal (base 16); en caso contrario, si comienza por «0b», se supone que es binario (base 2); si no, si comienza por «0», se supone que es octal (base 8); en cualquier otro caso, se supone que es decimal.
Devuelve 0 si la conversión falla.
Si ` ok ` no es ` nullptr`, el fallo se notifica estableciendo `*ok ` en ` false`, y el éxito estableciendo `*ok ` en ` true`.
Nota: La conversión del número se realiza en la configuración regional predeterminada de C, independientemente de la configuración regional del usuario. Utiliza QLocale para realizar conversiones entre números y cadenas que tengan en cuenta la configuración regional.
Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.
Véase también number().
qulonglong QByteArray::toULongLong(bool *ok = nullptr, int base = 10) const
Devuelve la matriz de bytes convertida a un objeto ` unsigned long long ` utilizando la base ` base`, que por defecto es diez. Se admiten las bases 0 y del 2 al 36, utilizando letras para los dígitos superiores a 9; A es diez, B es once, y así sucesivamente.
Si ` base ` es 0, la base se determina automáticamente siguiendo estas reglas: si la matriz de bytes comienza por «0x», se supone que es hexadecimal (base 16); en caso contrario, si empieza por «0b», se supone que es binario (base 2); si no, si empieza por «0», se supone que es octal (base 8); en cualquier otro caso, se supone que es decimal.
Devuelve 0 si la conversión falla.
Si ` ok ` no es ` nullptr`, el fallo se notifica estableciendo `*ok ` en ` false`, y el éxito estableciendo `*ok ` en ` true`.
Nota: La conversión del número se realiza en la configuración regional predeterminada de C, independientemente de la configuración regional del usuario. Utilice ` QLocale ` para realizar conversiones entre números y cadenas que tengan en cuenta la configuración regional.
Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.
Véase también number().
ushort QByteArray::toUShort(bool *ok = nullptr, int base = 10) const
Devuelve la matriz de bytes convertida a un objeto ` unsigned short ` utilizando la base ` base`, que por defecto es diez. Se admiten las bases 0 y del 2 al 36, utilizando letras para los dígitos superiores a 9; A es diez, B es once, y así sucesivamente.
Si ` base ` es 0, la base se determina automáticamente siguiendo estas reglas: si la matriz de bytes comienza por «0x», se supone que es hexadecimal (base 16); en caso contrario, si empieza por «0b», se supone que es binario (base 2); si no, si empieza por «0», se supone que es octal (base 8); en cualquier otro caso, se supone que es decimal.
Devuelve 0 si la conversión falla.
Si ` ok ` no es ` nullptr`, el fallo se notifica estableciendo `*ok ` en ` false`, y el éxito estableciendo `*ok ` en ` true`.
Nota: La conversión del número se realiza en la configuración regional predeterminada de C, independientemente de la configuración regional del usuario. Utiliza QLocale para realizar conversiones entre números y cadenas que tengan en cuenta la configuración regional.
Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.
Véase también number().
QByteArray QByteArray::toUpper() const
Devuelve una copia de la matriz de bytes en la que cada letra ASCII en minúscula se ha convertido a mayúscula.
Ejemplo:
QByteArray x("Qt by THE QT COMPANY");
QByteArray y = x.toUpper();
// y == "QT BY THE QT COMPANY"Véase también isUpper(), toLower() y Character Case.
QByteArray QByteArray::trimmed() const
Devuelve una copia de esta matriz de bytes en la que se han eliminado los caracteres de espaciado del principio y del final.
Los caracteres de espaciado son aquellos para los que la función estándar de C++ ` isspace() ` devuelve ` true ` en la configuración regional C; se trata de los caracteres ASCII de tabulación `'\t'`, salto de línea `'\n'`, retorno de carro `'\r'`, tabulación vertical `'\v'`, salto de página `'\f'` y espacio `' '`.
Ejemplo:
QByteArray ba(" lots\t of\nwhitespace\r\n ");
ba = ba.trimmed();
// ba == "lots\t of\nwhitespace";A diferencia de « simplified()», «trimmed()» no modifica los espacios internos.
Véase también simplified(), QChar::SpecialCharacter y Spacing Characters.
void QByteArray::truncate(qsizetype pos)
Trunca la matriz de bytes en la posición de índice pos.
Si pos se encuentra más allá del final de la matriz, no ocurre nada.
Ejemplo:
QByteArray ba("Stockholm");
ba.truncate(5); // ba == "Stock"Véase también chop(), resize() y first().
Nota: En el código nuevo,utiliza en su lugar ` constData()`.
Devuelve un puntero a los datos almacenados en la matriz de bytes. El puntero se puede utilizar para acceder a los bytes que componen la matriz. Los datos terminan en «\0 ».
El puntero sigue siendo válido siempre que no se produzca ninguna desconexión y no se modifique el QByteArray.
Este operador resulta especialmente útil para pasar una matriz de bytes a una función que acepte un « const char * ».
Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_BYTEARRAY ` al compilar tus aplicaciones.
Nota: Un ` QByteArray ` puede almacenar cualquier valor de byte, incluidos los caracteres «'\0 », pero la mayoría de las funciones que admiten argumentos ` char * ` asumen que los datos terminan en el primer carácter «'\0 » que encuentran.
Véase también constData().
[noexcept, since 6.10] QByteArray::operator std::string_view() const
Convierte este objeto ` QByteArray ` en un objeto ` std::string_view `. La vista de cadena devuelta abarcará la totalidad de la matriz de bytes.
Esta función se introdujo en Qt 6.10.
QByteArray &QByteArray::operator+=(const QByteArray &ba)
Añade la matriz de bytes ba al final de esta matriz de bytes y devuelve una referencia a dicha matriz.
Ejemplo:
QByteArray x("free");
QByteArray y("dom");
x += y;
// x == "freedom"Nota: QByteArray es una clase compartida implícitamente. Por lo tanto, si se añaden datos a una matriz de bytes vacía, esta simplemente compartirá los datos contenidos en ba. En este caso, no se realiza ninguna copia de los datos, por lo que el tiempo de ejecución es constante. Si se modifica una instancia compartida, se copiará (copia al escribir), lo que conlleva un tiempo de ejecución lineal.
Si la matriz de bytes a la que se añaden elementos no está vacía, se realiza una copia profunda de los datos, lo que lleva un tiempo lineal.
Esta operación no suele sufrir la sobrecarga de la asignación de memoria, ya que QByteArray preasigna espacio adicional al final de los datos para que pueda crecer sin necesidad de reasignar memoria en cada operación de anexión.
Véanse también append() y prepend().
QByteArray &QByteArray::operator+=(char ch)
Añade el byte ch al final de esta matriz de bytes y devuelve una referencia a dicha matriz.
Esta es una función sobrecargada.
QByteArray &QByteArray::operator+=(const char *str)
Añade la cadena «\0 », terminada con « str », al final de esta matriz de bytes y devuelve una referencia a dicha matriz.
Se trata de una función sobrecargada.
[noexcept] QByteArray &QByteArray::operator=(QByteArray &&other)
Asigna « other » a esta instancia de « QByteArray ».
[noexcept] QByteArray &QByteArray::operator=(const QByteArray &other)
Asigna ` other ` a esta matriz de bytes y devuelve una referencia a dicha matriz.
QByteArray &QByteArray::operator=(const char *str)
Asigna « str » a esta matriz de bytes.
str Se supone que apunta a una cadena terminada en nulo, y su longitud se determina dinámicamente.
Esta es una función sobrecargada.
char &QByteArray::operator[](qsizetype i)
Devuelve el byte situado en la posición de índice i como una referencia modificable.
i Debe ser una posición de índice válida en la matriz de bytes (es decir, 0 <= i < size()).
Ejemplo:
QByteArray ba("Hello, world");
cout << ba[0]; // prints H
ba[7] = 'W';
// ba == "Hello, World"Véase también at().
char QByteArray::operator[](qsizetype i) const
Igual que en (i).
Esta es una función sobrecargada.
Elementos no miembros relacionados
[since 6.1] template <typename T> qsizetype erase(QByteArray &ba, const T &t)
Elimina todos los elementos de la matriz de bytes ba que sean iguales a t. Devuelve el número de elementos eliminados, si los hay.
Esta función se introdujo en Qt 6.1.
Véase también erase_if.
[since 6.1] template <typename Predicate> qsizetype erase_if(QByteArray &ba, Predicate pred)
Elimina todos los elementos para los que el predicado ` pred ` devuelve «verdadero» de la matriz de bytes ` ba`. Devuelve el número de elementos eliminados, si los hay.
Esta función se introdujo en Qt 6.1.
Véase también erase.
quint16 qChecksum(QByteArrayView data, Qt::ChecksumType standard = Qt::ChecksumIso3309)
Devuelve la suma de comprobación CRC-16 de data.
La suma de comprobación es independiente del orden de los bytes (endianidad) y se calculará de acuerdo con el algoritmo publicado en standard. Por defecto, se utiliza el algoritmo publicado en la norma ISO 3309 (Qt::ChecksumIso3309).
Nota: Esta función es una implementación de 16 bits con caché (tabla de 16 entradas) del algoritmo CRC-16-CCITT.
QByteArray qCompress(const QByteArray &data, int compressionLevel = -1)
Comprime la matriz de bytes « data » y devuelve los datos comprimidos en una nueva matriz de bytes.
El parámetro ` compressionLevel ` especifica el nivel de compresión que se debe aplicar. Los valores válidos están comprendidos entre 0 y 9, correspondiendo el 9 a la mayor compresión (es decir, datos comprimidos más pequeños) a costa de utilizar un algoritmo más lento. Los valores más pequeños (8, 7, …, 1) proporcionan una compresión cada vez menor a velocidades ligeramente superiores. El valor 0 corresponde a una compresión nula. El valor por defecto es -1, que especifica la compresión predeterminada de zlib.
Véase también qUncompress(const QByteArray &data).
QByteArray qCompress(const uchar *data, qsizetype nbytes, int compressionLevel = -1)
Comprime los primeros nbytes de data con un nivel de compresión de compressionLevel y devuelve los datos comprimidos en una nueva matriz de bytes.
Se trata de una función sobrecargada.
QByteArray qUncompress(const QByteArray &data)
Descomprime la matriz de bytes « data » y devuelve una nueva matriz de bytes con los datos descomprimidos.
Devuelve un ` QByteArray ` vacío si los datos de entrada estaban dañados.
Esta función descomprimirá datos comprimidos con ` qCompress()` desde esta versión de Qt y cualquier versión anterior, remontándose hasta Qt 3.1, cuando se añadió esta característica.
Nota: Si deseas utilizar esta función para descomprimir datos externos que se hayan comprimido con zlib, primero debes anteponer una cabecera de cuatro bytes a la matriz de bytes que contiene los datos. La cabecera debe contener la longitud esperada (en bytes) de los datos descomprimidos, expresada como un entero de 32 bits sin signo y en formato big-endian. No obstante, este número es solo una indicación del tamaño inicial del búfer de salida. Si el tamaño indicado es demasiado pequeño para albergar el resultado, el tamaño del búfer de salida seguirá aumentando hasta que el resultado quepa o hasta que el sistema se quede sin memoria. Por lo tanto, a pesar de la cabecera de 32 bits, esta función, en plataformas de 64 bits, puede generar más de 4 GiB de salida.
Nota: En las versiones de Qt anteriores a la 6.5, el funcionamiento con más de 2 GiB de datos no era fiable; en las versiones anteriores a la 6.0, no funcionaba en absoluto.
Véase también qCompress().
QByteArray qUncompress(const uchar *data, qsizetype nbytes)
Descomprime los primeros nbytes de data y devuelve una nueva matriz de bytes con los datos descomprimidos.
Esta es una función sobrecargada.
int qstrcmp(const char *str1, const char *str2)
Una función segura de « strcmp() ».
Compara str1 y str2. Devuelve un valor negativo si str1 es menor que str2, 0 si str1 es igual a str2 o un valor positivo si str1 es mayor que str2.
Si ambas cadenas son nullptr, se consideran iguales; en caso contrario, si alguna de ellas es nullptr, se considera menor que la otra (incluso si la otra es una cadena vacía).
Véanse también qstrncmp(), qstricmp(), qstrnicmp(), Character Case y QByteArray::compare().
char *qstrcpy(char *dst, const char *src)
Copia todos los caracteres hasta el «\0 » (incluido este) desde src a dst y devuelve un puntero a dst. Si src es nullptr, devuelve inmediatamente nullptr.
Esta función da por hecho que dst tiene capacidad suficiente para almacenar el contenido de src.
Nota: Si dst y src se solapan, el comportamiento es indefinido.
Véase también qstrncpy().
char *qstrdup(const char *src)
Devuelve una cadena duplicada.
Asigna espacio para una copia de ` src`, la copia y devuelve un puntero a la copia. Si ` src ` es ` nullptr`, devuelve inmediatamente ` nullptr`.
La propiedad se transfiere al llamante, por lo que la cadena devuelta debe eliminarse utilizando ` delete[]`.
int qstricmp(const char *str1, const char *str2)
Una función segura de « stricmp() ».
Compara str1 y str2, ignorando las diferencias de mayúsculas y minúsculas en los caracteres ASCII.
Devuelve un valor negativo si str1 es menor que str2, 0 si str1 es igual a str2 o un valor positivo si str1 es mayor que str2.
Si ambas cadenas son nullptr, se consideran iguales; en caso contrario, si alguna de ellas es nullptr, se considera menor que la otra (incluso si la otra es una cadena vacía).
Véase también qstrcmp(), qstrncmp(), qstrnicmp(), Character Case y QByteArray::compare().
size_t qstrlen(const char *str)
Una función segura « strlen() ».
Devuelve el número de caracteres que preceden al carácter de terminación «\0 », o 0 si str es nullptr.
Véase también qstrnlen().
int qstrncmp(const char *str1, const char *str2, size_t len)
Una función segura de « strncmp() ».
Compara como máximo len bytes de str1 y str2.
Devuelve un valor negativo si str1 es menor que str2, 0 si str1 es igual a str2 o un valor positivo si str1 es mayor que str2.
Si ambas cadenas son nullptr, se consideran iguales; en caso contrario, si alguna de ellas es nullptr, se considera menor que la otra (incluso si la otra es una cadena vacía o si len es 0).
Véanse también qstrcmp(), qstricmp(), qstrnicmp(), Character Case y QByteArray::compare().
char *qstrncpy(char *dst, const char *src, size_t len)
Una función segura de « strncpy() ».
Copia como máximo len bytes de src (deteniéndose en len o en el carácter de fin «\0 », lo que ocurra primero) en dst. Garantiza que dst termine en «\0 », salvo cuando dst sea nullptr o len sea 0. Si src es nullptr, devuelve nullptr; en caso contrario, devuelve dst.
Esta función da por hecho que dst tiene una longitud mínima de len caracteres.
Nota: Si dst y src se solapan, el comportamiento es indefinido.
Nota: A diferencia de strncpy(), esta función no escribe «\0 » en todos los bytes de len de dst, sino que se detiene tras el carácter de terminación «\0 ». En este sentido, es similar a strncpy_s() de C11.
Véase también qstrcpy().
int qstrnicmp(const char *s1, const char *s2, size_t len)
Una función segura de « strnicmp() ».
Compara como máximo len bytes de s1 y s2, ignorando las diferencias en el caso de los caracteres ASCII.
Devuelve un valor negativo si s1 es menor que s2, 0 si s1 es igual a s2 o un valor positivo si s1 es mayor que s2.
Si ambas cadenas son nullptr, se consideran iguales; en caso contrario, si cualquiera de ellas es nullptr, se considera menor que la otra (incluso si la otra es una cadena vacía o si len es 0).
Véanse también qstrcmp(), qstrncmp(), qstricmp(), Character Case y QByteArray::compare().
size_t qstrnlen(const char *str, size_t maxlen)
Una función segura « strnlen() ».
Devuelve el número de caracteres que preceden al carácter de terminación «\0 », pero como máximo « maxlen ». Si « str » es « nullptr », devuelve 0.
Véase también ` qstrlen()`.
[noexcept] bool operator!=(const QByteArray &lhs, const QByteArray &rhs)
Devuelve « true » si la matriz de bytes lhs no es igual a la matriz de bytes rhs; en caso contrario, devuelve « false ».
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator!=(const QByteArray &lhs, const char *const &rhs)
Devuelve « true » si la matriz de bytes lhs no es igual a la cadena rhs, terminada con «'\0 »; en caso contrario, devuelve « false ».
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator!=(const char *const &lhs, const QByteArray &rhs)
Devuelve ` true ` si la cadena ` lhs `, terminada en «\0 », no es igual a la matriz de bytes ` rhs`; en caso contrario, devuelve ` false`.
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept, since 6.4] QByteArray operator""_ba(const char *str, size_t size)
Operador literal que crea un « QByteArray » a partir de los primeros size caracteres del literal de cadena de caracteres str.
El ` QByteArray ` se crea en tiempo de compilación, y los datos de la cadena generada se almacenan en el segmento de solo lectura del archivo objeto compilado. Los literales duplicados pueden compartir la misma memoria de solo lectura. Esta funcionalidad es intercambiable con ` QByteArrayLiteral`, pero ahorra tener que escribir cuando hay muchos literales de cadena en el código.
El siguiente código crea un ` QByteArray`:
using namespace Qt::StringLiterals;
auto str = "hello"_ba;Esta función se introdujo en Qt 6.4.
Véase también ` Qt::Literals::StringLiterals`.
QByteArray operator+(const QByteArray &a1, const QByteArray &a2)
Devuelve una matriz de bytes que es el resultado de concatenar la matriz de bytes a1 y la matriz de bytes a2.
Véase también QByteArray::operator+=().
[since 6.9] QByteArray operator+(QByteArrayView lhs, const QByteArray &rhs)
[since 6.9] QByteArray operator+(const QByteArray &lhs, QByteArrayView rhs)
Devuelve una matriz de bytes que es el resultado de concatenar lhs y rhs.
Estas funciones se introdujeron en Qt 6.9.
Véase también QByteArray::operator+=().
QByteArray operator+(char a1, const QByteArray &a2)
Devuelve una matriz de bytes que es el resultado de concatenar la matriz de bytes a1 y la matriz de bytes a2.
Esta es una función sobrecargada.
QByteArray operator+(const QByteArray &a1, char a2)
Devuelve una matriz de bytes que es el resultado de concatenar la matriz de bytes a1 y el byte a2.
Esta es una función sobrecargada.
QByteArray operator+(const QByteArray &a1, const char *a2)
Devuelve una matriz de bytes que es el resultado de concatenar la matriz de bytes a1 y la cadena terminada en '\0' a2.
Esta es una función sobrecargada.
QByteArray operator+(const char *a1, const QByteArray &a2)
Devuelve una matriz de bytes que es el resultado de concatenar la cadena «\0 », terminada en ' ', a1, y la matriz de bytes a2.
Esta es una función sobrecargada.
[noexcept] bool operator<(const QByteArray &lhs, const QByteArray &rhs)
Devuelve « true » si la matriz de bytes lhs es léxicamente menor que la matriz de bytes rhs; en caso contrario, devuelve « false ».
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator<(const QByteArray &lhs, const char *const &rhs)
Devuelve « true » si la matriz de bytes lhs es léxicamente menor que la cadena rhs, terminada por «'\0 »; en caso contrario, devuelve « false ».
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator<(const char *const &lhs, const QByteArray &rhs)
Devuelve ` true ` si la cadena ` lhs `, terminada en «\0 », es léxicamente menor que la matriz de bytes ` rhs`; en caso contrario, devuelve ` false`.
Esta es una función sobrecargada.
Véase también QByteArray::compare().
QDataStream &operator<<(QDataStream &out, const QByteArray &ba)
Escribe la matriz de bytes ba en el flujo out y devuelve una referencia al flujo.
Véase también «Serialización detipos de datos de Qt».
[noexcept] bool operator<=(const QByteArray &lhs, const QByteArray &rhs)
Devuelve ` true ` si la matriz de bytes ` lhs ` es léxicamente menor o igual que la matriz de bytes ` rhs`; en caso contrario, devuelve ` false`.
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator<=(const QByteArray &lhs, const char *const &rhs)
Devuelve « true » si la matriz de bytes lhs es léxicamente menor o igual que la cadena rhs, terminada por «'\0 »; en caso contrario, devuelve « false ».
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator<=(const char *const &lhs, const QByteArray &rhs)
Devuelve ` true ` si la cadena ` lhs `, terminada por «\0 », es léxicamente menor o igual que la matriz de bytes ` rhs`; en caso contrario, devuelve ` false`.
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator==(const QByteArray &lhs, const QByteArray &rhs)
Devuelve « true » si la matriz de bytes lhs es igual a la matriz de bytes rhs; en caso contrario, devuelve « false ».
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator==(const QByteArray &lhs, const char *const &rhs)
Devuelve « true » si la matriz de bytes lhs es igual a la cadena rhs, terminada por «'\0 »; en caso contrario, devuelve « false ».
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator==(const char *const &lhs, const QByteArray &rhs)
Devuelve ` true ` si la cadena ` lhs `, terminada en «\0 », es igual a la matriz de bytes ` rhs`; en caso contrario, devuelve ` false`.
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator>(const QByteArray &lhs, const QByteArray &rhs)
Devuelve ` true ` si la matriz de bytes ` lhs ` es léxicamente mayor que la matriz de bytes ` rhs`; en caso contrario, devuelve ` false`.
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator>(const QByteArray &lhs, const char *const &rhs)
Devuelve « true » si la matriz de bytes lhs es léxicamente mayor que la cadena rhs, terminada por «'\0 »; en caso contrario, devuelve « false ».
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator>(const char *const &lhs, const QByteArray &rhs)
Devuelve ` true ` si la cadena ` lhs `, terminada por `'\0`, es léxicamente mayor que la matriz de bytes ` rhs`; en caso contrario, devuelve ` false`.
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator>=(const QByteArray &lhs, const QByteArray &rhs)
Devuelve ` true ` si la matriz de bytes ` lhs ` es léxicamente mayor o igual que la matriz de bytes ` rhs`; en caso contrario, devuelve ` false`.
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator>=(const QByteArray &lhs, const char *const &rhs)
Devuelve « true » si la matriz de bytes lhs es léxicamente mayor o igual que la cadena rhs, terminada con «'\0 »; en caso contrario, devuelve « false ».
Esta es una función sobrecargada.
Véase también QByteArray::compare().
[noexcept] bool operator>=(const char *const &lhs, const QByteArray &rhs)
Devuelve ` true ` si la cadena ` lhs `, terminada en «\0 », es léxicamente mayor o igual que la matriz de bytes ` rhs`; en caso contrario, devuelve ` false`.
Esta es una función sobrecargada.
Véase también QByteArray::compare().
QDataStream &operator>>(QDataStream &in, QByteArray &ba)
Lee una matriz de bytes en un objeto ` ba ` desde el flujo ` in ` y devuelve una referencia al flujo.
Véase también «Serialización detipos de datos de Qt».
Documentación de macros
QByteArrayLiteral(ba)
La macro genera los datos para un ` QByteArray ` a partir de la cadena literal ` ba ` en tiempo de compilación. En este caso, la creación de un ` QByteArray ` a partir de ella no conlleva ningún coste, y los datos generados en forma de matriz de bytes se almacenan en el segmento de solo lectura del archivo objeto compilado.
Por ejemplo:
QByteArray ba = QByteArrayLiteral("byte array contents");El uso de `QByteArrayLiteral` en lugar de un literal de cadena de C++ sin formato entre comillas dobles puede acelerar significativamente la creación de instancias de ` QByteArray ` a partir de datos conocidos en tiempo de compilación.
Véase también ` QStringLiteral`.
QT_NO_CAST_FROM_BYTEARRAY
Desactiva las conversiones automáticas de ` QByteArray ` a `const char *` o `const void *`.
Véase también « QT_NO_CAST_TO_ASCII » y « QT_NO_CAST_FROM_ASCII ».
[since 6.8] QT_NO_QSNPRINTF
Al definir esta macro, se desactivan las funciones qsnprintf() y qvsnprintf(). Consulta la documentación de estas funciones para saber por qué podría ser conveniente desactivarlas.
Esta macro se introdujo en Qt 6.8.
Véase también qsnprintf() y qvsnprintf().
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.