En esta página

QString Class

La clase QString proporciona una cadena de caracteres Unicode. Más información...

Encabezado: #include <QString>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core

Nota: Todas las funciones de esta clase son reentrantes.

Comparaciones de QString

CategoríaTipos comparablesDescripción
strongQString
strongQChar, ` QLatin1StringView`, `const char16_t *`, ` QStringView` y ` QUtf8StringView`.
strongQByteArray, ` QByteArrayView` y `const char *`.Al compararlos con matrices de bytes, su contenido se interpreta como UTF-8.

Tipos públicos

ConstIterator
Iterator
enum NormalizationForm { NormalizationForm_D, NormalizationForm_C, NormalizationForm_KD, NormalizationForm_KC }
enum SectionFlag { SectionDefault, SectionSkipEmpty, SectionIncludeLeadingSep, SectionIncludeTrailingSep, SectionCaseInsensitiveSeps }
flags SectionFlags
const_iterator
const_pointer
const_reference
const_reverse_iterator
difference_type
iterator
pointer
reference
reverse_iterator
size_type
value_type

Funciones públicas

QString()
QString(QChar ch)
QString(QLatin1StringView str)
(since 6.8) QString(QStringView sv)
QString(const QByteArray&ba)
QString(const char*str)
(since 6.1) QString(const char8_t*str)
QString(const QChar*unicode, qsizetype size = -1)
QString(qsizetype size, QChar ch)
QString(const QString&other)
QString(QString&&other)
~QString()
QString &append(const QString&str)
QString &append(QChar ch)
QString &append(QLatin1StringView str)
(since 6.0) QString &append(QStringView v)
(since 6.5) QString &append(QUtf8StringView str)
QString &append(const QByteArray&ba)
QString &append(const char*str)
QString &append(const QChar*str, qsizetype len)
QString arg(Args &&... args) const
QString arg(const T&a, int fieldWidth = 0, QChar fillChar = u' ') const
QString arg(T a, int anchoDeCampo = 0, int base = 10, QChar carácterDeRelleno = u' ') const
QString arg(T a, int fieldWidth = 0, char format = 'g', int precision = -1, QChar fillChar = u' ') const
(since 6.6) QString &assign(QAnyStringView v)
(since 6.6) QString &assign(InputIterator first, InputIterator last)
(since 6.6) QString &assign(qsizetype n, QChar c)
const QChar at(qsizetype position) const
QChar &back()
QChar back() const
QString::iterator begin()
QString::const_iterator begin() const
qsizetype capacity() const
QString::const_iterator cbegin() const
QString::const_iterator cend() const
void chop(qsizetype n)
QString chopped(qsizetype len) &&
QString chopped(qsizetype len) const &
void clear()
int compare(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
int compare(QLatin1StringView other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
int compare(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
int compare(const QString&other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
QString::const_iterator constBegin() const
const QChar *constData() const
QString::const_iterator constEnd() const
bool contains(const QRegularExpression&re, QRegularExpressionMatch*rmatch = nullptr) const
bool contains(const QString&str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
bool contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
bool contains(QLatin1StringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
bool contains(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
qsizetype count(const QString&str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
qsizetype count(const QRegularExpression&re) const
qsizetype count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
(since 6.0) qsizetype count(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
QString::const_reverse_iterator crbegin() const
QString::const_reverse_iterator crend() const
QChar *data()
const QChar *data() const
void detach()
QString::iterator end()
QString::const_iterator end() const
bool endsWith(const QString&s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
bool endsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
bool endsWith(QLatin1StringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
bool endsWith(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
(since 6.1) QString::iterator erase(QString::const_iterator first, QString::const_iterator last)
(since 6.5) QString::iterator erase(QString::const_iterator it)
QString &fill(QChar ch, qsizetype size = -1)
(since 6.0) QString first(qsizetype n) &&
(since 6.0) QString first(qsizetype n) const &
QChar &front()
QChar front() const
qsizetype indexOf(QLatin1StringView str, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
qsizetype indexOf(const QRegularExpression&re, qsizetype from = 0, QRegularExpressionMatch*rmatch = nullptr) const
qsizetype indexOf(const QString&str, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
qsizetype indexOf(QChar ch, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
qsizetype indexOf(QStringView str, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
QString &insert(qsizetype position, const QString&str)
QString &insert(qsizetype position, QChar ch)
QString &insert(qsizetype posición, QLatin1StringView str)
(since 6.0) QString &insert(qsizetype posición, QStringView str)
(since 6.5) QString &insert(qsizetype position, QUtf8StringView str)
QString &insert(qsizetype position, const QByteArray&str)
QString &insert(qsizetype position, const char*str)
QString &insert(qsizetype posición, const QChar*unicode, qsizetype tamaño)
bool isEmpty() const
bool isLower() const
bool isNull() const
bool isRightToLeft() const
bool isUpper() const
bool isValidUtf16() const
(since 6.0) QString last(qsizetype n) &&
(since 6.0) QString last(qsizetype n) const &
qsizetype lastIndexOf(const QRegularExpression&re, qsizetype from, QRegularExpressionMatch*rmatch = nullptr) const
qsizetype lastIndexOf(const QString&str, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
(since 6.3) qsizetype lastIndexOf(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
(since 6.2) qsizetype lastIndexOf(QLatin1StringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
(since 6.2) qsizetype lastIndexOf(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
(since 6.2) qsizetype lastIndexOf(const QRegularExpression&re, QRegularExpressionMatch*rmatch = nullptr) const
(since 6.2) qsizetype lastIndexOf(const QString&str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
qsizetype lastIndexOf(QChar ch, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
qsizetype lastIndexOf(QLatin1StringView str, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
qsizetype lastIndexOf(QStringView str, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
QString left(qsizetype n) &&
QString left(qsizetype n) const &
QString leftJustified(qsizetype ancho, QChar relleno = u' ', bool truncar = false) const
qsizetype length() const
(since 6.0) int localeAwareCompare(QStringView other) const
int localeAwareCompare(const QString&other) const
(since 6.8) qsizetype max_size() const
QString mid(qsizetype posición, qsizetype n = -1) &&
QString mid(qsizetype posición, qsizetype n = -1) const &
QString normalized(QString::NormalizationForm modo, QChar::UnicodeVersion versión = QChar::Unicode_Unassigned) const
(since 6.10) QString &nullTerminate()
(since 6.10) QString nullTerminated() &&
(since 6.10) QString nullTerminated() const &
QString &prepend(const QString&str)
QString &prepend(QChar ch)
QString &prepend(QLatin1StringView str)
(since 6.0) QString &prepend(QStringView str)
(since 6.5) QString &prepend(QUtf8StringView str)
QString &prepend(const QByteArray&ba)
QString &prepend(const char*str)
QString &prepend(const QChar*str, qsizetype len)
void push_back(const QString&other)
void push_back(QChar ch)
void push_front(const QString&other)
void push_front(QChar ch)
QString::reverse_iterator rbegin()
QString::const_reverse_iterator rbegin() const
QString &remove(const QRegularExpression&re)
QString &remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QString &remove(const QString&str, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QString &remove(qsizetype posición, qsizetype n)
QString &remove(QLatin1StringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive)
(since 6.5) QString &removeAt(qsizetype pos)
(since 6.5) QString &removeFirst()
(since 6.1) QString &removeIf(Predicado pred)
(since 6.5) QString &removeLast()
QString::reverse_iterator rend()
QString::const_reverse_iterator rend() const
QString repeated(qsizetype veces) const
QString &replace(qsizetype posición, qsizetype n, const QString&después)
QString &replace(const QRegularExpression&re, const QString&after)
QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QString &replace(QChar c, QLatin1StringView after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QString &replace(QChar ch, const QString&después, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QString &replace(QLatin1StringView before, QLatin1StringView after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QString &replace(QLatin1StringView before, const QString&after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QString &replace(const QString&antes, QLatin1StringView después, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QString &replace(const QString&antes, const QString&después, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QString &replace(qsizetype position, qsizetype n, QChar after)
QString &replace(qsizetype position, qsizetype n, const QChar*after, qsizetype alen)
QString &replace(const QChar*before, qsizetype blen, const QChar*after, qsizetype alen, Qt::CaseSensitivity cs = Qt::CaseSensitive)
void reserve(qsizetype size)
void resize(qsizetype size)
void resize(qsizetype newSize, QChar fillChar)
(since 6.8) void resizeForOverwrite(qsizetype tamaño)
QString right(qsizetype n) &&
QString right(qsizetype n) const &
QString rightJustified(qsizetype ancho, QChar relleno = u' ', bool truncar = false) const
QString section(QChar sep, qsizetype start, qsizetype end = -1, QString::SectionFlags flags = SectionDefault) const
QString section(const QRegularExpression&re, qsizetype start, qsizetype end = -1, QString::SectionFlags flags = SectionDefault) const
QString section(const QString&sep, qsizetype start, qsizetype end = -1, QString::SectionFlags flags = SectionDefault) const
QString &setNum(int n, int base = 10)
QString &setNum(long n, int base = 10)
QString &setNum(qlonglong n, int base = 10)
QString &setNum(qulonglong n, int base = 10)
QString &setNum(short n, int base = 10)
QString &setNum(uint n, int base = 10)
QString &setNum(ulong n, int base = 10)
QString &setNum(ushort n, int base = 10)
QString &setNum(double n, char formato = 'g', int precisión = 6)
QString &setNum(float n, char formato = 'g', int precisión = 6)
QString &setRawData(const QChar*unicode, qsizetype size)
QString &setUnicode(const QChar*unicode, qsizetype size)
(since 6.9) QString &setUnicode(const char16_t*unicode, qsizetype size)
(since 6.9) QString &setUtf16(const char16_t*unicode, qsizetype size)
void shrink_to_fit()
QString simplified() const
qsizetype size() const
(since 6.8) QString &slice(qsizetype pos, qsizetype n)
(since 6.8) QString &slice(qsizetype pos)
(since 6.0) QString sliced(qsizetype pos, qsizetype n) &&
(since 6.0) QString sliced(qsizetype pos, qsizetype n) const &
(since 6.0) QString sliced(qsizetype pos) &&
(since 6.0) QString sliced(qsizetype pos) const &
QStringList split(const QString&sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
QStringList split(const QRegularExpression&re, Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const
QStringList split(QChar sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
void squeeze()
bool startsWith(const QString&s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
bool startsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
bool startsWith(QLatin1StringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
bool startsWith(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
void swap(QString&other)
CFStringRef toCFString() const
QString toCaseFolded() const
double toDouble(bool*ok = nullptr) const
(since 6.6) emscripten::val toEcmaString() const
float toFloat(bool*ok = nullptr) const
QString toHtmlEscaped() const
int toInt(bool*ok = nullptr, int base = 10) const
QByteArray toLatin1() const
QByteArray toLocal8Bit() const
long toLong(bool*ok = nullptr, int base = 10) const
qlonglong toLongLong(bool*ok = nullptr, int base = 10) const
QString toLower() const
NSString *toNSString() const
short toShort(bool*ok = nullptr, int base = 10) const
std::string toStdString() const
std::u16string toStdU16String() const
std::u32string toStdU32String() const
std::wstring toStdWString() 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
QList<uint> toUcs4() const
QString toUpper() const
QByteArray toUtf8() const
qsizetype toWCharArray(wchar_t*array) const
(since 6.0) auto tokenize(Needle&&sep, Flags... flags) &&
(since 6.0) auto tokenize(Needle&&sep, Flags... flags) const &&
(since 6.0) auto tokenize(Needle&&sep, Flags... flags) const &
QString trimmed() const
void truncate(qsizetype posición)
const QChar *unicode() const
(since 6.7) operator std::u16string_view() const
QString &operator+=(const QString&other)
QString &operator+=(QChar ch)
QString &operator+=(QLatin1StringView str)
(since 6.0) QString &operator+=(QStringView str)
(since 6.5) QString &operator+=(QUtf8StringView str)
QString &operator+=(const QByteArray&ba)
QString &operator+=(const char*str)
QString &operator=(QString&&other)
QString &operator=(const QString&other)
QString &operator=(QChar ch)
QString &operator=(QLatin1StringView str)
QString &operator=(const QByteArray&ba)
QString &operator=(const char*str)
QChar &operator[](qsizetype position)
const QChar operator[](qsizetype posición) const

Miembros públicos estáticos

QString asprintf(const char*cformat, ...)
int compare(const QString&s1, const QString&s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)
int compare(QLatin1StringView s1, const QString&s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)
int compare(QStringView s1, const QString&s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)
int compare(const QString&s1, QLatin1StringView s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)
int compare(const QString&s1, QStringView s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QString fromCFString(CFStringRef cadena)
(since 6.6) QString fromEcmaString(emscripten::val jsString)
QString fromLatin1(const char*str, qsizetype size)
(since 6.0) QString fromLatin1(QByteArrayView str)
QString fromLatin1(const QByteArray&str)
QString fromLocal8Bit(const char*str, qsizetype size)
(since 6.0) QString fromLocal8Bit(QByteArrayView str)
QString fromLocal8Bit(const QByteArray&str)
QString fromNSString(const NSString*cadena)
(since 6.10) QString fromRawData(const char16_t*unicode, qsizetype size)
QString fromRawData(const QChar*unicode, qsizetype size)
QString fromStdString(const std::string&str)
QString fromStdU16String(const std::u16string&str)
QString fromStdU32String(const std::u32string&str)
QString fromStdWString(const std::wstring&str)
QString fromUcs4(const char32_t*unicode, qsizetype size = -1)
QString fromUtf8(const char*str, qsizetype size)
(since 6.0) QString fromUtf8(QByteArrayView str)
QString fromUtf8(const QByteArray&str)
(since 6.1) QString fromUtf8(const char8_t*str)
(since 6.0) QString fromUtf8(const char8_t*str, qsizetype size)
QString fromUtf16(const char16_t*unicode, qsizetype size = -1)
QString fromWCharArray(const wchar_t*string, qsizetype size = -1)
int localeAwareCompare(const QString&s1, const QString&s2)
(since 6.0) int localeAwareCompare(QStringView s1, QStringView s2)
(since 6.8) qsizetype maxSize()
QString number(long n, int base = 10)
QString number(double n, char formato = 'g', int precisión = 6)
QString number(int n, int base = 10)
QString number(qlonglong n, int base = 10)
QString number(qulonglong n, int base = 10)
QString number(uint n, int base = 10)
QString number(ulong n, int base = 10)
QString vasprintf(const char*cformat, va_list ap)
(since 6.1) qsizetype erase(QString &s, const T &t)
(since 6.1) qsizetype erase_if(QString &s, Predicate pred)
bool operator!=(const QByteArray &lhs, const QString &rhs)
bool operator!=(const QString &lhs, const QString &rhs)
bool operator!=(const char *const &lhs, const QString &rhs)
bool operator!=(const QString &lhs, const QByteArray &rhs)
bool operator!=(const QString &lhs, const QLatin1StringView &rhs)
bool operator!=(const QString &lhs, const char *const &rhs)
(since 6.4) QString operator""_s(const char16_t *str, size_t size)
QString operator+(QString &&s1, const QString &s2)
(since 6.9) QString operator+(QStringView lhs, const QString &rhs)
(since 6.9) QString operator+(const QString &lhs, QStringView rhs)
QString operator+(const QString &s1, const QString &s2)
QString operator+(const QString &s1, const char *s2)
QString operator+(const char *s1, const QString &s2)
bool operator<(const QByteArray &lhs, const QString &rhs)
bool operator<(const char *const &lhs, const QString &rhs)
bool operator<(const QLatin1StringView &lhs, const QString &rhs)
bool operator<(const QString &lhs, const QByteArray &rhs)
bool operator<(const QString &lhs, const QLatin1StringView &rhs)
bool operator<(const QString &lhs, const QString &rhs)
bool operator<(const QString &lhs, const char *const &rhs)
QDataStream &operator<<(QDataStream &stream, const QString &string)
bool operator<=(const QByteArray &lhs, const QString &rhs)
bool operator<=(const QString &lhs, const QString &rhs)
bool operator<=(const char *const &lhs, const QString &rhs)
bool operator<=(const QLatin1StringView &lhs, const QString &rhs)
bool operator<=(const QString &lhs, const QByteArray &rhs)
bool operator<=(const QString &lhs, const QLatin1StringView &rhs)
bool operator<=(const QString &lhs, const char *const &rhs)
bool operator==(const QByteArray &lhs, const QString &rhs)
bool operator==(const QLatin1StringView &lhs, const QString &rhs)
bool operator==(const QString &lhs, const QByteArray &rhs)
bool operator==(const QString &lhs, const QLatin1StringView &rhs)
bool operator==(const QString &lhs, const QString &rhs)
bool operator==(const QString &lhs, const char *const &rhs)
bool operator==(const char *const &lhs, const QString &rhs)
bool operator>(const QByteArray &lhs, const QString &rhs)
bool operator>(const QString &lhs, const QString &rhs)
bool operator>(const char *const &lhs, const QString &rhs)
bool operator>(const QLatin1StringView &lhs, const QString &rhs)
bool operator>(const QString &lhs, const QByteArray &rhs)
bool operator>(const QString &lhs, const QLatin1StringView &rhs)
bool operator>(const QString &lhs, const char *const &rhs)
bool operator>=(const QByteArray &lhs, const QString &rhs)
bool operator>=(const QString &lhs, const QString &rhs)
bool operator>=(const char *const &lhs, const QString &rhs)
bool operator>=(const QLatin1StringView &lhs, const QString &rhs)
bool operator>=(const QString &lhs, const QByteArray &rhs)
bool operator>=(const QString &lhs, const QLatin1StringView &rhs)
bool operator>=(const QString &lhs, const char *const &rhs)
QDataStream &operator>>(QDataStream &stream, QString &string)

Macros

QStringLiteral(str)
QT_NO_CAST_FROM_ASCII
QT_NO_CAST_TO_ASCII
QT_RESTRICTED_CAST_FROM_ASCII
const char *qPrintable(const QString &str)
const wchar_t *qUtf16Printable(const QString &str)
const char *qUtf8Printable(const QString &str)

Descripción detallada

QString almacena una cadena de caracteres de 16 bits ( QChar), en la que cada « QChar » corresponde a una unidad de código UTF-16. (Los caracteres Unicode con valores de código superiores a 65535 se almacenan mediante pares sustitutos, es decir, dos « QChar» consecutivos.)

Unicode es un estándar internacional que admite la mayoría de los sistemas de escritura en uso actualmente. Es un superconjunto de US-ASCII (ANSI X3.4-1986) y Latin-1 (ISO 8859-1), y todos los caracteres US-ASCII/Latin-1 están disponibles en las mismas posiciones de código.

En segundo plano, QString utiliza el uso compartido implícito (copia al escribir) para reducir el consumo de memoria y evitar la copia innecesaria de datos. Esto también ayuda a reducir la sobrecarga inherente que supone almacenar caracteres de 16 bits en lugar de caracteres de 8 bits.

Además de QString, Qt también proporciona la clase ` QByteArray ` para almacenar bytes sin procesar y cadenas tradicionales de 8 bits terminadas en «\0 ». Para la mayoría de los casos, QString es la clase que debes utilizar. Se utiliza en toda la API de Qt, y la compatibilidad con Unicode garantiza que tus aplicaciones sean fáciles de traducir si en algún momento deseas ampliar su mercado. Dos casos destacados en los que « QByteArray » resulta adecuado son cuando necesitas almacenar datos binarios sin procesar y cuando el ahorro de memoria es fundamental (como en los sistemas embebidos).

Inicialización de una cadena

Una forma de inicializar un QString es pasar un ` const char * ` a su constructor. Por ejemplo, el siguiente código crea un QString de tamaño 5 que contiene los datos «Hello»:

QString str = "Hello";

QString convierte los datos de « const char * » a Unicode mediante la función fromUtf8().

En todas las funciones de QString que admiten parámetros de tipo « const char * », la cadena « const char * » se interpreta como una cadena clásica al estilo C terminada en « '\\0' ». Salvo que el nombre de la función indique explícitamente otra codificación, se supone que dichos parámetros de tipo « const char * » están codificados en UTF-8.

Desde Qt 6.4, también es posible inicializar QStrings utilizando los operadores literales Qt::Literals::StringLiterals::operator""_s() y Qt::Literals::StringLiterals::operator""_L1(). En muchos casos, el uso de los literales da como resultado more efficient string construction.

También se pueden proporcionar datos de cadena como una matriz de QChars:

static const QChar data[4] = {QChar(0x0055), QChar(0x006e), QChar(0x10e3), QChar(0x03a3) };
QString str(data, 4);

QString realiza una copia profunda de los datos de QChar, por lo que se pueden modificar posteriormente sin que se produzcan efectos secundarios. Se puede evitar realizar una copia profunda de los datos de caracteres utilizando QStringView o QString::fromRawData() en su lugar.

Otro método consiste en establecer el tamaño de la cadena mediante resize() e inicializar los datos carácter por carácter. QString utiliza índices que comienzan en 0, al igual que las matrices de C++. Para acceder al carácter situado en una posición de índice concreta, puedes utilizar operator[](). En cadenas que no sean de tipoconst, operator[]() devuelve una referencia a un carácter que puede utilizarse en el lado izquierdo de una asignación. Por ejemplo:

QString str;
str.resize(4);

str[0] = QChar('U');
str[1] = QChar('n');
str[2] = QChar(0x10e3);
str[3] = QChar(0x03a3);

Para el acceso de solo lectura, una sintaxis alternativa consiste en utilizar la función ` at()`:

QString str;

for (qsizetype i = 0; i < str.size();++i) {
    if (str.at(i) >= QChar('a')&& str.at(i) <= QChar('f'))
        qDebug() << "Found character in range [a-f]";
}

La función ` at()` puede ser más rápida que ` operator[]()` porque nunca provoca una copia profunda. Como alternativa, utiliza las funciones ` first()`, ` last()` o ` sliced()` para extraer varios caracteres a la vez.

Un QString puede contener caracteres «\0 » (QChar::Null). La función size() siempre devuelve el tamaño de toda la cadena, incluidos los caracteres «\0 » incrustados.

Tras llamar a la función resize(), los caracteres recién asignados tienen valores indefinidos. Para establecer todos los caracteres de la cadena en un valor concreto, utiliza la función fill().

QString ofrece docenas de sobrecargas diseñadas para simplificar el uso de las cadenas. Por ejemplo, si quieres comparar un QString con un literal de cadena, puedes escribir código como este y funcionará según lo esperado:

QString str;

if (str == "auto" || str == "extern"
        || str == "static" || str == "register") {
    // ...
}

También puede pasar literales de cadena a funciones que toman QStrings como argumentos, invocando el constructor `QString(const char *)`. Del mismo modo, puede pasar un QString a una función que tome un argumento ` const char * ` utilizando la macro ` qPrintable()`, que devuelve el QString dado como un ` const char *`. Esto equivale a llamar a ` toLocal8Bit()`. `constData()` sobre el QString.

Manipulación de datos de cadena

QString proporciona las siguientes funciones básicas para modificar los datos de caracteres: ` append()`, ` prepend()`, ` insert()`, ` replace()` y ` remove()`. Por ejemplo:

QString str = "and";
str.prepend("rock ");     // str == "rock and"
str.append(" roll");        // str == "rock and roll"
str.replace(5, 3, "&");   // str == "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 caracteres que deben sustituirse.

Cuando las funciones que modifican datos aumentan el tamaño de la cadena, QString puede reasignar la memoria en la que almacena sus datos. Cuando esto ocurre, QString se expande más de lo que necesita en ese momento, con el fin de disponer de espacio para una mayor expansión sin necesidad de reasignación hasta que el tamaño de la cadena haya aumentado significativamente.

Las funciones ` insert()`, ` remove()` y, al sustituir una subcadena por otra de diferente tamaño, ` replace()` pueden resultar lentas (tiempo lineal) con cadenas largas, ya que requieren desplazar muchos caracteres de la cadena al menos una posición en la memoria.

Si estás creando un QString de forma gradual y sabes de antemano aproximadamente cuántos caracteres contendrá, puedes llamar a reserve(), solicitando a QString que preasigne una determinada cantidad de memoria. También puedes llamar a capacity() para averiguar cuánta memoria ha asignado realmente el QString.

QString proporciona iteradores al estilo de la STL (QString::const_iterator y QString::iterator). En la práctica, los iteradores resultan muy útiles cuando se trabaja con algoritmos genéricos proporcionados por la biblioteca estándar de C++.

Nota: No se puede confiar en quelos iteradores sobre un QString, ni las referencias a caracteres individuales dentro de este, sigan siendo válidos cuando se llame a cualquier método del QString que no seaconst. Acceder a dicho iterador o referencia tras llamar a un método que no sea de tipo `const ` da lugar a un comportamiento indefinido. Cuando se requiera estabilidad para la funcionalidad similar a la de los iteradores, debes utilizar índices en lugar de iteradores, ya que estos no están vinculados al estado interno de `QString` y, por lo tanto, no pierden su validez.

Nota: Debido al uso compartido implícito, el primer operador o función noconst que se utilice en un QString determinado puede provocar que este realice internamente una copia profunda de sus datos. Esto invalida todos los iteradores sobre la cadena y las referencias a los caracteres individuales que contiene. No llames a funciones no const mientras mantengas iteradores. Acceder a un iterador o a una referencia después de que se haya invalidado provoca un comportamiento indefinido. Consulta la sección «Problema de los iteradores con uso compartido implícito» para obtener más información.

Un requisito frecuente es eliminar o simplificar los espacios entre los caracteres visibles de una cadena. Los caracteres que componen esos espacios son aquellos para los que ` isSpace()` devuelve ` true`, como el espacio simple ` ' '`, la tabulación horizontal ` '\\t' ` y el salto de línea ` '\\n'`. Para obtener una copia de una cadena que omita cualquier espacio al principio y al final, utiliza ` trimmed()`. Para sustituir además cada secuencia de caracteres de espaciado dentro de la cadena por un espacio simple ( ' '), utiliza simplified().

Si quieres encontrar todas las apariciones de un carácter o subcadena concretos en un QString, utiliza las funciones indexOf() o lastIndexOf(). La primera busca hacia adelante, la segunda hacia atrás. A ambas se les puede indicar una posición de índice desde la que iniciar la búsqueda. Cada una devuelve la posición del índice del carácter o la subcadena si la encuentra; de lo contrario, devuelven -1. Por ejemplo, este es un bucle típico que busca todas las apariciones de una subcadena concreta:

QString str = "We must be <b>bold</b>, very <b>bold</b>";
qsizetype j = 0;

while ((j = str.indexOf("<b>", j)) !=-1) {
    qDebug() << "Found <b> tag at index position" << j;
   ++j;
}

QString ofrece numerosas funciones para convertir números en cadenas y cadenas en números. Consulta las funciones arg(), las funciones setNum(), las funciones estáticas number() y las funciones toInt(), toDouble() y otras similares.

Para obtener una versión en mayúsculas o minúsculas de una cadena, utiliza toUpper() o toLower().

Las listas de cadenas se gestionan mediante la clase ` QStringList `. Puedes dividir una cadena en una lista de cadenas utilizando la función split(), y unir una lista de cadenas en una sola cadena con un separador opcional utilizando QStringList::join(). Puedes obtener una lista filtrada a partir de una lista de cadenas seleccionando las entradas que contengan una subcadena concreta o que coincidan con un QRegularExpression concreto. Consulta QStringList::filter() para obtener más detalles.

Consulta de datos de cadenas

Para comprobar si un QString comienza o termina con una subcadena concreta, utilice startsWith() o endsWith(). Para comprobar si un QString contiene un carácter o una subcadena específicos, utilice la función contains(). Para averiguar cuántas veces aparece un carácter o una subcadena concretos en una cadena, utilice count().

Para obtener un puntero a los datos reales del carácter, llama a data() o a constData(). Estas funciones devuelven un puntero al inicio de los datos de QChar. Se garantiza que el puntero seguirá siendo válido hasta que se llame a una función que no seaconst en el QString.

Comparación de cadenas

Las cadenas QString se pueden comparar utilizando operadores sobrecargados como operator<(), operator<=(), operator==(), operator>=(), etc. La comparación se basa exclusivamente en el orden lexicográfico de las dos cadenas, consideradas como secuencias de unidades de código UTF-16. Es muy rápida, pero no es lo que esperaría un usuario; la función ` QString::localeAwareCompare()` suele ser una mejor opción para ordenar cadenas de la interfaz de usuario, cuando dicha comparación está disponible.

Cuando Qt se enlaza con la biblioteca ICU (lo cual suele ser el caso), se utiliza su ordenación sensible a la configuración regional. De lo contrario, se utilizan soluciones específicas de la plataforma:

  • En Windows, ` localeAwareCompare()` utiliza la configuración regional actual del usuario, tal y como se establece en las opciones « regional » y « language » de Control Panel.
  • En macOS e iOS, localeAwareCompare() realiza la comparación según la configuración de « Order for sorted lists » (Orden de los caracteres) del panel « International preferences ».
  • En otros sistemas similares a Unix, la comparación recurre a la función strcoll() de la biblioteca del sistema.

Conversión entre datos de cadena codificados y QString

QString proporciona las siguientes funciones que devuelven una versión const char * de la cadena como QByteArray: toUtf8(), toLatin1() y toLocal8Bit().

  • toLatin1() devuelve una cadena de 8 bits codificada en Latin-1 (ISO 8859-1).
  • toUtf8() devuelve una cadena de 8 bits codificada en UTF-8. UTF-8 es un superconjunto de US-ASCII (ANSI X3.4-1986) que admite todo el conjunto de caracteres Unicode mediante secuencias multibyte.
  • toLocal8Bit() devuelve una cadena de 8 bits utilizando la codificación local del sistema. Esto equivale a « toUtf8()» en sistemas Unix.

Para convertir desde una de estas codificaciones, QString proporciona fromLatin1(), fromUtf8() y fromLocal8Bit(). Se admiten otras codificaciones a través de las clases QStringEncoder y QStringDecoder.

Como se ha mencionado anteriormente, QString ofrece numerosas funciones y operadores que facilitan la interoperabilidad con cadenas de tipo « const char * ». Sin embargo, esta funcionalidad es un arma de doble filo: Hace que QString sea más cómodo de usar si todas las cadenas son US-ASCII o Latin-1, pero siempre existe el riesgo de que una conversión implícita desde o hacia const char * se realice utilizando una codificación de 8 bits incorrecta. Para minimizar estos riesgos, puedes desactivar estas conversiones implícitas definiendo algunos de los siguientes símbolos del preprocesador:

  • QT_NO_CAST_FROM_ASCII desactiva las conversiones automáticas desde literales de cadena y punteros de C a Unicode.
  • QT_RESTRICTED_CAST_FROM_ASCII permite las conversiones automáticas desde caracteres y matrices de caracteres de C, pero desactiva las conversiones automáticas desde punteros a caracteres a Unicode.
  • QT_NO_CAST_TO_ASCII desactiva la conversión automática de QString a cadenas de C.

A continuación, es necesario llamar explícitamente a fromUtf8(), fromLatin1() o fromLocal8Bit() para construir un QString a partir de una cadena de 8 bits, o bien utilizar la clase ligera QLatin1StringView. Por ejemplo:

// Required for using the '_L1' string literal.
using namespace Qt::StringLiterals;
// ...
QString url = "https://www.unicode.org/"_L1;

Del mismo modo, debes llamar explícitamente a toLatin1(), toUtf8() o toLocal8Bit() para convertir el QString en una cadena de 8 bits.

Nota para programadores de C
Debido al sistema de tipos de C++ y al hecho de que QString se comparte implícitamente, los QString pueden tratarse como ints u otros tipos básicos. Por ejemplo:
QString Widget::boolToString(bool b)
{
    QString result;
    if (b)
        result = "True";
    else
        result = "False";
    return result;
}

La variabl result es una variable normal asignada en la pila. Cuando se llama a return, y dado que se devuelve por valor, se invoca el constructor de copia y se devuelve una copia de la cadena. No se produce ninguna copia real gracias al uso compartido implícito.

Distinción entre cadenas nulas y vacías

Por razones históricas, QString distingue entre cadenas nulas y vacías. Una cadena nula es aquella que se inicializa mediante el constructor por defecto de QString o pasando ` nullptr ` al constructor. Una cadena vacía es cualquier cadena con tamaño 0. Una cadena nula siempre está vacía, pero una cadena vacía no es necesariamente nula:

QString().isNull();               // returns true
QString().isEmpty();              // returns true

QString("").isNull();             // returns false
QString("").isEmpty();            // returns true

QString("abc").isNull();          // returns false
QString("abc").isEmpty();         // returns false

Todas las funciones, excepto ` isNull()`, tratan las cadenas nulas igual que las cadenas vacías. Por ejemplo, ` toUtf8()`. `constData()` devuelve un puntero válido (no ` nullptr`) a un carácter «\0 » para una cadena nula. Recomendamos utilizar siempre la función ` isEmpty()` y evitar ` isNull()`.

Formatos numéricos

Cuando un especificador de formato de QString::arg() '%' incluye el calificador de configuración regional 'L' y la base es diez (su valor por defecto), se utiliza la configuración regional predeterminada. Esto se puede configurar mediante QLocale::setDefault(). Para un control más preciso de las representaciones localizadas de cadenas numéricas, véase QLocale::toString(). El resto del formato numérico realizado por QString sigue la representación de números de la configuración regional de C.

Cuando QString::arg() aplica el relleno a la izquierda a los números, el carácter de relleno '0' recibe un tratamiento especial. Si el número es negativo, su signo menos aparece antes del relleno con ceros. Si el campo está localizado, se utiliza el carácter de cero adecuado a la configuración regional en lugar de '0'. En el caso de los números de coma flotante, este tratamiento especial solo se aplica si el número es finito.

Formatos de coma flotante

En las funciones miembro (por ejemplo, arg() y number()) que formatean números de coma flotante (float o double) como cadenas, la representación utilizada puede controlarse mediante la elección del formato y la precisión, cuyos significados son los mismos que para QLocale::toString(double, char, int).

Si el formato seleccionado incluye un exponente, las formas localizadas siguen la convención de la configuración regional respecto a los dígitos del exponente. En el caso del formateo no localizado, el exponente muestra su signo e incluye al menos dos dígitos, rellenándose por la izquierda con ceros si es necesario.

Construcción más eficiente de cadenas

Muchas cadenas se conocen en tiempo de compilación. El constructor de QString a partir de literales de cadena de C++ copiará el contenido de la cadena, tratándolo como UTF-8. Esto requiere la asignación de memoria y la recodificación de los datos de la cadena, operaciones que se llevarán a cabo en tiempo de ejecución. Si los datos de la cadena se conocen en tiempo de compilación, puedes utilizar la macro ` QStringLiteral ` o, de forma similar, ` operator""_s ` para crear el contenido de `QString` en tiempo de compilación.

Con el operador « '+' » de QString, es fácil construir una cadena compleja a partir de varias subcadenas. A menudo escribirás código como este:

// Required for using the '_L1' string literal.
using namespace Qt::StringLiterals;
// ...

    QString foo;
    QString type = "long";

    foo = "vector<"_L1 + type + ">::iterator"_L1;

    if (foo.startsWith("(" + type + ") 0x"))
        ...

No hay nada incorrecto en ninguna de estas construcciones de cadenas, pero existen algunas ineficiencias ocultas:

En primer lugar, el uso repetido del operador '+' puede dar lugar a múltiples asignaciones de memoria. Al concatenar n subcadenas, donde n > 2, puede haber hasta n - 1 llamadas al asignador de memoria.

Estas asignaciones pueden optimizarse mediante una clase interna denominada « QStringBuilder ». Esta clase está marcada como «internal» y no aparece en la documentación, ya que no está pensada para que la instancies en tu código. Su uso será automático, tal y como se describe a continuación.

QStringBuilder Utiliza plantillas de expresión y reimplementa el operador ` '%' `, de modo que cuando se utiliza ` '%' ` para la concatenación de cadenas en lugar de ` '+'`, las concatenaciones de múltiples subcadenas se posponen hasta que el resultado final esté a punto de asignarse a un `QString`. En ese momento, se conoce la cantidad de memoria necesaria para el resultado final. A continuación, se invoca una vez al asignador de memoria para obtener el espacio necesario, y las subcadenas se copian en él una por una.

Se consigue una mayor eficiencia mediante la optimización en línea y la reducción del recuento de referencias (el QString creado a partir de un ` QStringBuilder ` tiene un recuento de referencias de 1, mientras que ` QString::append()` necesita una comprobación adicional).

Hay dos formas de acceder a este método mejorado de construcción de cadenas. La forma más sencilla es incluir ` QStringBuilder ` donde quieras utilizarlo y emplear el operador ` '%' ` en lugar de ` '+' ` al concatenar cadenas:

    #include <QStringBuilder>

    QString hello("hello");
    QStringView el = QStringView{ hello }.sliced(2, 3);
    QString message =  hello % el % "world"_L1 % QChar('!');

Un enfoque más global, que resulta más cómodo pero no es totalmente compatible con el código fuente, consiste en definir QT_USE_QSTRINGBUILDER (añadiéndolo a los parámetros del compilador) en el momento de la compilación. De este modo, la concatenación de cadenas con '+' funcionará de la misma manera que QStringBuilder's '%' .

Nota: Si se utiliza la deducción automática de tipos (por ejemplo, mediante la palabra clave « auto ») con el resultado de la concatenación de cadenas cuando QStringBuilder está habilitado, se observará que la concatenación es, efectivamente, un objeto de una especialización de QStringBuilder:

    QString str("QStringBuilder");

    // "s" type is deduced as QStringBuilder<...>
    auto s = "Like hot glue, " % str % " concatenates strings";

    // Similarly the return type of this lambda is deduced as QStringBuilder<...>
    auto concatenateStr = []() {
        return "Like hot glue, " % str % " concatenates strings";
    };

Esto no supone ningún problema, ya que QStringBuilder se convertirá implícitamente a QString cuando sea necesario. Si esto no es deseable, se deben especificar los tipos necesarios en lugar de dejar que el compilador los deduzca:

    QString s = "Like hot glue, " % str % " concatenates strings";

    // With a lambda, specify a trailing return type:
    auto concatenateStr = []() -> QString {
        return "Like hot glue, " % str % " concatenates strings";
    };

Tamaño máximo y condiciones de falta de memoria

El tamaño máximo de QString 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, cabe esperar un tamaño máximo de 2 GB menos la sobrecarga en plataformas de 32 bits y de 2^63 bytes menos la sobrecarga en plataformas de 64 bits. El número de elementos que se pueden almacenar en un QString es este tamaño máximo dividido por el tamaño de un QChar.

Cuando falla la asignación de memoria, QString lanza una excepción de « std::bad_alloc » si la aplicación se ha compilado con soporte para excepciones. Las situaciones de falta de memoria en los contenedores de Qt son los únicos casos en los que Qt lanzará excepciones. Si las excepciones están desactivadas, quedarse sin memoria se considera un comportamiento indefinido.

Nota: Los sistemas operativosde destino pueden imponer límites a la cantidad total de memoria que una aplicación puede asignar, o al tamaño de las asignaciones individuales. Esto puede restringir aún más el tamaño de la cadena que puede contener un QString. Mitigar o controlar el comportamiento que provocan estos límites queda fuera del alcance de la API de Qt.

Véase también «¿Qué clase de cadena utilizar?», fromRawData(), QChar, QStringView, QLatin1StringView y QByteArray.

Documentación sobre tipos de miembros

QString::ConstIterator

Sinónimo al estilo Qt de « QString::const_iterator ».

QString::Iterator

Sinónimo, al estilo de Qt XML, de « QString::iterator ».

enum QString::NormalizationForm

Esta enumeración describe las distintas formas normalizadas del texto Unicode.

ConstanteValorDescripción
QString::NormalizationForm_D0Descomposición canónica
QString::NormalizationForm_C1Descomposición canónica seguida de composición canónica
QString::NormalizationForm_KD2Descomposición de compatibilidad
QString::NormalizationForm_KC3Descomposición de compatibilidad seguida de composición canónica

Véase también normalized() y el Anexo n.º 15 del Estándar Unicode.

enum QString::SectionFlag
flags QString::SectionFlags

Esta enumeración especifica los indicadores que se pueden utilizar para modificar diversos aspectos del comportamiento de la función section() en lo que respecta a los separadores y los campos vacíos.

ConstanteValorDescripción
QString::SectionDefault0x00Se cuentan los campos vacíos, no se incluyen los separadores iniciales ni finales, y la comparación del separador distingue entre mayúsculas y minúsculas.
QString::SectionSkipEmpty0x01Se tratan los campos vacíos como si no existieran, es decir, no se tienen en cuenta a la hora de determinar el inicio y el final.
QString::SectionIncludeLeadingSep0x02Incluir el separador inicial (si lo hay) en la cadena de resultado.
QString::SectionIncludeTrailingSep0x04Incluir el separador final (si lo hay) en la cadena de resultado.
QString::SectionCaseInsensitiveSeps0x08Comparar el separador sin distinguir entre mayúsculas y minúsculas.

El tipo SectionFlags es un typedef para QFlags<SectionFlag>. Almacena una combinación OR de valores de SectionFlag.

Véase también section().

QString::const_iterator

Véase también QString::iterator.

QString::const_pointer

La definición de tipo `QString::const_pointer` proporciona un puntero constante al estilo de la STL a un elemento de ` QString ` (QChar).

QString::const_reference

QString::const_reverse_iterator

Véase también QString::reverse_iterator y QString::const_iterator.

QString::difference_type

QString::iterator

Véase también QString::const_iterator.

QString::pointer

La definición de tipo `QString::pointer` proporciona un puntero al estilo de la STL a un elemento de ` QString ` (QChar).

QString::reference

QString::reverse_iterator

Véase también QString::const_reverse_iterator y QString::iterator.

QString::size_type

QString::value_type

Documentación sobre funciones de miembro

[constexpr noexcept] QString::QString()

Crea una cadena nula. Las cadenas nulas también se consideran vacías.

Véase también isEmpty(), isNull() y Distinction Between Null and Empty Strings.

QString::QString(QChar ch)

Crea una cadena de tamaño 1 que contiene el carácter « ch ».

QString::QString(QLatin1StringView str)

Crea una copia de la cadena en codificación Latin-1 tal y como la ve str.

Véase también fromLatin1().

[explicit, since 6.8] QString::QString(QStringView sv)

Crea una cadena inicializada con los datos de la vista de cadena.

La cadena QString será nula si y solo si ` sv ` es nula.

Esta función se introdujo en Qt 6.8.

Véase también ` fromUtf16()`.

QString::QString(const QByteArray &ba)

Crea una cadena inicializada con la matriz de bytes ba. La matriz de bytes proporcionada se convierte a Unicode mediante la función fromUtf8().

Puedes desactivar este constructor definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Nota: Cualquier byte nulo («\0 ») presente en la matriz de bytes se incluirá en esta cadena, convertido a caracteres nulos Unicode (U+0000). Este comportamiento difiere del de Qt 5.x.

Véanse también fromLatin1(), fromLocal8Bit() y fromUtf8().

QString::QString(const char *str)

Crea una cadena inicializada con la cadena de 8 bits « str ». El puntero const char proporcionado se convierte a Unicode mediante la función fromUtf8().

Puedes desactivar este constructor definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, deseas asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Nota: La definición de ` QT_RESTRICTED_CAST_FROM_ASCII ` también desactiva este constructor, pero activa en su lugar un constructor ` QString(const char (&ch)[N]) `. En este caso, el uso de entradas que no sean literales, o que contengan caracteres NUL incrustados o caracteres de más de 7 bits, da lugar a un comportamiento indefinido.

Véase también fromLatin1(), fromLocal8Bit() y fromUtf8().

[since 6.1] QString::QString(const char8_t *str)

Crea una cadena inicializada con la cadena UTF-8 str. El puntero const char8_t proporcionado se convierte a Unicode mediante la función fromUtf8().

Esta función se introdujo en Qt 6.1.

Véanse también fromLatin1(), fromLocal8Bit() y fromUtf8().

[explicit] QString::QString(const QChar *unicode, qsizetype size = -1)

Crea una cadena inicializada con los primeros size caracteres de la matriz QChar unicode .

Si unicode es 0, se crea una cadena nula.

Si size es negativo, se supone que unicode apunta a una matriz terminada en «\0 » y su longitud se determina dinámicamente. El carácter nulo de terminación no se considera parte de la cadena.

QString realiza una copia profunda de los datos de la cadena. Los datos Unicode se copian tal cual y se conserva la marca de orden de bytes (Byte Order Mark), si está presente.

Véase también fromRawData().

QString::QString(qsizetype size, QChar ch)

Crea una cadena a partir de la dirección size, en la que cada carácter se establece en ch.

Véase también fill().

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

Crea una copia de ` other`.

Esta operación tarda un tiempo constante, ya que QString se comparte implícitamente. Esto hace que devolver un QString 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] QString::QString(QString &&other)

Crea una instancia de QString mediante «move», haciendo que apunte al mismo objeto al que apuntaba « other ».

[noexcept] QString::~QString()

Elimina la cadena.

QString &QString::append(const QString &str)

Añade la cadena « str » al final de esta cadena.

Ejemplo:

QString x = "free";
QString y = "dom";

x.append(y);
// x == "freedom"

Esto equivale a utilizar la función insert():

x.insert(x.size(), y);

La función append() suele ser muy rápida (tiempo constante), ya que QString preasigna espacio adicional al final de los datos de la cadena para que esta pueda crecer sin tener que reasignar toda la cadena cada vez.

Véase también operator+=(), prepend() y insert().

QString &QString::append(QChar ch)

Añade el carácter « ch » a esta cadena.

Esta función sobrecarga la función QString::append().

QString &QString::append(QLatin1StringView str)

Añade a esta cadena la cadena en formato Latin-1 obtenida mediante la función ` str `.

Esta función sobrecarga la función ` QString::append()`.

[since 6.0] QString &QString::append(QStringView v)

Añade la vista de cadena especificada ` v ` a esta cadena y devuelve el resultado.

Esta función sobrecarga QString::append().

Esta función se introdujo en Qt 6.0.

[since 6.5] QString &QString::append(QUtf8StringView str)

Añade la vista de cadena UTF-8 str a esta cadena.

Esta función sobrecarga QString::append().

Esta función se introdujo en Qt 6.5.

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

Añade la matriz de bytes ba a esta cadena. La matriz de bytes proporcionada se convierte a Unicode mediante la función fromUtf8().

Puedes desactivar esta función definiendo QT_NO_CAST_FROM_ASCII al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por QObject::tr().

Esta función sobrecarga QString::append().

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

Añade la cadena « str » a esta cadena. El puntero const char proporcionado se convierte a Unicode mediante la función « fromUtf8()».

Puedes desactivar esta función definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga QString::append().

QString &QString::append(const QChar *str, qsizetype len)

Añade los caracteres « len » de la matriz « QChar » str a esta cadena.

Esta función sobrecarga la función QString::append().

template <typename... Args> QString QString::arg(Args &&... args) const

Sustituye las apariciones de « %N » en esta cadena por el argumento correspondiente de « args ». Los argumentos no son posicionales: el primero de « args » sustituye « %N » por el « N » más bajo (todos ellos); el segundo de « args » sustituye « %N » por el « N » inmediatamente inferior, y así sucesivamente.

Args puede consistir en cualquier cosa que se convierta implícitamente a QAnyStringView.

Nota: En las versiones de Qt anteriores a la 6.9, las cadenas de tipo « QAnyStringView » y UTF-8 (QUtf8StringView, QByteArray, QByteArrayView, const char8_t*, etc.) no eran compatibles como « args ».

Véase también QString::arg().

template <typename T> requires if_string_like<T> QString QString::arg(const T &a, int fieldWidth = 0, QChar fillChar = u' ') const

Devuelve una copia de esta cadena en la que el marcador de posición con el número más bajo se sustituye por la cadena a, es decir, %1, %2, ..., %99.

fieldWidth especifica el espacio mínimo que debe ocupar « a ». Si « a » requiere menos espacio que « fieldWidth », se rellena hasta « fieldWidth » con el carácter « fillChar ». Un valor positivo de « fieldWidth » produce texto alineado a la derecha. Un valor negativo de « fieldWidth » produce texto alineado a la izquierda.

Este ejemplo muestra cómo podríamos crear una cadena status para informar del progreso mientras se procesa una lista de archivos:

int i;                // current file's number
int total;            // number of files to process
QStringView fileName; // current file's name

QString status = QString("Processing file %1 of %2: %3")
                .arg(i).arg(total).arg(fileName);

En primer lugar, arg(i) sustituye a %1. A continuación, arg(total) sustituye a %2. Por último, arg(fileName) sustituye a %3.

Una ventaja de utilizar arg() en lugar de asprintf() es que el orden de los marcadores de posición numerados puede cambiar si las cadenas de la aplicación se traducen a otros idiomas, pero cada arg() seguirá sustituyendo al marcador de posición sin sustituir con el número más bajo, independientemente de dónde aparezca. Además, si el marcador de posición %i aparece más de una vez en la cadena, arg() los sustituye todos.

Si no queda ningún marcador de posición sin sustituir, se muestra un mensaje de advertencia y el resultado es indefinido. Los números de los marcadores de posición deben estar comprendidos entre 1 y 99.

Nota: En las versiones de Qt anteriores a la 6.9, esta función estaba sobrecargada en char, QChar, QString, QStringView y QLatin1StringView, y en algunos casos, los argumentos wchar_t y char16_t se resolvían como sobrecargas de tipo entero. En las versiones de Qt anteriores a la 5.10, esta función carecía de las sobrecargas QStringView y QLatin1StringView.

template <typename T> requires if_integral_non_char<T> QString QString::arg(T a, int fieldWidth = 0, int base = 10, QChar fillChar = u' ') const

El argumento ` a ` se expresa en base ` base`, que por defecto es 10 y debe estar comprendido entre 2 y 36. Para bases distintas de 10, ` a ` se trata como un entero sin signo.

fieldWidth especifica la cantidad mínima de espacio hasta la que se rellena a con el carácter fillChar. Un valor positivo produce texto alineado a la derecha; un valor negativo produce texto alineado a la izquierda.

El carácter «%» puede ir seguido de una «L»; en ese caso, la secuencia se sustituye por una representación localizada de a. La conversión utiliza la configuración regional predeterminada, establecida mediante QLocale::setDefault(). Si no se ha especificado ninguna configuración regional predeterminada, se utiliza la configuración regional del sistema. El indicador «L» se ignora si base no es 10.

QString str;
str = QString("Decimal 63 is %1 in hexadecimal")
        .arg(63, 0, 16);
// str == "Decimal 63 is 3f in hexadecimal"

QLocale::setDefault(QLocale(QLocale::English, QLocale::UnitedStates));
str = QString("%1 %L2 %L3")
        .arg(12345)
        .arg(12345)
        .arg(12345, 0, 16);
// str == "12345 12,345 3039"

Nota: En las versiones de Qt anteriores a la 6.10.1, esta función aceptaba argumentos de tipos que se convertían implícitamente en tipos enteros. Esto ya no se admite, salvo en el caso de las enumeraciones (sin ámbito), ya que también aceptaba tipos convertibles en tipos de coma flotante, lo que provocaba una pérdida de precisión al imprimirlos como enteros. Una solución compatible con versiones anteriores consiste en convertir dichos tipos a un tipo de C++ cuya forma de visualización se ajuste a lo que se desea (int, float, ...).

Nota: En las versiones de Qt anteriores a la 6.9, esta función se sobrecargaba en varios tipos enteros y, en ocasiones, aceptaba incorrectamente argumentos de tipo ` char ` y ` char16_t `.

Esta función sobrecarga QString::arg().

Véase también Number formats.

template <typename T> requires if_floating_point<T> QString QString::arg(T a, int fieldWidth = 0, char format = 'g', int precision = -1, QChar fillChar = u' ') const

El argumento « a » se formatea según lo especificado en « format » y « precision ». Para más detalles, consulta Floating-point Formats.

fieldWidth especifica la cantidad mínima de espacio hasta la que se rellena a con el carácter fillChar. Un valor positivo produce texto alineado a la derecha; un valor negativo produce texto alineado a la izquierda.

double d = 12.34;
QString str = QString("delta: %1").arg(d, 0, 'E', 3);
// str == "delta: 1.234E+01"

Nota: En las versiones de Qt anteriores a la 6.9, esta función era una función normal que aceptaba double. Al ser ahora una función de plantilla, ya no acepta argumentos que simplemente se conviertan implícitamente a tipos de punto flotante. Una solución compatible con versiones anteriores consiste en convertir dichos tipos a uno de los tipos de punto flotante de C++.

Esta función sobrecarga ` QString::arg()`.

Véase también QLocale::toString(), QLocale::FloatingPointPrecisionOption y Number formats.

[static] QString QString::asprintf(const char *cformat, ...)

Crea de forma segura una cadena formateada a partir de la cadena de formato cformat y una lista arbitraria de argumentos.

La cadena de formato admite los especificadores de conversión, los modificadores de longitud y los indicadores que proporciona la función printf() en la biblioteca estándar de C++. La cadena cformat y los argumentos %s deben estar codificados en UTF-8.

Nota: La secuencia de escape %lc espera un carácter Unicode de tipo char16_t (tal y como lo devuelve QChar::unicode()), o ushort. La secuencia de escape %ls espera un puntero a una matriz terminada en cero de caracteres Unicode de tipo char16_t, o ushort (tal y como lo devuelve QString::utf16()). Esto entra en conflicto con la función printf() de la biblioteca estándar de C++, que define %lc para imprimir un wchar_t y %ls para imprimir un wchar_t*, y también podría generar advertencias del compilador en plataformas en las que el tamaño de wchar_t no sea de 16 bits.

Advertencia: Norecomendamos utilizar QString::asprintf() en código Qt nuevo. En su lugar, plantéate utilizar QTextStream o arg(), ya que ambas funciones admiten cadenas Unicode sin problemas y son seguras en cuanto a tipos. A continuación se muestra un ejemplo que utiliza QTextStream:

QString result;
QTextStream(&result) << "pi = " << 3.14;
// result == "pi = 3.14"

En el caso de translations, especialmente si las cadenas contienen más de una secuencia de escape, deberías plantearte utilizar en su lugar la función arg(). Esto permite que el traductor controle el orden de las sustituciones.

Véase también arg().

[since 6.6] QString &QString::assign(QAnyStringView v)

Sustituye el contenido de esta cadena por una copia de v y devuelve una referencia a esta cadena.

El tamaño de esta cadena será igual al tamaño de v, convertido a UTF-16 como si se hubiera utilizado v.toString(). Sin embargo, a diferencia de QAnyStringView::toString(), esta función solo asigna memoria si el tamaño estimado supera la capacidad de esta cadena o si esta cadena es compartida.

Esta función se introdujo en Qt 6.6.

Véase también QAnyStringView::toString().

[since 6.6] template <typename InputIterator> requires if_compatible_iterator<InputIterator> QString &QString::assign(InputIterator first, InputIterator last)

Sustituye el contenido de esta cadena por una copia de los elementos del rango del iterador [first, last) y devuelve una referencia a esta cadena.

El tamaño de esta cadena será igual a la longitud descodificada de los elementos del rango [first, last), que no tiene por qué ser igual a la longitud del propio rango, ya que esta función recodifica de forma transparente el juego de caracteres de entrada a UTF-16.

Esta función solo asignará memoria si el número de elementos del rango o, en el caso de entradas no codificadas en UTF-16, el tamaño máximo posible de la cadena resultante, supera la capacidad de esta cadena, o si esta cadena es compartida.

Nota: El comportamiento es indefinido si cualquiera de los argumentos es un iterador en *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 y el value_type de InputIterator es uno de los siguientes tipos de caracteres:

  • QChar
  • QLatin1Char
  • char
  • unsigned char
  • signed char
  • char8_t
  • char16_t
  • (en plataformas, como Windows, donde es un tipo de 16 bits) wchar_t
  • char32_t

Esta función se introdujo en Qt 6.6.

[since 6.6] QString &QString::assign(qsizetype n, QChar c)

Sustituye el contenido de esta cadena por n copias de c y devuelve una referencia a esta cadena.

El tamaño de esta cadena será igual a n, que debe ser un número no negativo.

Esta función solo asignará memoria si n supera la capacidad de esta cadena o si esta cadena es compartida.

Esta función se introdujo en Qt 6.6.

Véase también fill().

const QChar QString::at(qsizetype position) const

Devuelve el carácter situado en el índice indicado position de la cadena.

El position debe ser una posición de índice válida en la cadena (es decir, 0 <= position < size()).

Véase también operator[]().

QChar &QString::back()

Devuelve una referencia al último carácter de la cadena. Equivale a ` operator[](size() - 1)`.

Esta función se proporciona para garantizar la compatibilidad con la STL.

Advertencia: llamar a esta función con una cadena vacía da lugar a un comportamiento indefinido.

Véase también front(), at() y operator[]().

QChar QString::back() const

Devuelve el último carácter de la cadena. Equivale a ` at(size() - 1)`.

Esta función se proporciona por motivos de compatibilidad con la STL.

Advertencia: llamar a esta función con una cadena vacía da lugar a un comportamiento indefinido.

Véase también front(), at() y operator[]().

QString::iterator QString::begin()

Devuelve un iterador de estilo STL que apunta al primer carácter de la cadena.

Advertencia: El iterador devuelto deja de ser válido al desacoplarse o cuando se modifica la función QString.

Véase también ` constBegin()` y ` end()`.

QString::const_iterator QString::begin() const

Esta función sobrecarga la función ` QString::begin()`.

qsizetype QString::capacity() const

Devuelve el número máximo de caracteres que se pueden almacenar en la cadena sin que sea necesario realizar 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 QString. En general, rara vez necesitarás llamar a esta función. Si quieres saber cuántos caracteres hay en la cadena, llama a size().

Nota: una cadena 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().

QString::const_iterator QString::cbegin() const

Devuelve un iterador const al estilo STL que apunta al primer carácter de la cadena.

Advertencia: El iterador devuelto deja de ser válido al desvincularse o cuando se modifica el objeto ` QString `.

Véase también ` begin()` y ` cend()`.

QString::const_iterator QString::cend() const

Devuelve un iterador const al estilo STL que apunta justo después del último carácter de la cadena.

Advertencia: El iterador devuelto deja de ser válido al separarse o cuando se modifica el objeto ` QString `.

Véase también ` cbegin()` y ` end()`.

void QString::chop(qsizetype n)

Elimina los caracteres « n » del final de la cadena.

Si n es mayor o igual que size(), el resultado es una cadena vacía; si n es negativo, equivale a pasar el valor cero.

Ejemplo:

QString str("LOGOUT\r\n");
str.chop(2);
// str == "LOGOUT"

Si deseas eliminar caracteres del principio de la cadena, utiliza en su lugar remove().

Véase también truncate(), resize(), remove() y QStringView::chop().

QString QString::chopped(qsizetype len) &&

QString QString::chopped(qsizetype len) const &

Devuelve una cadena que contiene los caracteres situados más a la izquierda de esta cadena, según la función size() - len.

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 QString::clear()

Borra el contenido de la cadena y la deja vacía.

Véase también resize() y isNull().

[static noexcept] int QString::compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Compara la cadena s1 con la cadena s2 y devuelve un entero negativo si s1 es menor que s2, un entero positivo si es mayor que s2, y cero si son iguales.

Si cs es Qt::CaseSensitive (el valor por defecto), la comparación distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

La comparación que distingue entre mayúsculas y minúsculas se basa exclusivamente en los valores numéricos Unicode de los caracteres y es muy rápida, pero no es lo que esperaría un ser humano. Piensa, por ejemplo, en ordenar cadenas visibles para el usuario con localeAwareCompare().

int x = QString::compare("aUtO", "AuTo", Qt::CaseInsensitive);  // x == 0
int y = QString::compare("auto", "Car", Qt::CaseSensitive);     // y > 0
int z = QString::compare("auto", "Car", Qt::CaseInsensitive);   // z < 0

Nota: Esta función trata las cadenas nulas igual que las cadenas vacías; para más detalles, consulta Distinction Between Null and Empty Strings.

Véanse también operator==(), operator<(), operator>() y Comparing Strings.

[noexcept] int QString::compare(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Realiza una comparación de esto con ` ch`, utilizando la configuración de distinción entre mayúsculas y minúsculas ` cs`.

Esta función sobrescribe la función QString::compare().

[noexcept] int QString::compare(QLatin1StringView other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Es lo mismo que `compare(*this, other, cs)`.

Esta función sobrecarga QString::compare().

[noexcept] int QString::compare(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Realiza una comparación de esto con ` s`, utilizando la configuración de distinción entre mayúsculas y minúsculas ` cs`.

Esta función sobrescribe la función QString::compare().

[noexcept] int QString::compare(const QString &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Compara léxicamente esta cadena con la cadena other y devuelve un entero negativo si esta cadena es menor que other, un entero positivo si es mayor que other y cero si son iguales.

Equivale a compare(*this, other, cs).

Esta función sobrecarga QString::compare().

[static noexcept] int QString::compare(QLatin1StringView s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Realiza una comparación entre s1 y s2, utilizando la configuración de distinción entre mayúsculas y minúsculas cs.

Esta función sobrecarga QString::compare().

[static noexcept] int QString::compare(QStringView s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Esta función sobrecarga la función « QString::compare()».

[static noexcept] int QString::compare(const QString &s1, QLatin1StringView s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Realiza una comparación entre s1 y s2, utilizando la configuración de distinción entre mayúsculas y minúsculas cs.

Esta función sobrescribe la función QString::compare().

[static noexcept] int QString::compare(const QString &s1, QStringView s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Esta función sobrescribe la función « QString::compare()».

QString::const_iterator QString::constBegin() const

Devuelve un iterador const al estilo STL que apunta al primer carácter de la cadena.

Advertencia: El iterador devuelto deja de ser válido al desacoplarse o cuando se modifica la función « QString ».

Véase también ` begin()` y ` constEnd()`.

const QChar *QString::constData() const

Devuelve un puntero a los datos almacenados en ` QString`. El puntero se puede utilizar para acceder a los caracteres que componen la cadena.

Ten en cuenta que el puntero solo es válido mientras la cadena no se modifique.

Nota: Es posible quela cadena devuelta no termine en «\0 ». Utilice size() para determinar la longitud de la matriz.

Véase también data(), operator[]() y fromRawData().

QString::const_iterator QString::constEnd() const

Devuelve un iterador const al estilo STL que apunta justo después del último carácter de la cadena.

Advertencia: El iterador devuelto queda invalidado al desacoplarse o cuando se modifica el objeto ` QString `.

Véase también « constBegin()» y « end()».

bool QString::contains(const QRegularExpression &re, QRegularExpressionMatch *rmatch = nullptr) const

Devuelve « true » si la expresión regular « re » coincide en algún punto de esta cadena; en caso contrario, devuelve « false ».

Si la coincidencia se produce con éxito y rmatch no es nullptr, también escribe los resultados de la coincidencia en el objeto QRegularExpressionMatch al que apunta rmatch.

Véase también QRegularExpression::match().

bool QString::contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve « true » si esta cadena contiene alguna aparición de la cadena « str »; en caso contrario, devuelve « false ».

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Ejemplo:

QString str = "Peter Pan";
str.contains("peter", Qt::CaseInsensitive);    // returns true

Véase también indexOf() y count().

bool QString::contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve « true » si esta cadena contiene alguna aparición del carácter « ch »; en caso contrario, devuelve « false ».

Esta función sobrescribe la función QString::contains().

bool QString::contains(QLatin1StringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve « true » si esta cadena contiene alguna aparición de la cadena « str » en codificación Latin-1; en caso contrario, devuelve « false ».

Esta función sobrecarga QString::contains().

[noexcept] bool QString::contains(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve « true » si esta cadena contiene alguna aparición de la cadena «view str »; en caso contrario, devuelve « false ».

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Esta función sobrescribe a ` QString::contains()`.

Véase también indexOf() y count().

qsizetype QString::count(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve el número de apariciones (que pueden solaparse) de la cadena « str » en esta cadena.

Si cs es Qt::CaseSensitive (el valor predeterminado), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Véanse también « contains()» y « indexOf()».

qsizetype QString::count(const QRegularExpression &re) const

Devuelve el número de veces que la expresión regular « re » coincide en la cadena.

Por razones históricas, esta función cuenta las coincidencias superpuestas, por lo que en el ejemplo siguiente hay cuatro instancias de «ana» o «ama»:

QString str = "banana and panama";
str.count(QRegularExpression("a[nm]a"));    // returns 4

Este comportamiento difiere del que se obtiene al simplemente recorrer las coincidencias de la cadena utilizando QRegularExpressionMatchIterator.

Esta función sobrecarga ` QString::count()`.

Véase también QRegularExpression::globalMatch().

qsizetype QString::count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve el número de veces que aparece el carácter ch en la cadena.

Si cs es Qt::CaseSensitive (valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Esta función sobrecarga la función QString::count().

Véase también contains() y indexOf().

[since 6.0] qsizetype QString::count(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve el número de apariciones (que pueden solaparse) de la cadena « str » en esta cadena.

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Esta función sobrescribe a ` QString::count()`.

Esta función se introdujo en Qt 6.0.

Véase también contains() y indexOf().

QString::const_reverse_iterator QString::crbegin() const

Devuelve un iterador inverso const al estilo STL que apunta al primer carácter de la cadena, en orden inverso.

Advertencia: El iterador devuelto deja de ser válido al desacoplarse o cuando se modifica el objeto ` QString `.

Véase también « begin()», « rbegin()» y « rend()».

QString::const_reverse_iterator QString::crend() const

Devuelve un iterador inverso de tipo const al estilo STL que apunta justo después del último carácter de la cadena, en orden inverso.

Advertencia: El iterador devuelto deja de ser válido al desacoplarse o cuando se modifica la ` QString `.

Véase también end(), rend() y rbegin().

QChar *QString::data()

Devuelve un puntero a los datos almacenados en ` QString`. El puntero se puede utilizar para acceder a los caracteres que componen la cadena y modificarlos.

A diferencia de ` constData()` y ` unicode()`, los datos devueltos siempre terminan con «\0 ».

Ejemplo:

QString str = "Hello world";
QChar*data = str.data();
while (!data->isNull()) {
    qDebug() << data->unicode();
   ++data;
}

Ten en cuenta que el puntero solo sigue siendo válido mientras la cadena no se modifique por otros medios. Para el acceso de solo lectura, constData() es más rápido porque nunca provoca que se realice una copia profunda.

Véanse también constData() y operator[]().

const QChar *QString::data() const

Nota: Es posible quela cadena devuelta no termine en «\0 ». Utiliza size() para determinar la longitud del array.

Esta es una función sobrecargada.

Véase también ` fromRawData()`.

void QString::detach()

Garantiza que los datos de esta cadena ya no se compartan con otras instancias.

QString::iterator QString::end()

Devuelve un iterador de estilo STL que apunta justo después del último carácter de la cadena.

Advertencia: El iterador devuelto queda invalidado al desacoplarse o cuando se modifica el objeto ` QString `.

Véase también « begin()» y « constEnd()».

QString::const_iterator QString::end() const

Esta función sobrecarga la función « QString::end()».

bool QString::endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve « true » si la cadena termina en « s »; en caso contrario, devuelve « false ».

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

QString str = "Bananas";
str.endsWith("anas");         // returns true
str.endsWith("pple");         // returns false

Véase también startsWith().

bool QString::endsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve « true » si la cadena termina con « c »; en caso contrario, devuelve « false ».

Esta función sobrecarga QString::endsWith().

bool QString::endsWith(QLatin1StringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Esta función sobrecarga la función « QString::endsWith()».

[noexcept] bool QString::endsWith(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve « true » si la cadena termina con la cadena « str »; en caso contrario, devuelve « false ».

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Esta función sobrecarga la función QString::endsWith().

Véase también startsWith().

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

Elimina de la cadena los caracteres comprendidos en el intervalo semiabierto [ first, last ). Devuelve un iterador que apunta al carácter inmediatamente posterior al último carácter borrado (es decir, el carácter al que hace referencia last antes del borrado).

Esta función se introdujo en Qt 6.1.

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

Elimina de la cadena el carácter indicado por ` it `. Devuelve un iterador que apunta al carácter inmediatamente posterior al carácter eliminado.

QString c = "abcdefg";
auto it = c.erase(c.cbegin()); // c is now "bcdefg"; "it" points to "b"

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.5.

QString &QString::fill(QChar ch, qsizetype size = -1)

Establece todos los caracteres de la cadena como el carácter ch. Si size es distinto de -1 (valor por defecto), la cadena se redimensiona previamente a size.

Ejemplo:

QString str = "Berlin";
str.fill('z');
// str == "zzzzzz"

str.fill('A', 2);
// str == "AA"

Véase también resize().

[since 6.0] QString QString::first(qsizetype n) &&

[since 6.0] QString QString::first(qsizetype n) const &

Devuelve una cadena que contiene los primeros n caracteres de esta cadena (es decir, desde el principio de esta cadena hasta, sin incluirlo, el elemento situado en la posición de índice n).

Nota: El comportamiento es indefinido cuando n < 0 o n > size().

QString x = "Pineapple";
QString 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] QString QString::fromCFString(CFStringRef string)

Crea un nuevo objeto ` QString ` que contiene una copia del objeto `CFString` ` string `.

Nota: esta función solo está disponible en macOS e iOS.

[static, since 6.6] QString QString::fromEcmaString(emscripten::val jsString)

Convierte la cadena ECMAScript jsString en QString. El comportamiento es indefinido si el parámetro proporcionado no es una cadena.

Esta función se introdujo en Qt 6.6.

Véase también toEcmaString().

[static] QString QString::fromLatin1(const char *str, qsizetype size)

Devuelve un objeto ` QString ` inicializado con los primeros ` size ` caracteres de la cadena en Latin-1 ` str`.

Si size es -1, se utiliza en su lugar strlen(str).

Véase también toLatin1(), fromUtf8() y fromLocal8Bit().

[static, since 6.0] QString QString::fromLatin1(QByteArrayView str)

Devuelve un objeto ` QString ` inicializado con la cadena Latin-1 « str ».

Nota: cualquier byte nulo («\0 ») presente en la matriz de bytes se incluirá en esta cadena, convertido a caracteres nulos Unicode (U+0000).

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.0.

[static] QString QString::fromLatin1(const QByteArray &str)

Devuelve un objeto ` QString ` inicializado con la cadena Latin-1 « str ».

Nota: cualquier byte nulo («\0 ») presente en la matriz de bytes se incluirá en esta cadena, convertido a caracteres nulos Unicode (U+0000). Este comportamiento difiere del de Qt 5.x.

Esta es una función sobrecargada.

[static] QString QString::fromLocal8Bit(const char *str, qsizetype size)

Devuelve un objeto ` QString ` inicializado con los primeros ` size ` caracteres de la cadena de 8 bits ` str`.

Si size es -1, se utiliza strlen(str) en su lugar.

En sistemas Unix, esto equivale a fromUtf8(). Ten en cuenta que, en sistemas Apple, esta función no tiene en cuenta NSString.defaultCStringEncoding ni CFStringGetSystemEncoding(), ya que estas funciones suelen devolver la codificación heredada «Western (Mac OS Roman)», que no debería utilizarse en los sistemas operativos modernos de Apple. En Windows se utiliza la página de códigos actual del sistema.

Véanse también toLocal8Bit(), fromLatin1() y fromUtf8().

[static, since 6.0] QString QString::fromLocal8Bit(QByteArrayView str)

Devuelve un objeto ` QString ` inicializado con la cadena de 8 bits ` str`.

En sistemas Unix, esto equivale a ` fromUtf8()`. Ten en cuenta que, en sistemas Apple, esta función no tiene en cuenta `NSString.defaultCStringEncoding ` ni `CFStringGetSystemEncoding()`, ya que estas funciones suelen devolver la codificación heredada «Western (Mac OS Roman)», que no debería utilizarse en los sistemas operativos modernos de Apple. En Windows se utiliza la página de códigos actual del sistema.

Nota: cualquier byte nulo («\0 ») presente en la matriz de bytes se incluirá en esta cadena, convertido a caracteres nulos Unicode (U+0000).

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.0.

[static] QString QString::fromLocal8Bit(const QByteArray &str)

Devuelve un objeto ` QString ` inicializado con la cadena de 8 bits ` str`.

En sistemas Unix, esto equivale a fromUtf8(). Ten en cuenta que, en sistemas Apple, esta función no tiene en cuenta NSString.defaultCStringEncoding ni CFStringGetSystemEncoding(), ya que estas funciones suelen devolver la codificación heredada «Western (Mac OS Roman)», que no debería utilizarse en los sistemas operativos modernos de Apple. En Windows se utiliza la página de códigos actual del sistema.

Nota: cualquier byte nulo («\0 ») de la matriz de bytes se incluirá en esta cadena, convertido a caracteres nulos Unicode (U+0000). Este comportamiento difiere del de Qt 5.x.

Esta es una función sobrecargada.

[static] QString QString::fromNSString(const NSString *string)

Crea un nuevo objeto ` QString ` que contiene una copia del objeto `NSString` ` string `.

Nota: esta función solo está disponible en macOS e iOS.

[static, since 6.10] QString QString::fromRawData(const char16_t *unicode, qsizetype size)

Crea un objeto ` QString ` que utiliza los primeros ` size ` caracteres Unicode del array ` unicode`. Los datos de ` unicode ` no se copian. El llamante debe poder garantizar que ` unicode ` no se eliminará ni se modificará mientras exista ` QString ` (o una copia no modificada del mismo).

Cualquier intento de modificar QString o sus copias provocará la creación de una copia profunda de los datos, lo que garantiza que los datos sin procesar no se modifiquen.

A continuación se muestra un ejemplo de cómo podemos utilizar un QRegularExpression con datos sin procesar en memoria sin necesidad de copiar los datos a un QString:

QRegularExpression pattern("\u00A4");
static const char16_t unicode[] = {
        0x005A, 0x007F, 0x00A4, 0x0060,
        0x1009, 0x0020, 0x0020};

QString str = QString::fromRawData(unicode, std::size(unicode));
if (str.contains(pattern)) {
    // ...
}

Advertencia: Una cadena creada con `fromRawData()` no termina con «\0 », a menos que los datos sin procesar contengan un carácter «\0 » en la posición size. Esto significa que ` unicode()` no devolverá una cadena que termine con «\0 » (aunque `utf16()` sí lo hace, a costa de copiar los datos sin procesar).

Esta función se introdujo en Qt 6.10.

Véase también fromUtf16(), setRawData(), data(), constData(), nullTerminate() y nullTerminated().

[static] QString QString::fromRawData(const QChar *unicode, qsizetype size)

Esta es una función sobrecargada.

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

Devuelve una copia de la cadena « str ». Se da por hecho que la cadena proporcionada está codificada en UTF-8 y se convierte a « QString » mediante la función fromUtf8().

Véanse también fromLatin1(), fromLocal8Bit(), fromUtf8() y QByteArray::fromStdString().

[static] QString QString::fromStdU16String(const std::u16string &str)

Devuelve una copia de la cadena « str ». Se supone que la cadena proporcionada está codificada en UTF-16 y se convierte a « QString » mediante la función fromUtf16().

Véase también fromUtf16(), fromStdWString() y fromStdU32String().

[static] QString QString::fromStdU32String(const std::u32string &str)

Devuelve una copia de la cadena « str ». Se da por supuesto que la cadena proporcionada está codificada en UTF-32 y se convierte a « QString » mediante la función fromUcs4().

Véase también fromUcs4(), fromStdWString() y fromStdU16String().

[static] QString QString::fromStdWString(const std::wstring &str)

Devuelve una copia de la cadena « str ». Se supone que la cadena proporcionada está codificada en UTF-16 si el tamaño de `wchar_t` es de 2 bytes (por ejemplo, en Windows) y en UCS-4 si el tamaño de `wchar_t` es de 4 bytes (la mayoría de los sistemas Unix).

Véanse también fromUtf16(), fromLatin1(), fromLocal8Bit(), fromUtf8(), fromUcs4(), fromStdU16String() y fromStdU32String().

[static] QString QString::fromUcs4(const char32_t *unicode, qsizetype size = -1)

Devuelve un objeto ` QString ` inicializado con los primeros ` size ` caracteres de la cadena Unicode ` unicode ` (codificada en UTF-32).

Si size es -1 (valor predeterminado), unicode debe terminar en «\0 ».

Véanse también toUcs4(), fromUtf16(), utf16(), setUtf16(), fromWCharArray() y fromStdU32String().

[static] QString QString::fromUtf8(const char *str, qsizetype size)

Devuelve un objeto ` QString ` inicializado con los primeros ` size ` bytes de la cadena UTF-8 ` str`.

Si size es -1, se utiliza strlen(str) en su lugar.

UTF-8 es un códec Unicode y puede representar todos los caracteres de una cadena Unicode como QString. Sin embargo, en UTF-8 pueden darse secuencias no válidas y, si se encuentra alguna, se sustituirá por uno o más «caracteres de sustitución» o se suprimirá. Entre ellas se incluyen secuencias no Unicode, elementos que no son caracteres, secuencias excesivamente largas o puntos de código sustitutos codificados en UTF-8.

Esta función se puede utilizar para procesar los datos entrantes de forma incremental, siempre y cuando todos los caracteres UTF-8 estén terminados dentro de los datos entrantes. Cualquier carácter sin terminar al final de la cadena será sustituido u omitido. Para realizar una decodificación con estado, utilice QStringDecoder.

Véanse también toUtf8(), fromLatin1() y fromLocal8Bit().

[static, since 6.0] QString QString::fromUtf8(QByteArrayView str)

Devuelve un objeto ` QString ` inicializado con la cadena UTF-8 ` str`.

Nota: cualquier byte nulo («\0 ») presente en la matriz de bytes se incluirá en esta cadena, convertido a caracteres nulos Unicode (U+0000).

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.0.

[static] QString QString::fromUtf8(const QByteArray &str)

Devuelve un objeto ` QString ` inicializado con la cadena UTF-8 « str ».

Nota: cualquier byte nulo («\0 ») presente en la matriz de bytes se incluirá en esta cadena, convertido a caracteres nulos Unicode (U+0000). Este comportamiento difiere del de Qt 5.x.

Esta es una función sobrecargada.

[static, since 6.1] QString QString::fromUtf8(const char8_t *str)

Esta sobrecarga solo está disponible al compilar en modo C++20.

Se trata de una función sobrecargada.

Esta función se introdujo en Qt 6.1.

[static, since 6.0] QString QString::fromUtf8(const char8_t *str, qsizetype size)

Esta sobrecarga solo está disponible al compilar en modo C++20.

Se trata de una función sobrecargada.

Esta función se introdujo en Qt 6.0.

[static] QString QString::fromUtf16(const char16_t *unicode, qsizetype size = -1)

Devuelve un objeto ` QString ` inicializado con los primeros ` size ` caracteres de la cadena Unicode ` unicode ` (codificada en ISO-10646-UTF-16).

Si size es -1 (valor predeterminado), unicode debe terminar en «'\0'».

Esta función comprueba si hay una marca de orden de bytes (BOM). Si no la hay, se asume el orden de bytes del host.

Esta función es lenta en comparación con las demás conversiones Unicode. Utiliza QString(const QChar *, qsizetype) o QString(const QChar *) si es posible.

QString Realiza una copia profunda de los datos Unicode.

Véanse también utf16(), setUtf16() y fromStdU16String().

[static] QString QString::fromWCharArray(const wchar_t *string, qsizetype size = -1)

Lee las primeras size unidades de código de la matriz wchar_t a cuyo inicio apunta string, las convierte a Unicode y devuelve el resultado como un QString. Se supone que la codificación utilizada por wchar_t es UTF-32 si el tamaño del tipo es de cuatro bytes, o UTF-16 si su tamaño es de dos bytes.

Si size es -1 (valor por defecto), el string debe terminar en «\0 ».

Véanse también fromUtf16(), fromLatin1(), fromLocal8Bit(), fromUtf8(), fromUcs4() y fromStdWString().

QChar &QString::front()

Devuelve una referencia al primer carácter de la cadena. Equivale a ` operator[](0)`.

Esta función se proporciona para garantizar la compatibilidad con STL.

Advertencia: llamar a esta función con una cadena vacía da lugar a un comportamiento indefinido.

Véase también back(), at() y operator[]().

QChar QString::front() const

Devuelve el primer carácter de la cadena. Es lo mismo que « at(0) ».

Esta función se proporciona para garantizar la compatibilidad con la STL.

Advertencia: llamar a esta función con una cadena vacía da lugar a un comportamiento indefinido.

Véase también back(), at() y operator[]().

qsizetype QString::indexOf(QLatin1StringView str, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve la posición en el índice de la primera aparición de la cadena «Latin-1» interpretada por « str » en esta cadena, buscando hacia adelante a partir de la posición de índice « from ». Devuelve -1 si no se encuentra « str ».

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Ejemplo:

QString x = "sticky question";
QString y = "sti";
x.indexOf(y);               // returns 0
x.indexOf(y, 1);            // returns 10
x.indexOf(y, 10);           // returns 10
x.indexOf(y, 11);           // returns -1

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.

Véanse también lastIndexOf(), contains() y count().

qsizetype QString::indexOf(const QRegularExpression &re, qsizetype from = 0, QRegularExpressionMatch *rmatch = nullptr) const

Devuelve la posición en el índice de la primera coincidencia de la expresión regular re en la cadena, buscando hacia adelante a partir de la posición from. Devuelve -1 si re no coincide en ningún sitio.

Si la búsqueda tiene éxito y rmatch no es nullptr, también escribe los resultados de la búsqueda en el objeto QRegularExpressionMatch al que apunta rmatch.

Ejemplo:

QString str = "the minimum";
str.indexOf(QRegularExpression("m[aeiou]"), 0);       // returns 4

QRegularExpressionMatch match;
str.indexOf(QRegularExpression("m[aeiou]"), 0, &match);       // returns 4
// match.captured() == mi

qsizetype QString::indexOf(const QString &str, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve la posición en el índice de la primera aparición de la cadena « str » en esta cadena, buscando hacia adelante a partir de la posición de índice « from ». Devuelve -1 si no se encuentra « str ».

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Ejemplo:

QString x = "sticky question";
QString y = "sti";
x.indexOf(y);               // returns 0
x.indexOf(y, 1);            // returns 10
x.indexOf(y, 10);           // returns 10
x.indexOf(y, 11);           // returns -1

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.

Véanse también lastIndexOf(), contains() y count().

qsizetype QString::indexOf(QChar ch, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve la posición en el índice de la primera aparición del carácter ch en esta cadena, buscando hacia adelante a partir de la posición from. Devuelve -1 si no se encuentra ch.

Esta función sobrecarga QString::indexOf().

[noexcept] qsizetype QString::indexOf(QStringView str, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve la posición en el índice de la primera aparición de la cadena « str » en esta cadena, buscando hacia adelante a partir de la posición de índice « from ». Devuelve -1 si no se encuentra « str ».

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

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.

Esta función sobrescribe QString::indexOf().

Véase también QStringView::indexOf(), lastIndexOf(), contains() y count().

QString &QString::insert(qsizetype position, const QString &str)

Inserta la cadena « str » en el índice indicado « position » y devuelve una referencia a dicha cadena.

Ejemplo:

QString str = "Meal";
str.insert(1, QString("ontr"));
// str == "Montreal"

Esta cadena se amplía para dar cabida a la inserción. Si position se encuentra más allá del final de la cadena, se añaden caracteres de espacio a la cadena hasta alcanzar este position, seguido de str.

Véase también append(), prepend(), replace() y remove().

QString &QString::insert(qsizetype position, QChar ch)

Inserta ch en el índice indicado position de la cadena.

La cadena se amplía para dar cabida a la inserción. Si position se encuentra más allá del final de la cadena, se añaden caracteres de espacio a la cadena hasta alcanzar este position, seguido de ch.

Esta función sobrecarga QString::insert().

QString &QString::insert(qsizetype position, QLatin1StringView str)

Inserta la cadena Latin-1 visualizada por str en el índice indicado position.

Esta cadena se amplía para dar cabida a la inserción. Si position se encuentra más allá del final de la cadena, se añaden caracteres de espacio a la cadena hasta alcanzar este position, seguido de str.

Esta función sobrecarga la función ` QString::insert()`.

[since 6.0] QString &QString::insert(qsizetype position, QStringView str)

Inserta la vista de cadena str en el índice indicado position y devuelve una referencia a esta cadena.

Esta cadena se amplía para dar cabida a la inserción. Si position se encuentra más allá del final de la cadena, se añaden caracteres de espacio a la cadena hasta alcanzar este position, seguidos de str.

Esta función sobrecarga ` QString::insert()`.

Esta función se introdujo en Qt 6.0.

[since 6.5] QString &QString::insert(qsizetype position, QUtf8StringView str)

Inserta la vista de cadena UTF-8 str en el índice indicado position.

Nota: La inserción de datos de cadena codificados en UTF-8 de ancho variable es, conceptualmente, más lenta que la inserción de datos de cadena de ancho fijo, como UTF-16 (QStringView) o Latin-1 (QLatin1StringView), por lo que debe utilizarse con moderación.

Esta cadena se amplía para dar cabida a la inserción. Si position se encuentra más allá del final de la cadena, se añaden caracteres de espacio a la cadena hasta alcanzar este position, seguido de str.

Esta función sobrecarga ` QString::insert()`.

Esta función se introdujo en Qt 6.5.

QString &QString::insert(qsizetype position, const QByteArray &str)

Interpreta el contenido de str como UTF-8, inserta la cadena Unicode que codifica en el índice especificado position y devuelve una referencia a dicha cadena.

Esta cadena se amplía para dar cabida a la inserción. Si position se encuentra más allá del final de la cadena, se añaden caracteres de espacio a la cadena hasta alcanzar este position, seguidos de str.

Esta función no está disponible cuando se define ` QT_NO_CAST_FROM_ASCII `.

Esta función sobrecarga la función QString::insert().

QString &QString::insert(qsizetype position, const char *str)

Inserta la cadena C « str » en el índice indicado « position » y devuelve una referencia a dicha cadena.

Esta cadena se amplía para dar cabida a la inserción. Si position se encuentra más allá del final de la cadena, se añaden caracteres de espacio a la cadena hasta alcanzar este position, seguidos de str.

Esta función no está disponible cuando se define QT_NO_CAST_FROM_ASCII.

Esta función sobrecarga QString::insert().

QString &QString::insert(qsizetype position, const QChar *unicode, qsizetype size)

Inserta los primeros size caracteres de la matriz QChar unicode en el índice indicado position dentro de la cadena.

La cadena se amplía para dar cabida a la inserción. Si position se encuentra más allá del final de la cadena, se añaden caracteres de espacio a la cadena hasta alcanzar este position, seguidos de size caracteres del QChar del unicode.

Esta función sobrecarga QString::insert().

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

Devuelve « true » si la cadena no contiene caracteres; en caso contrario, devuelve « false ».

Ejemplo:

QString().isEmpty();            // returns true
QString("").isEmpty();          // returns true
QString("x").isEmpty();         // returns false
QString("abc").isEmpty();       // returns false

Véase también size().

bool QString::isLower() const

Devuelve ` true ` si la cadena está en minúsculas, es decir, si es idéntica a su conversión mediante ` toLower()`.

Tenga en cuenta que esto no significa que la cadena no contenga letras mayúsculas (algunas letras mayúsculas no tienen una conversión a minúsculas; toLower() no las modifica). Para obtener más información, consulte el estándar Unicode, sección 3.13.

Véanse también QChar::toLower() y isUpper().

[constexpr] bool QString::isNull() const

Devuelve « true » si esta cadena es nula; en caso contrario, devuelve « false ».

Ejemplo:

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

Qt distingue entre cadenas nulas y cadenas vacías por razones históricas. Para la mayoría de las aplicaciones, lo que importa es si una cadena contiene datos o no, y esto se puede determinar utilizando la función isEmpty().

Véase también ` isEmpty()`.

bool QString::isRightToLeft() const

Devuelve « true » si la cadena se lee de derecha a izquierda.

Véase también QStringView::isRightToLeft().

bool QString::isUpper() const

Devuelve ` true ` si la cadena está en mayúsculas, es decir, si es idéntica a su representación obtenida con ` toUpper()`.

Ten en cuenta que esto no significa que la cadena no contenga letras minúsculas (algunas letras minúsculas no tienen una conversión a mayúsculas; toUpper() no las modifica). Para obtener más información, consulta la norma Unicode, sección 3.13.

Véanse también QChar::toUpper() y isLower().

[noexcept] bool QString::isValidUtf16() const

Devuelve « true » si la cadena contiene datos válidos codificados en UTF-16, o « false » en caso contrario.

Ten en cuenta que esta función no realiza ninguna validación especial de los datos; simplemente comprueba si se pueden decodificar correctamente desde UTF-16. Se da por hecho que los datos están en el orden de bytes del host; la presencia de un BOM no tiene importancia.

Véase también QStringView::isValidUtf16().

[since 6.0] QString QString::last(qsizetype n) &&

[since 6.0] QString QString::last(qsizetype n) const &

Devuelve la cadena que contiene los últimos n caracteres de esta cadena.

Nota: El comportamiento es indefinido cuando n < 0 o n > size().

QString x = "Pineapple";
QString 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().

qsizetype QString::lastIndexOf(const QRegularExpression &re, qsizetype from, QRegularExpressionMatch *rmatch = nullptr) const

Devuelve la posición en el índice de la última coincidencia de la expresión regular « re » en la cadena, que comienza antes de 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 re no ha coincidido en ningún sitio.

Si la coincidencia es correcta y rmatch no es nullptr, también escribe los resultados de la coincidencia en el objeto QRegularExpressionMatch al que apunta rmatch.

Ejemplo:

QString str = "the minimum";
str.lastIndexOf(QRegularExpression("m[aeiou]"));      // returns 8

QRegularExpressionMatch match;
str.lastIndexOf(QRegularExpression("m[aeiou]"), -1, &match);      // returns 8
// match.captured() == mu

Nota: Debido al funcionamiento del algoritmo de coincidencia de expresiones regulares, esta función realizará coincidencias repetidamente desde el principio de la cadena hasta que se alcance la posición from.

Nota: Al buscar una expresión regular re que pueda coincidir con 0 caracteres, la coincidencia al final de los datos se excluye de la búsqueda mediante un from negativo, aunque normalmente se considere que -1 busca desde el final de la cadena: la coincidencia al final se encuentra después del último carácter, por lo que se excluye. Para incluir dicha coincidencia final vacía, se debe indicar un valor positivo para from u omitir por completo el parámetro from.

qsizetype QString::lastIndexOf(const QString &str, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve la posición en el índice de la última aparición de la cadena « str » en esta cadena, buscando hacia atrás a partir de la posición de í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 « str ».

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Ejemplo:

QString x = "crazy azimuths";
QString y = "az";
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

Nota: Al buscar un « str » de longitud 0, la coincidencia 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 cadena: la coincidencia al final se encuentra después del último carácter, por lo que queda excluida. Para incluir dicha coincidencia final vacía, se debe proporcionar un valor positivo para from u omitir por completo el parámetro from.

Véase también indexOf(), contains() y count().

[noexcept, since 6.3] qsizetype QString::lastIndexOf(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Esta función sobrescribe la función « QString::lastIndexOf()».

Esta función se introdujo en Qt 6.3.

[since 6.2] qsizetype QString::lastIndexOf(QLatin1StringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve la posición en el índice de la última aparición de la cadena « str » en esta cadena. Devuelve -1 si no se encuentra « str ».

Si cs es Qt::CaseSensitive (valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Ejemplo:

QString x = "crazy azimuths";
QString y = "az";
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

Esta función sobrecarga ` QString::lastIndexOf()`.

Esta función se introdujo en Qt 6.2.

Véase también indexOf(), contains() y count().

[noexcept, since 6.2] qsizetype QString::lastIndexOf(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve la posición en el índice de la última aparición de la cadena « str » en esta cadena. Devuelve -1 si no se encuentra « str ».

Si cs es Qt::CaseSensitive (por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Esta función sobrecarga QString::lastIndexOf().

Esta función se introdujo en Qt 6.2.

Véase también indexOf(), contains() y count().

[since 6.2] qsizetype QString::lastIndexOf(const QRegularExpression &re, QRegularExpressionMatch *rmatch = nullptr) const

Devuelve la posición en el índice de la última coincidencia de la expresión regular re en la cadena. Devuelve -1 si re no ha coincidido en ningún sitio.

Si la coincidencia es correcta y rmatch no es nullptr, también escribe los resultados de la coincidencia en el objeto QRegularExpressionMatch al que apunta rmatch.

Ejemplo:

QString str = "the minimum";
str.lastIndexOf(QRegularExpression("m[aeiou]"));      // returns 8

QRegularExpressionMatch match;
str.lastIndexOf(QRegularExpression("m[aeiou]"), -1, &match);      // returns 8
// match.captured() == mu

Nota: Debido al funcionamiento del algoritmo de coincidencia de expresiones regulares, esta función realizará coincidencias repetidamente desde el principio de la cadena hasta llegar al final de la misma.

Esta función sobrecarga ` QString::lastIndexOf()`.

Esta función se introdujo en Qt 6.2.

[since 6.2] qsizetype QString::lastIndexOf(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve la posición en el índice de la última aparición de la cadena « str » en esta cadena. Devuelve -1 si no se encuentra « str ».

Si cs es Qt::CaseSensitive (valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Ejemplo:

QString x = "crazy azimuths";
QString y = "az";
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

Esta función sobrecarga QString::lastIndexOf().

Esta función se introdujo en Qt 6.2.

Véase también indexOf(), contains() y count().

qsizetype QString::lastIndexOf(QChar ch, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve la posición en el índice de la última aparición del carácter « ch » en esta cadena, buscando hacia atrás a partir de la posición del índice « from ».

Esta función sobrecarga la función QString::lastIndexOf().

qsizetype QString::lastIndexOf(QLatin1StringView str, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve la posición en el índice de la última aparición de la cadena «Latin-1» detectada por « str » en esta cadena, buscando hacia atrás a partir de la posición del í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 str.

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Ejemplo:

QString x = "crazy azimuths";
QString y = "az";
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

Nota: Al buscar un ` str` de longitud 0, la coincidencia al final de los datos queda excluida de la búsqueda si se utiliza un ` from` negativo, aunque normalmente se considere que ` -1 ` busca desde el final de la cadena: la coincidencia al final se encuentra después del último carácter, por lo que queda excluida. Para incluir dicha coincidencia final vacía, se debe proporcionar un valor positivo para from u omitir por completo el parámetro from.

Esta función sobrecarga QString::lastIndexOf().

Véanse también indexOf(), contains() y count().

[noexcept] qsizetype QString::lastIndexOf(QStringView str, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve la posición en el índice de la última aparición de la cadena « str » en esta cadena, buscando hacia atrás a partir de la posición del í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 « str ».

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Nota: Al buscar un « str » de longitud 0, la coincidencia 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 cadena: la coincidencia al final se encuentra después del último carácter, por lo que queda excluida. Para incluir dicha coincidencia vacía final, se debe proporcionar un valor positivo para from u omitir por completo el parámetro from.

Esta función sobrecarga QString::lastIndexOf().

Véanse también indexOf(), contains() y count().

QString QString::left(qsizetype n) &&

QString QString::left(qsizetype n) const &

Devuelve una subcadena que contiene los n caracteres situados más a la izquierda de esta cadena (es decir, desde el principio de la cadena hasta, sin incluirlo, el elemento situado en la posición de índice n).

Si sabes que n no puede estar fuera de límites, utiliza first() en lugar de esto en el código nuevo, ya que es más rápido.

Se devuelve la cadena completa si n es mayor o igual que size(), o menor que cero.

Véase también first(), last(), startsWith(), chopped(), chop() y truncate().

QString QString::leftJustified(qsizetype width, QChar fill = u' ', bool truncate = false) const

Devuelve una cadena de tamaño width que contiene esta cadena rellenada con el carácter fill.

Si truncate es false y el valor de size() de la cadena es mayor que width, entonces la cadena devuelta es una copia de la cadena.

QString s = "apple";
QString t = s.leftJustified(8, '.');    // t == "apple..."

Si truncate es true y el valor de size() de la cadena es mayor que width, se eliminan todos los caracteres de la copia de la cadena que se encuentren después de la posición width y se devuelve dicha copia.

QString str = "Pineapple";
str = str.leftJustified(5, '.', true);    // str == "Pinea"

Véase también rightJustified().

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

Devuelve el número de caracteres de esta cadena. Equivalente a ` size()`.

Véase también resize().

[static] int QString::localeAwareCompare(const QString &s1, const QString &s2)

Compara s1 con s2 y devuelve un número entero menor, igual o mayor que cero si s1 es menor, igual o mayor que s2.

La comparación se realiza en función de la configuración regional y también de la plataforma. Utiliza esta función para presentar al usuario listas ordenadas de cadenas.

Véase también compare(), QLocale y Comparing Strings.

[since 6.0] int QString::localeAwareCompare(QStringView other) const

Compara esta cadena con la cadena other y devuelve un número entero menor, igual o mayor que cero si esta cadena es menor, igual o mayor que la cadena other.

La comparación se realiza en función de la configuración regional y también de la plataforma. Utiliza esta función para presentar al usuario listas ordenadas de cadenas.

Es lo mismo que localeAwareCompare(*this, other).

Esta función sobrecarga QString::localeAwareCompare().

Esta función se introdujo en Qt 6.0.

Véase también Comparing Strings.

int QString::localeAwareCompare(const QString &other) const

Compara esta cadena con la cadena other y devuelve un entero menor, igual o mayor que cero si esta cadena es menor, igual o mayor que la cadena other.

La comparación se realiza en función de la configuración regional y también de la plataforma. Utiliza esta función para presentar al usuario listas ordenadas de cadenas.

Es lo mismo que localeAwareCompare(*this, other).

Esta función sobrecarga QString::localeAwareCompare().

Véase también Comparing Strings.

[static, since 6.0] int QString::localeAwareCompare(QStringView s1, QStringView s2)

Compara s1 con s2 y devuelve un número entero menor, igual o mayor que cero si s1 es menor, igual o mayor que s2.

La comparación se realiza en función de la configuración regional y también de la plataforma. Utiliza esta función para presentar al usuario listas ordenadas de cadenas.

Esta función sobrecarga ` QString::localeAwareCompare()`.

Esta función se introdujo en Qt 6.0.

Véase también Comparing Strings.

[static constexpr noexcept, since 6.8] qsizetype QString::maxSize()

[constexpr noexcept, since 6.8] qsizetype QString::max_size() const

Devuelve el número máximo de elementos que la cadena puede contener teóricamente. 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.

QString QString::mid(qsizetype position, qsizetype n = -1) &&

QString QString::mid(qsizetype position, qsizetype n = -1) const &

Devuelve una cadena que contiene los caracteres « n » de esta cadena, empezando por el índice especificado position hasta el elemento situado en la posición del índice, sin incluirlo position + n.

Si sabes que position y n no pueden estar fuera de límites, utiliza sliced() en su lugar en el código nuevo, ya que es más rápido.

Devuelve una cadena nula si el índice position supera la longitud de la cadena. Si hay menos de n caracteres disponibles en la cadena a partir del position dado, o si n es -1 (valor por defecto), la función devuelve todos los caracteres disponibles a partir del position especificado.

Véanse también first(), last(), sliced(), chopped(), chop(), truncate() y slice().

QString QString::normalized(QString::NormalizationForm mode, QChar::UnicodeVersion version = QChar::Unicode_Unassigned) const

Devuelve la cadena con la normalización Unicode especificada mode, de acuerdo con el documento version del estándar Unicode.

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

Si esta cadena de datos no está terminada en nulo, este método realizará una copia profunda de los datos y la terminará en nulo.

Una cadena de tipo ` QString ` termina en `null` por defecto; sin embargo, en algunos casos (por ejemplo, al utilizar ` fromRawData()`), los datos de la cadena 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 `null`.

Esta función se introdujo en Qt 6.10.

Véase también nullTerminated(), fromRawData() y setRawData().

[since 6.10] QString QString::nullTerminated() &&

[since 6.10] QString QString::nullTerminated() const &

Devuelve una copia de esta cadena que siempre termina en ‘NULL’.

Estas funciones se introdujeron en Qt 6.10.

Véase también nullTerminate(), fromRawData() y setRawData().

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

Devuelve una cadena equivalente al número n según la base especificada base.

La base es 10 por defecto y debe estar comprendida entre 2 y 36. Para bases distintas de 10, n se trata como un entero sin signo.

El formato utiliza siempre QLocale::C, es decir, inglés/Estados Unidos. Para obtener una representación en cadena localizada de un número, utiliza QLocale::toString() con la configuración regional adecuada.

long a = 63;
QString s = QString::number(a, 16);             // s == "3f"
QString t = QString::number(a, 16).toUpper();     // t == "3F"

Véase también setNum().

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

Devuelve una cadena que representa el número de coma flotante n.

Devuelve una cadena que representa n, formateada según lo especificado en format y precision.

En los formatos con exponente, este mostrará su signo y tendrá al menos dos dígitos, rellenándose a la izquierda con ceros si es necesario.

Véase también setNum(), QLocale::toString(), QLocale::FloatingPointPrecisionOption y Number formats.

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

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

QString &QString::prepend(const QString &str)

Añade la cadena « str » al principio de esta cadena y devuelve una referencia a ella.

Esta operación suele ser muy rápida (tiempo constante), ya que QString preasigna espacio adicional al principio de los datos de la cadena, de modo que esta puede crecer sin necesidad de reasignar toda la cadena cada vez.

Ejemplo:

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

Véase también ` append()` y ` insert()`.

QString &QString::prepend(QChar ch)

Añade al principio de esta cadena el carácter « ch ».

Esta función sobrecarga la función QString::prepend().

QString &QString::prepend(QLatin1StringView str)

Añade al principio de esta cadena la cadena en formato Latin-1 que muestra « str ».

Esta función sobrecarga la función QString::prepend().

[since 6.0] QString &QString::prepend(QStringView str)

Añade la vista de cadena str al principio de esta cadena y devuelve una referencia a esta cadena.

Esta función sobrecarga QString::prepend().

Esta función se introdujo en Qt 6.0.

[since 6.5] QString &QString::prepend(QUtf8StringView str)

Añade al principio de esta cadena la vista de cadena UTF-8 str.

Esta función sobrecarga QString::prepend().

Esta función se introdujo en Qt 6.5.

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

Añade al principio de esta cadena la matriz de bytes ba. La matriz de bytes se convierte a Unicode mediante la función fromUtf8().

Puedes desactivar esta función definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga ` QString::prepend()`.

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

Añade al principio de esta cadena la cadena « str ». El puntero const char se convierte a Unicode mediante la función fromUtf8().

Puedes desactivar esta función definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga la función ` QString::prepend()`.

QString &QString::prepend(const QChar *str, qsizetype len)

Añade al principio de esta cadena los caracteres len del array QChar str y devuelve una referencia a esta cadena.

Esta función sobrecarga la función ` QString::prepend()`.

void QString::push_back(const QString &other)

Esta función se proporciona para garantizar la compatibilidad con STL y añade la cadena « other » al final de esta cadena. Es equivalente a « append(other) ».

Véase también append().

void QString::push_back(QChar ch)

Añade el carácter ch especificado al final de esta cadena.

Esta es una función sobrecargada.

void QString::push_front(const QString &other)

Esta función se proporciona para garantizar la compatibilidad con STL y añade la cadena « other » al principio de esta cadena. Es equivalente a « prepend(other) ».

Véase también prepend().

void QString::push_front(QChar ch)

Añade el carácter ch al principio de esta cadena.

Esta es una función sobrecargada.

QString::reverse_iterator QString::rbegin()

Devuelve un iterador inverso al estilo STL que apunta al primer carácter de la cadena, en orden inverso.

Advertencia: El iterador devuelto deja de ser válido al desacoplarse o cuando se modifica el objeto ` QString `.

Véase también begin(), crbegin() y rend().

QString::const_reverse_iterator QString::rbegin() const

Esta es una función sobrecargada.

QString &QString::remove(const QRegularExpression &re)

Elimina todas las apariciones de la expresión regular « re » en la cadena y devuelve una referencia a la misma. Por ejemplo:

QString r = "Telephone";
r.remove(QRegularExpression("[aeiou]."));
// r == "The"

La eliminación de elementos conservará la capacidad de la cadena y no reducirá la cantidad de memoria asignada. Para liberar capacidad sobrante y liberar tanta memoria como sea posible, llama a ` squeeze()` tras el último cambio en el tamaño de la cadena.

Véase también ` indexOf()`, ` lastIndexOf()` y ` replace()`.

QString &QString::remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Elimina todas las apariciones del carácter ch en esta cadena y devuelve una referencia a dicha cadena.

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Ejemplo:

QString t = "Ali Baba";
t.remove(QChar('a'), Qt::CaseInsensitive);
// t == "li Bb"

Esto es lo mismo que replace(ch, "", cs).

La eliminación de elementos conservará la capacidad de la cadena y no reducirá la cantidad de memoria asignada. Para liberar capacidad sobrante y liberar tanta memoria como sea posible, llama a ` squeeze()` tras el último cambio en el tamaño de la cadena.

Véase también replace().

QString &QString::remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Elimina todas las apariciones de la cadena « str » en esta cadena y devuelve una referencia a esta cadena.

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Esto es lo mismo que replace(str, "", cs).

La eliminación de elementos conservará la capacidad de la cadena y no reducirá la cantidad de memoria asignada. Para liberar capacidad sobrante y liberar tanta memoria como sea posible, llama a squeeze() tras el último cambio en el tamaño de la cadena.

Véase también replace().

QString &QString::remove(qsizetype position, qsizetype n)

Elimina los caracteres n de la cadena, a partir del índice position especificado, y devuelve una referencia a la cadena.

Si el índice position especificado se encuentra dentro de la cadena, pero position + n supera el final de la cadena, esta se trunca en el punto especificado position.

Si n es <= 0, no se produce ningún cambio.

QString s = "Montreal";
s.remove(1, 4);
// s == "Meal"

La eliminación de elementos conservará la capacidad de la cadena y no reducirá la cantidad de memoria asignada. Para liberar capacidad sobrante y liberar tanta memoria como sea posible, llama a squeeze() tras el último cambio en el tamaño de la cadena.

Véase también ` insert()` y ` replace()`.

QString &QString::remove(QLatin1StringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Elimina de esta cadena todas las apariciones de la cadena Latin-1 especificada, tal y como la interpreta str, y devuelve una referencia a esta cadena.

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Esto equivale a ` replace(str, "", cs)`.

La eliminación de elementos conservará la capacidad de la cadena y no reducirá la cantidad de memoria asignada. Para liberar la capacidad sobrante y liberar tanta memoria como sea posible, llama a ` squeeze()` tras el último cambio en el tamaño de la cadena.

Esta es una función sobrecargada.

Véase también replace().

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

Elimina el carácter situado 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] QString &QString::removeFirst()

Elimina el primer carácter de esta cadena. Si la cadena 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> QString &QString::removeIf(Predicate pred)

Elimina de la cadena todos los elementos para los que el predicado « pred » devuelve «true». Devuelve una referencia a la cadena.

Esta función se introdujo en Qt 6.1.

Véase también remove().

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

Elimina el último carácter de esta cadena. Si la cadena 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().

QString::reverse_iterator QString::rend()

Devuelve un iterador inverso al estilo STL que apunta justo después del último carácter de la cadena, en orden inverso.

Advertencia: El iterador devuelto deja de ser válido al desacoplarse o cuando se modifica el objeto ` QString `.

Véase también end(), crend() y rbegin().

QString::const_reverse_iterator QString::rend() const

Esta es una función sobrecargada.

QString QString::repeated(qsizetype times) const

Devuelve una copia de esta cadena repetida el número especificado de times.

Si times es menor que 1, se devuelve una cadena vacía.

Ejemplo:

QString str("ab");
str.repeated(4);            // returns "abababab"

QString &QString::replace(qsizetype position, qsizetype n, const QString &after)

Sustituye los caracteres « n » que comienzan en el índice « position » por la cadena « after » y devuelve una referencia a dicha cadena.

Nota: Si el índice especificado position se encuentra dentro de la cadena, pero position + n se sale del rango de la cadena, entonces n se ajustará para terminar al final de la cadena.

Ejemplo:

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

Véase también insert() y remove().

QString &QString::replace(const QRegularExpression &re, const QString &after)

Sustituye cada aparición de la expresión regular re en la cadena por after. Devuelve una referencia a la cadena. Por ejemplo:

QString s = "Banana";
s.replace(QRegularExpression("a[mn]"), "ox");
// s == "Boxoxa"

En el caso de expresiones regulares que contengan grupos de captura, las apariciones de \1, \2, ..., en « after » se sustituyen por la cadena capturada por el grupo de captura correspondiente.

QString t = "A <i>bon mot</i>.";
t.replace(QRegularExpression("<i>([^<]*)</i>"), "\\emph{\\1}");
// t == "A \\emph{bon mot}."

Esta función sobrecarga QString::replace().

Véase también indexOf(), lastIndexOf(), remove(), QRegularExpression y QRegularExpressionMatch.

QString &QString::replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Sustituye cada aparición del carácter « before » por el carácter « after » y devuelve una referencia a esta cadena.

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Esta función sobrecarga QString::replace().

QString &QString::replace(QChar c, QLatin1StringView after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Sustituye todas las apariciones del carácter « c » por la cadena « after » y devuelve una referencia a dicha cadena.

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Nota: El texto no se vuelve a analizar tras una sustitución.

Esta función sobrescribe la función QString::replace().

QString &QString::replace(QChar ch, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Sustituye cada aparición del carácter ch en la cadena por after y devuelve una referencia a dicha cadena.

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Esta función sobrecarga la función QString::replace().

QString &QString::replace(QLatin1StringView before, QLatin1StringView after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Sustituye cada aparición en esta cadena de la cadena en Latin-1 que se ve en before por la cadena en Latin-1 que se ve en after, y devuelve una referencia a esta cadena.

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Nota: El texto no se vuelve a analizar tras una sustitución.

Nota: Si se utiliza un argumento ` before ` vacío, el argumento ` after ` se insertará antes y después de cada carácter de la cadena.

Esta función sobrecarga la función QString::replace().

QString &QString::replace(QLatin1StringView before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Sustituye cada aparición en esta cadena de la cadena Latin-1 visualizada por before por la cadena after, y devuelve una referencia a esta cadena.

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Nota: El texto no se vuelve a analizar tras una sustitución.

Nota: Si se utiliza un argumento ` before ` vacío, el argumento ` after ` se insertará antes y después de cada carácter de la cadena.

Esta función sobrecarga la función QString::replace().

QString &QString::replace(const QString &before, QLatin1StringView after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Sustituye todas las apariciones de la cadena « before » por la cadena « after » y devuelve una referencia a esta cadena.

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Nota: El texto no se vuelve a analizar tras una sustitución.

Nota: Si se utiliza un argumento before vacío, el argumento after se insertará antes y después de cada carácter de la cadena.

Esta función sobrecarga la función QString::replace().

QString &QString::replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Sustituye cada aparición de la cadena « before » por la cadena « after » y devuelve una referencia a esta cadena.

Si cs es Qt::CaseSensitive (valor predeterminado), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Ejemplo:

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

Nota: El texto de sustitución no se vuelve a analizar tras su inserción.

Ejemplo:

QString equis = "xxxxxx";
equis.replace("xx", "x");
// equis == "xxx"

Nota: Si se utiliza un argumento « before » vacío, el argumento « after » se insertará antes y después de cada carácter de la cadena.

Esta función sobrecarga la función QString::replace().

QString &QString::replace(qsizetype position, qsizetype n, QChar after)

Sustituye los caracteres de la cadena ` n ` que comienzan en el índice ` position ` por el carácter ` after ` y devuelve una referencia a esta cadena.

Esta función sobrecarga la función QString::replace().

QString &QString::replace(qsizetype position, qsizetype n, const QChar *after, qsizetype alen)

Sustituye los caracteres « n » que comienzan en el índice « position » por los primeros « alen » caracteres de la matriz « QChar » « after » y devuelve una referencia a esta cadena.

n no debe ser negativo.

Esta función sobrecarga ` QString::replace()`.

QString &QString::replace(const QChar *before, qsizetype blen, const QChar *after, qsizetype alen, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Sustituye cada aparición en esta cadena de los primeros blen caracteres de before por los primeros alen caracteres de after y devuelve una referencia a esta cadena.

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

Nota: Si before apunta a una cadena vacía (es decir, blen == 0), la cadena a la que apunta after se insertará antes y después de cada carácter de esta cadena.

Esta función sobrecarga QString::replace().

void QString::reserve(qsizetype size)

Garantiza que la cadena tenga espacio para al menos size caracteres.

Si sabes de antemano cuál será el tamaño de una cadena, puedes llamar a esta función para evitar reasignaciones repetidas mientras la construyes. Esto puede mejorar el rendimiento al construir una cadena de forma incremental. Una larga secuencia de operaciones que añaden contenido a una cadena puede provocar varias reasignaciones, la última de las cuales puede dejarte con mucho más espacio del que necesitas. Esto es menos eficiente que realizar una única asignación del tamaño adecuado desde el principio.

En caso de duda 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 cadena 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 tenido tu mejor sobreestimación y ralentizará la operación que la desencadena.

Advertencia: reserve () reserva memoria, pero no modifica el tamaño de la cadena. Acceder a datos más allá del final de la cadena es un comportamiento indefinido. Si necesitas acceder a memoria más allá del final actual de la cadena, utiliza resize().

Esta función resulta útil para código que necesita construir una cadena larga y desea evitar reasignaciones repetidas. En este ejemplo, queremos ir añadiendo elementos a la cadena hasta que se cumpla una determinada condición true, y estamos bastante seguros de que ese tamaño es lo suficientemente grande como para que merezca la pena llamar a `reserve()`:

QString result;
qsizetype maxSize;
bool condition;
QChar nextChar;

result.reserve(maxSize);

while (condition)
    result.append(nextChar);

result.squeeze();

Véanse también squeeze(), capacity() y resize().

void QString::resize(qsizetype size)

Establece el tamaño de la cadena en size caracteres.

Si size es mayor que el tamaño actual, la cadena se amplía hasta alcanzar una longitud de size caracteres, añadiendo los caracteres adicionales al final. Los nuevos caracteres no están inicializados.

Si ` size ` es menor que el tamaño actual, los caracteres que se encuentren más allá de la posición ` size ` se excluyen de la cadena.

Nota: Aunque resize() aumentará la capacidad si es necesario, nunca la reduce. Para eliminar el exceso de capacidad, utiliza squeeze().

Ejemplo:

QString s = "Hello world";
s.resize(5);
// s == "Hello"

s.resize(8);
// s == "Hello???" (where ? stands for any character)

Si deseas añadir un número determinado de caracteres idénticos a la cadena, utiliza la sobrecarga de resize(qsizetype, QChar).

Si quieres ampliar la cadena para que alcance una anchura determinada y rellenar las nuevas posiciones con un carácter concreto, utiliza la función ` leftJustified()`:

Si size es negativo, equivale a pasar cero.

QString r = "Hello";
r = r.leftJustified(10, ' ');
// r == "Hello     "

Véase también truncate(), reserve() y squeeze().

void QString::resize(qsizetype newSize, QChar fillChar)

A diferencia de ` resize` (`qsizetype`), esta sobrecarga inicializa los nuevos caracteres con ` fillChar`:

QString t = "Hello";
t.resize(t.size() + 10, 'X');
// t == "HelloXXXXXXXXXX"

Esta es una función sobrecargada.

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

Establece el tamaño de la cadena en size caracteres. Si el tamaño de la cadena aumenta, los nuevos caracteres 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()`.

QString QString::right(qsizetype n) const &

Devuelve una subcadena que contiene los n caracteres situados más a la derecha de la cadena.

Si sabes que ` n ` 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 cadena completa si ` n ` es mayor o igual que ` size()`, o menor que cero.

Véase también endsWith(), last(), first(), sliced(), chopped(), chop(), truncate() y slice().

QString QString::rightJustified(qsizetype width, QChar fill = u' ', bool truncate = false) const

Devuelve una cadena de tipo size() width que contiene el carácter fill seguido de la cadena. Por ejemplo:

QString s = "apple";
QString t = s.rightJustified(8, '.');    // t == "...apple"

Si truncate es false y el size() de la cadena es mayor que width, entonces la cadena devuelta es una copia de la cadena.

Si truncate es true y el size() de la cadena es mayor que width, entonces la cadena resultante se trunca en la posición width.

QString str = "Pineapple";
str = str.rightJustified(5, '.', true);    // str == "Pinea"

Véase también leftJustified().

QString QString::section(QChar sep, qsizetype start, qsizetype end = -1, QString::SectionFlags flags = SectionDefault) const

Esta función devuelve una parte de la cadena.

Esta cadena se trata como una secuencia de campos separados por el carácter sep. La cadena devuelta está formada por los campos desde la posición start hasta la posición end, ambas incluidas. Si no se especifica end, se incluyen todos los campos desde la posición start hasta el final de la cadena. Los campos se numeran 0, 1, 2, etc., contando desde la izquierda, y -1, -2, etc., contando de derecha a izquierda.

El argumento flags se puede utilizar para modificar algunos aspectos del comportamiento de la función, por ejemplo, si se distingue entre mayúsculas y minúsculas, si se omiten los campos vacíos y cómo se tratan los separadores iniciales y finales; véase SectionFlags.

QString str;
QString csv = "forename,middlename,surname,phone";
QString path = "/usr/local/bin/myapp"; // First field is empty
QString::SectionFlag flag = QString::SectionSkipEmpty;

str = csv.section(',', 2, 2);   // str == "surname"
str = path.section('/', 3, 4);  // str == "bin/myapp"
str = path.section('/', 3, 3, flag); // str == "myapp"

Si start o end es negativo, se cuentan los campos desde la derecha de la cadena, siendo el campo más a la derecha el -1, el siguiente el -2, y así sucesivamente.

str = csv.section(',', -3, -2);  // str == "middlename,surname"
str = path.section('/', -1); // str == "myapp"

Véase también split().

QString QString::section(const QRegularExpression &re, qsizetype start, qsizetype end = -1, QString::SectionFlags flags = SectionDefault) const

Esta cadena se trata como una secuencia de campos separados por la expresión regular « re ».

QString line = "forename\tmiddlename  surname \t \t phone";
QRegularExpression sep("\\s+");
str = line.section(sep, 2, 2); // str == "surname"
str = line.section(sep, -3, -2); // str == "middlename  surname"

Advertencia: El uso de esta versión de « QRegularExpression » resulta mucho más costoso que las versiones sobrecargadas para cadenas y caracteres.

Esta función sobrecarga « QString::section()».

Véase también split() y simplified().

QString QString::section(const QString &sep, qsizetype start, qsizetype end = -1, QString::SectionFlags flags = SectionDefault) const

QString str;
QString data = "forename**middlename**surname**phone";

str = data.section("**", 2, 2); // str == "surname"
str = data.section("**", -3, -2); // str == "middlename**surname"

Esta función sobrescribe la función QString::section().

Véase también split().

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

Establece la cadena con el valor impreso de « n » en el « base » especificado y devuelve una referencia a la cadena.

La base es 10 por defecto y debe estar comprendida entre 2 y 36.

QString str;
str.setNum(1234);       // str == "1234"

El formato siempre utiliza « QLocale::C », es decir, inglés de Estados Unidos. Para obtener una representación localizada de un número en forma de cadena, utiliza « QLocale::toString()» con la configuración regional adecuada.

Véase también number().

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

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

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

Establece la cadena con el valor impreso de n, formateado según lo indicado en format y precision, y devuelve una referencia a la cadena.

Esta es una función sobrecargada.

Véanse también number(), QLocale::FloatingPointPrecisionOption y Number formats.

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

Establece la cadena con el valor impreso de n, formateado según los valores proporcionados en format y precision, y devuelve una referencia a la cadena.

El formateo siempre utiliza QLocale::C, es decir, inglés/Estados Unidos. Para obtener una representación localizada de un número en forma de cadena, utiliza QLocale::toString() con la configuración regional adecuada.

Esta es una función sobrecargada.

Véase también number().

QString &QString::setRawData(const QChar *unicode, qsizetype size)

Restablece el objeto ` QString ` para que utilice los primeros caracteres Unicode ` size ` de la matriz ` unicode`. Los datos de ` unicode ` no se copian. La función que realiza la llamada debe poder garantizar que ` unicode ` no se eliminará ni modificará mientras exista ` QString ` (o una copia no modificada de la misma).

Esta función puede utilizarse en lugar de fromRawData() para reutilizar objetos QString existentes y así ahorrar reasignaciones de memoria.

Véanse también fromRawData(), nullTerminate() y nullTerminated().

QString &QString::setUnicode(const QChar *unicode, qsizetype size)

Ajusta el tamaño de la cadena a size caracteres y copia unicode en la cadena.

Si unicode es nullptr, no se copia nada, pero la cadena se sigue ajustando a size.

Véase también unicode() y setUtf16().

[since 6.9] QString &QString::setUnicode(const char16_t *unicode, qsizetype size)

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.9.

Véase también unicode() y setUtf16().

[since 6.9] QString &QString::setUtf16(const char16_t *unicode, qsizetype size)

Ajusta el tamaño de la cadena a size caracteres y copia unicode en la cadena.

Si unicode es nullptr, no se copia nada, pero la cadena se redimensiona igualmente a size.

Ten en cuenta que, a diferencia de fromUtf16(), esta función no tiene en cuenta los BOM ni los posibles cambios en el orden de los bytes.

Esta función se introdujo en Qt 6.9.

Véanse también utf16() y setUnicode().

void QString::shrink_to_fit()

Esta función se proporciona para garantizar la compatibilidad con STL. Es equivalente a squeeze().

Véase también squeeze().

QString QString::simplified() const

Devuelve una cadena a la que se le han eliminado los espacios en blanco del principio y del final, y en la que cada secuencia de espacios en blanco internos se ha sustituido por un único espacio.

Se entiende por «espacio en blanco» cualquier carácter para el que QChar::isSpace() devuelva true. Esto incluye los caracteres ASCII «'\t », «\n », «\v », «\f », «\r » y «».

Ejemplo:

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

Véase también trimmed().

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

Devuelve el número de caracteres de esta cadena.

El último carácter de la cadena se encuentra en la posición size() - 1.

Ejemplo:

QString str = "World";
qsizetype n = str.size();   // n == 5
str.data()[0];              // returns 'W'
str.data()[4];              // returns 'd'

Véanse también isEmpty() y resize().

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

Modifica esta cadena para que comience en la posición pos, hasta el carácter (punto de código) situado en la posición de índice pos + n; y devuelve una referencia a esta cadena.

Nota: El comportamiento es indefinido si pos < 0, n < 0 o pos + n > size().

QString x = u"Nine pineapples"_s;
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] QString &QString::slice(qsizetype pos)

Modifica esta cadena para que comience en la posición pos y se extienda hasta su final, y devuelve una referencia a dicha cadena.

Nota: El comportamiento es indefinido si pos < 0 o 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] QString QString::sliced(qsizetype pos, qsizetype n) &&

[since 6.0] QString QString::sliced(qsizetype pos, qsizetype n) const &

Devuelve una cadena que contiene los caracteres « n » de esta cadena, desde la posición pos hasta, sin incluir, el elemento situado en el índice pos + n.

Nota: El comportamiento es indefinido cuando pos < 0, n < 0 o pos + n > size().

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

Estas funciones se introdujeron en Qt 6.0.

Véanse también first(), last(), chopped(), chop(), truncate() y slice().

[since 6.0] QString QString::sliced(qsizetype pos) &&

[since 6.0] QString QString::sliced(qsizetype pos) const &

Devuelve una cadena que contiene la parte de esta cadena que comienza en la posición pos y se extiende hasta su final.

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

QStringList QString::split(const QString &sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Divide la cadena en subcadenas cada vez que aparece sep y devuelve la lista de dichas cadenas. Si sep no coincide en ningún punto de la cadena, split() devuelve una lista de un solo elemento que contiene esta cadena.

cs Especifica si la búsqueda de « sep » debe realizarse distinguiendo entre mayúsculas y minúsculas o sin distinguirlas.

Si behavior es Qt::SkipEmptyParts, las entradas vacías no aparecen en el resultado. Por defecto, se conservan las entradas vacías.

Ejemplo:

QString str = QStringLiteral("a,,b,c");

QStringList list1 = str.split(u',');
// list1: [ "a", "", "b", "c" ]

QStringList list2 = str.split(u',', Qt::SkipEmptyParts);
// list2: [ "a", "b", "c" ]

Si ` sep ` está vacía, `split()` devuelve una cadena vacía, seguida de cada uno de los caracteres de la cadena, y a continuación otra cadena vacía:

QString str = "abc";
auto parts = str.split(QString());
// parts: {"", "a", "b", "c", ""}

Para comprender este comportamiento, recuerda que la cadena vacía coincide con cualquier parte, por lo que lo anterior es, en esencia, lo mismo que:

QString str = "/a/b/c/";
auto parts = str.split(u'/');
// parts: {"", "a", "b", "c", ""}

Véase también QStringList::join() y section().

QStringList QString::split(const QRegularExpression &re, Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const

Divide la cadena en subcadenas cada vez que coincida la expresión regular re y devuelve la lista de dichas cadenas. Si re no coincide en ningún punto de la cadena, split() devuelve una lista de un solo elemento que contiene dicha cadena.

A continuación se muestra un ejemplo en el que extraemos las palabras de una frase utilizando uno o más caracteres de espacio en blanco como separador:

QString str;
QStringList list;

str = "Some  text\n\twith  strange whitespace.";
list = str.split(QRegularExpression("\\s+"));
// list: [ "Some", "text", "with", "strange", "whitespace." ]

A continuación se muestra un ejemplo similar, pero en esta ocasión utilizamos cualquier secuencia de caracteres que no formen parte de una palabra como separador:

str = "This time, a normal English sentence.";
list = str.split(QRegularExpression("\\W+"), Qt::SkipEmptyParts);
// list: [ "This", "time", "a", "normal", "English", "sentence" ]

A continuación se muestra un tercer ejemplo en el que utilizamos una aserción de longitud cero, \b (límite de palabra), para dividir la cadena en una secuencia alterna de tokens que no son palabras y de tokens que sí son palabras:

str = "Now: this sentence fragment.";
list = str.split(QRegularExpression("\\b"));
// list: [ "", "Now", ": ", "this", " ", "sentence", " ", "fragment", "." ]

Esta es una función sobrecargada.

Véase también QStringList::join() y section().

QStringList QString::split(QChar sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Esta es una función sobrecargada.

void QString::squeeze()

Libera toda la memoria que no sea necesaria para almacenar los datos de los caracteres.

El único propósito de esta función es proporcionar un medio para ajustar con precisión el uso de memoria de QString. En general, rara vez necesitarás llamar a esta función.

Véanse también reserve() y capacity().

bool QString::startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve « true » si la cadena comienza por « s »; en caso contrario, devuelve « false ».

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, no distingue entre mayúsculas y minúsculas.

QString str = "Bananas";
str.startsWith("Ban");     // returns true
str.startsWith("Car");     // returns false

Véase también endsWith().

bool QString::startsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve « true » si la cadena comienza por « c »; en caso contrario, devuelve « false ».

Esta función sobrecarga QString::startsWith().

bool QString::startsWith(QLatin1StringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Esta función sobrescribe la función « QString::startsWith()».

[noexcept] bool QString::startsWith(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Devuelve « true » si la cadena comienza con la vista de cadena « str »; en caso contrario, devuelve « false ».

Si cs es Qt::CaseSensitive (el valor por defecto), la búsqueda distingue entre mayúsculas y minúsculas; en caso contrario, la búsqueda no distingue entre mayúsculas y minúsculas.

Esta es una función sobrecargada.

Véase también endsWith().

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

Intercambia esta cadena con other. Esta operación es muy rápida y nunca falla.

CFStringRef QString::toCFString() const

Crea un CFString a partir de un ` QString`.

El autor de la llamada es el propietario del CFString y es responsable de liberarlo.

Nota: esta función solo está disponible en macOS e iOS.

QString QString::toCaseFolded() const

Devuelve el equivalente de la cadena con mayúsculas y minúsculas unificadas. Para la mayoría de los caracteres Unicode, el resultado es el mismo que el de la función ` toLower()`.

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

Devuelve la cadena convertida a un valor de tipo « double ».

Devuelve infinito si se produce un desbordamiento en 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.

QString str = "1234.56";
double val = str.toDouble();   // val == 1234.56

Advertencia: El contenido de QString solo puede contener caracteres numéricos válidos, lo que incluye el signo más/menos, la letra «e» utilizada en notación científica y el punto decimal. Incluir la unidad o caracteres adicionales provoca un error de conversión.

bool ok;
double d;

d = QString( "1234.56e-02" ).toDouble(&ok); // ok == true, d == 12.3456

d = QString( "1234.56e-02 Volt" ).toDouble(&ok); // ok == false, d == 0

La conversión de la cadena se realizará siempre en la configuración regional «C». Para una conversión dependiente de la configuración regional, utiliza QLocale::toDouble().

d = QString( "1234,56" ).toDouble(&ok); // ok == false
d = QString( "1234.56" ).toDouble(&ok); // ok == true, d == 1234.56

Por motivos históricos, esta función no gestiona los separadores de miles. Si necesitas convertir este tipo de números, utiliza QLocale::toDouble().

d = QString( "1,234,567.89" ).toDouble(&ok); // ok == false
d = QString( "1234567.89" ).toDouble(&ok); // ok == true

Esta función ignora los espacios en blanco iniciales y finales.

Véase también number(), QLocale::setDefault(), QLocale::toDouble() y trimmed().

[since 6.6] emscripten::val QString::toEcmaString() const

Convierte este objeto en una cadena de ECMAScript.

Esta función se introdujo en Qt 6.6.

Véase también fromEcmaString().

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

Devuelve la cadena convertida a un valor de tipo « float ».

Devuelve infinito si la conversión produce un desbordamiento 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.

Advertencia: El contenido de « QString » solo puede contener caracteres numéricos válidos, lo que incluye el signo más/menos, la letra «e» utilizada 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.

La conversión de cadenas se realizará siempre en la configuración regional «C». Para una conversión dependiente de la configuración regional, utiliza QLocale::toFloat().

Por motivos históricos, esta función no admite separadores de miles. Si necesitas convertir este tipo de números, utiliza QLocale::toFloat().

Ejemplo:

QString str1 = "1234.56";
str1.toFloat();             // returns 1234.56

bool ok;
QString str2 = "R2D2";
str2.toFloat(&ok);          // returns 0.0, sets ok to false

QString str3 = "1234.56 Volt";
str3.toFloat(&ok);          // returns 0.0, sets ok to false

Esta función ignora los espacios en blanco iniciales y finales.

Véase también number(), toDouble(), toInt(), QLocale::toFloat() y trimmed().

QString QString::toHtmlEscaped() const

Convierte una cadena de texto sin formato en una cadena HTML, sustituyendo los metacaracteres HTML <, >, & y " por entidades HTML.

Ejemplo:

QString plain = "#include <QtCore>";
QString html = plain.toHtmlEscaped();
// html == "#include &lt;QtCore&gt;"

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

Devuelve la cadena convertida a un ` int ` utilizando la base ` base`, que es 10 por defecto y debe estar comprendida entre 2 y 36, o bien 0. Devuelve 0 si la conversión falla.

Si « ok » no es « nullptr », se notifica el error estableciendo *«ok » en « false », y el éxito estableciendo *«ok » en « true ».

Si base es 0, se utiliza la convención del lenguaje C: si la cadena comienza por «0x», se utiliza la base 16; en caso contrario, si la cadena comienza por «0b», se utiliza la base 2; si no, si la cadena comienza por «0», se utiliza la base 8; en caso contrario, se utiliza la base 10.

La conversión de la cadena siempre se realizará en la configuración regional «C». Para una conversión dependiente de la configuración regional, utilice QLocale::toInt()

Ejemplo:

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

Esta función ignora los espacios en blanco iniciales y finales.

Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.

Véase también number(), toUInt(), toDouble() y QLocale::toInt().

QByteArray QString::toLatin1() const

Devuelve una representación en Latin-1 de la cadena como un objeto ` QByteArray`.

La matriz de bytes devuelta no está definida si la cadena contiene caracteres que no sean Latin-1. Esos caracteres pueden suprimirse o sustituirse por un signo de interrogación.

Véase también fromLatin1(), toUtf8(), toLocal8Bit() y QStringEncoder.

QByteArray QString::toLocal8Bit() const

Devuelve la representación local de 8 bits de la cadena como un objeto ` QByteArray`.

En sistemas Unix, esto equivale a ` toUtf8()`. Ten en cuenta que, en sistemas Apple, esta función no tiene en cuenta `NSString.defaultCStringEncoding ` ni `CFStringGetSystemEncoding()`, ya que estas funciones suelen devolver la codificación heredada «Western (Mac OS Roman)», que no debería utilizarse en los sistemas operativos modernos de Apple. En Windows se utiliza la página de códigos actual del sistema.

Si esta cadena contiene algún carácter que no pueda codificarse en la codificación local de 8 bits, la matriz de bytes devuelta es indefinida. Esos caracteres pueden suprimirse o sustituirse por otros.

Véase también fromLocal8Bit(), toLatin1(), toUtf8() y QStringEncoder.

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

Devuelve la cadena convertida a un « long » utilizando la base « base », que es 10 por defecto y debe estar comprendida entre 2 y 36, o bien 0. Devuelve 0 si la conversión falla.

Si « ok » no es « nullptr », se notifica el error estableciendo *ok en « false », y el éxito estableciendo *ok en « true ».

Si base es 0, se utiliza la convención del lenguaje C: si la cadena comienza por «0x», se utiliza la base 16; en caso contrario, si la cadena comienza por «0b», se utiliza la base 2; si tampoco es así, si la cadena comienza por «0», se utiliza la base 8; en caso contrario, se utiliza la base 10.

La conversión de la cadena se realizará siempre en la configuración regional «C». Para una conversión dependiente de la configuración regional, utilice QLocale::toLongLong()

Ejemplo:

QString str = "FF";
bool ok;

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

Esta función ignora los espacios en blanco iniciales y finales.

Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.

Véase también number(), toULong(), toInt() y QLocale::toInt().

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

Devuelve la cadena convertida a un ` long long ` utilizando la base ` base`, que es 10 por defecto y debe estar comprendida entre 2 y 36, o bien 0. Devuelve 0 si la conversión falla.

Si ` ok ` no es ` nullptr`, se notifica el error estableciendo *`ok ` en ` false`, y el éxito estableciendo *`ok ` en ` true`.

Si base es 0, se utiliza la convención del lenguaje C: si la cadena comienza por «0x», se utiliza la base 16; en caso contrario, si la cadena comienza por «0b», se utiliza la base 2; si la cadena comienza por «0», se utiliza la base 8; en caso contrario, se utiliza la base 10.

La conversión de la cadena se realizará siempre en la configuración regional «C». Para una conversión dependiente de la configuración regional, utiliza QLocale::toLongLong()

Ejemplo:

QString str = "FF";
bool ok;

qint64 hex = str.toLongLong(&ok, 16);      // hex == 255, ok == true
qint64 dec = str.toLongLong(&ok, 10);      // dec == 0, ok == false

Esta función ignora los espacios en blanco iniciales y finales.

Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.

Véase también number(), toULongLong(), toInt() y QLocale::toLongLong().

QString QString::toLower() const

Devuelve una copia de la cadena en minúsculas.

QString str = "The Qt PROJECT";
str = str.toLower();        // str == "the qt project"

La conversión de mayúsculas y minúsculas se realizará siempre según la configuración regional «C». Para una conversión de mayúsculas y minúsculas dependiente de la configuración regional, utiliza QLocale::toLower()

Véase también toUpper() y QLocale::toLower().

NSString *QString::toNSString() const

Crea un objeto `NSString` a partir de un objeto ` QString`.

El NSString se libera automáticamente.

Nota: esta función solo está disponible en macOS e iOS.

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

Devuelve la cadena convertida a un ` short ` utilizando la base ` base`, que es 10 por defecto y debe estar comprendida entre 2 y 36, o bien 0. Devuelve 0 si la conversión falla.

Si « ok » no es « nullptr », se notifica el error estableciendo *ok en « false », y el éxito estableciendo *ok en « true ».

Si base es 0, se utiliza la convención del lenguaje C: si la cadena comienza por «0x», se utiliza la base 16; en caso contrario, si la cadena comienza por «0b», se utiliza la base 2; si no, si la cadena comienza por «0», se utiliza la base 8; en caso contrario, se utiliza la base 10.

La conversión de la cadena siempre se realizará en la configuración regional «C». Para una conversión dependiente de la configuración regional, utilice ` QLocale::toShort()`

Ejemplo:

QString str = "FF";
bool ok;

short hex = str.toShort(&ok, 16);   // hex == 255, ok == true
short dec = str.toShort(&ok, 10);   // dec == 0, ok == false

Esta función ignora los espacios en blanco iniciales y finales.

Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.

Véase también number(), toUShort(), toInt() y QLocale::toShort().

std::string QString::toStdString() const

Devuelve un objeto `std::string` con los datos contenidos en este ` QString`. Los datos Unicode se convierten en caracteres de 8 bits mediante la función ` toUtf8()`.

Este método resulta especialmente útil para pasar un objeto ` QString ` a una función que acepte un objeto `std::string`.

Véase también toLatin1(), toUtf8(), toLocal8Bit() y QByteArray::toStdString().

std::u16string QString::toStdU16String() const

Devuelve un objeto `std::u16string` con los datos contenidos en este ` QString`. Los datos Unicode son los mismos que los devueltos por el método `utf16()`.

Véase también utf16(), toStdWString() y toStdU32String().

std::u32string QString::toStdU32String() const

Devuelve un objeto std::u32string con los datos contenidos en este ` QString`. Los datos Unicode son los mismos que devuelve el método ` toUcs4()`.

Véanse también toUcs4(), toStdWString() y toStdU16String().

std::wstring QString::toStdWString() const

Devuelve un objeto `std::wstring` con los datos contenidos en este ` QString`. El objeto `std::wstring` se codifica en UTF-16 en plataformas donde `wchar_t` tiene 2 bytes de ancho (por ejemplo, Windows) y en UTF-32 en plataformas donde `wchar_t` tiene 4 bytes de ancho (la mayoría de los sistemas Unix).

Este método resulta especialmente útil para pasar un objeto ` QString ` a una función que acepte un objeto `std::wstring`.

Véanse también utf16(), toLatin1(), toUtf8(), toLocal8Bit(), toStdU16String() y toStdU32String().

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

Devuelve la cadena convertida a un ` unsigned int ` utilizando la base ` base`, que es 10 por defecto y debe estar comprendida entre 2 y 36, o bien 0. Devuelve 0 si la conversión falla.

Si ok no es nullptr, se notifica el error estableciendo *ok en false, y el éxito estableciendo *ok en true.

Si base es 0, se utiliza la convención del lenguaje C: si la cadena comienza por «0x», se utiliza la base 16; en caso contrario, si la cadena comienza por «0b», se utiliza la base 2; en caso contrario, si la cadena comienza por «0», se utiliza la base 8; en caso contrario, se utiliza la base 10.

La conversión de la cadena siempre se realizará en la configuración regional «C». Para una conversión dependiente de la configuración regional, utilice QLocale::toUInt()

Ejemplo:

QString str = "FF";
bool ok;

uint hex = str.toUInt(&ok, 16);     // hex == 255, ok == true
uint dec = str.toUInt(&ok, 10);     // dec == 0, ok == false

Esta función ignora los espacios en blanco iniciales y finales.

Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.

Véase también number(), toInt() y QLocale::toUInt().

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

Devuelve la cadena convertida a un unsigned long utilizando la base base, que es 10 por defecto y debe estar comprendida entre 2 y 36, o bien 0. Devuelve 0 si la conversión falla.

Si ok no es nullptr, se notifica el error estableciendo *ok en false, y el éxito estableciendo *ok en true.

Si base es 0, se utiliza la convención del lenguaje C: si la cadena comienza por «0x», se utiliza la base 16; en caso contrario, si la cadena comienza por «0b», se utiliza la base 2; si la cadena comienza por «0», se utiliza la base 8; en caso contrario, se utiliza la base 10.

La conversión de la cadena siempre se realizará en la configuración regional «C». Para una conversión dependiente de la configuración regional, utilice QLocale::toULongLong()

Ejemplo:

QString str = "FF";
bool ok;

ulong hex = str.toULong(&ok, 16);   // hex == 255, ok == true
ulong dec = str.toULong(&ok, 10);   // dec == 0, ok == false

Esta función ignora los espacios en blanco iniciales y finales.

Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.

Véase también number() y QLocale::toUInt().

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

Devuelve la cadena convertida a un « unsigned long long » utilizando la base base, que es 10 por defecto y debe estar comprendida entre 2 y 36, o bien 0. Devuelve 0 si la conversión falla.

Si ` ok ` no es ` nullptr`, se notifica el error estableciendo *`ok ` en ` false`, y el éxito estableciendo *`ok ` en ` true`.

Si base es 0, se utiliza la convención del lenguaje C: si la cadena comienza por «0x», se utiliza la base 16; en caso contrario, si la cadena comienza por «0b», se utiliza la base 2; si la cadena comienza por «0», se utiliza la base 8; en caso contrario, se utiliza la base 10.

La conversión de la cadena siempre se realizará en la configuración regional «C». Para una conversión dependiente de la configuración regional, utilice QLocale::toULongLong()

Ejemplo:

QString str = "FF";
bool ok;

quint64 hex = str.toULongLong(&ok, 16);    // hex == 255, ok == true
quint64 dec = str.toULongLong(&ok, 10);    // dec == 0, ok == false

Esta función ignora los espacios en blanco iniciales y finales.

Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.

Véase también number(), toLongLong() y QLocale::toULongLong().

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

Devuelve la cadena convertida a un ` unsigned short ` utilizando la base ` base`, que es 10 por defecto y debe estar comprendida entre 2 y 36, o bien 0. Devuelve 0 si la conversión falla.

Si ok no es nullptr, se notifica el error estableciendo *ok en false, y el éxito estableciendo *ok en true.

Si base es 0, se utiliza la convención del lenguaje C: si la cadena comienza por «0x», se utiliza la base 16; en caso contrario, si la cadena comienza por «0b», se utiliza la base 2; si tampoco es así, si la cadena comienza por «0», se utiliza la base 8; en caso contrario, se utiliza la base 10.

La conversión de la cadena siempre se realizará en la configuración regional «C». Para una conversión dependiente de la configuración regional, utilice QLocale::toUShort()

Ejemplo:

QString str = "FF";
bool ok;

ushort hex = str.toUShort(&ok, 16);     // hex == 255, ok == true
ushort dec = str.toUShort(&ok, 10);     // dec == 0, ok == false

Esta función ignora los espacios en blanco iniciales y finales.

Nota: La compatibilidad con el prefijo «0b» se añadió en Qt 6.4.

Véase también number(), toShort() y QLocale::toUShort().

QList<uint> QString::toUcs4() const

Devuelve una representación UCS-4/UTF-32 de la cadena como un valor « QList » <uint>.

UTF-32 es un códec Unicode y, por lo tanto, no presenta pérdidas. Todos los caracteres de esta cadena se codificarán en UTF-32. Cualquier secuencia no válida de unidades de código en esta cadena se sustituye por el carácter de sustitución de Unicode (QChar::ReplacementCharacter, que corresponde a U+FFFD).

La lista devuelta no termina en 0.

Véanse también fromUtf8(), toUtf8(), toLatin1(), toLocal8Bit(), QStringEncoder, fromUcs4() y toWCharArray().

QString QString::toUpper() const

Devuelve una copia de la cadena en mayúsculas.

QString str = "TeXt";
str = str.toUpper();        // str == "TEXT"

La conversión de mayúsculas y minúsculas se realizará siempre según la configuración regional «C». Para una conversión de mayúsculas y minúsculas que dependa de la configuración regional, utiliza QLocale::toUpper().

Nota: En algunos casos, la forma en mayúsculas de una cadena puede ser más larga que la original.

Nota: Desde 2024, la lengua alemana prefiere oficialmente escribir la letra ß (U+00DF, LETRA MINÚSCULA LATINA «S» AGUDA) en mayúscula como ẞ (U+1E9E, LETRA MAYÚSCULA LATINA «S» AGUDA). La implementación de Qt sigue el estándar Unicode, que sigue exigiendo el uso de «SS». Si necesitas aplicar las nuevas normas alemanas, debes llamar manualmente a replace(u'ß', u'ẞ') antes de invocar esta función.

Véase también toLower() y QLocale::toLower().

QByteArray QString::toUtf8() const

Devuelve una representación UTF-8 de la cadena como un ` QByteArray`.

UTF-8 es un códec Unicode y puede representar todos los caracteres de una cadena Unicode como QString.

Véase también fromUtf8(), toLatin1(), toLocal8Bit() y QStringEncoder.

qsizetype QString::toWCharArray(wchar_t *array) const

Rellena el ` array ` con los datos contenidos en este objeto ` QString `. La matriz se codifica en UTF-16 en plataformas en las que `wchar_t` tiene 2 bytes de ancho (por ejemplo, Windows) y en UTF-32 en plataformas en las que `wchar_t` tiene 4 bytes de ancho (la mayoría de los sistemas Unix).

array Debe ser asignado por el llamante y contener espacio suficiente para albergar la cadena completa (siempre basta con asignar una matriz de la misma longitud que la cadena).

Esta función devuelve la longitud real de la cadena en un objeto ` array`.

Nota: Esta función no añade un carácter nulo al array.

Véase también utf16(), toUcs4(), toLatin1(), toUtf8(), toLocal8Bit(), toStdWString() y QStringView::toWCharArray().

[noexcept(...), since 6.0] template <typename Needle, typename... Flags> auto QString::tokenize(Needle &&sep, Flags... flags) &&

[noexcept(...), since 6.0] template <typename Needle, typename... Flags> auto QString::tokenize(Needle &&sep, Flags... flags) const &&

[noexcept(...), since 6.0] template <typename Needle, typename... Flags> auto QString::tokenize(Needle &&sep, Flags... flags) const &

Divide la cadena en subcadenas siempre que aparezca « sep » y devuelve una secuencia diferida de dichas cadenas.

Equivalente a

return QStringTokenizer{std::forward<Needle>(sep), flags...};

, salvo que funciona sin que esté habilitada en el compilador la deducción de argumentos de plantillas de clase (CTAD) de C++17.

Consulta QStringTokenizer para ver cómo interactúan sep y flags para formar el resultado.

Nota: Aunque esta función devuelve un objeto ` QStringTokenizer`, nunca, bajo ningún concepto, debes nombrar explícitamente sus argumentos de plantilla. Si puedes utilizar la deducción de argumentos de plantillas de clase (CTAD) de C++17, puedes escribir

QStringTokenizer result = sv.tokenize(sep);

(sin argumentos de plantilla). Si no puedes utilizar la CTAD de C++17, debes almacenar el valor de retorno únicamente en variables de tipo auto:

auto result = sv.tokenize(sep);

Esto se debe a que los argumentos de plantilla de QStringTokenizer tienen una dependencia muy sutil con respecto a la sobrecarga específica de tokenize() desde la que se devuelven, y no suelen corresponder al tipo utilizado para el separador.

Estas funciones se introdujeron en Qt 6.0.

Nota: ( 1) es «noexcept» cuando ` noexcept(qTokenize(std::declval<QString>(), std::forward<Needle>(needle), flags...)) ` es ` true`.

Nota: ( 2) es «noexcept» cuando ` noexcept(qTokenize(std::declval<const QString>(), std::forward<Needle>(needle), flags...)) ` es ` true`.

Nota: ( 3) es «noexcept» cuando ` noexcept(qTokenize(std::declval<const QString &>(), std::forward<Needle>(needle), flags...)) ` es ` true`.

Véase también QStringTokenizer y qTokenize().

QString QString::trimmed() const

Devuelve una cadena a la que se le han eliminado los espacios en blanco al principio y al final.

Por «espacios en blanco» se entiende cualquier carácter para el que QChar::isSpace() devuelva true. Esto incluye los caracteres ASCII «\t », «\n », «\v », «\f », «\r » y « ».

Ejemplo:

QString str = "  lots\t of\nwhitespace\r\n ";
str = str.trimmed();
// str == "lots\t of\nwhitespace"

A diferencia de simplified(), la función trimmed() no elimina los espacios en blanco internos.

Véase también simplified().

void QString::truncate(qsizetype position)

Trunca la cadena a partir del elemento situado en el índice position, incluido este.

Si el índice position especificado se encuentra más allá del final de la cadena, no ocurre nada.

Ejemplo:

QString str = "Vladivostok";
str.truncate(4);
// str == "Vlad"

Si position es negativo, equivale a pasar cero.

Véase también chop(), resize(), first() y QStringView::truncate().

const QChar *QString::unicode() const

Devuelve una representación Unicode de la cadena. El resultado sigue siendo válido hasta que se modifique la cadena.

Nota: Es posible quela cadena devuelta no termine en «\0 ». Utiliza size() para determinar la longitud de la matriz.

Véase también setUnicode(), utf16() y fromRawData().

[static] QString QString::vasprintf(const char *cformat, va_list ap)

Método equivalente a ` asprintf()`, pero que admite una `va_list` ap en lugar de una lista de argumentos variables. Consulte la documentación de ` asprintf()` para obtener una explicación de ` cformat`.

Este método no llama a la macro va_end; el llamante es responsable de llamar a va_end en ap.

Véase también asprintf().

[noexcept, since 6.7] QString::operator std::u16string_view() const

Convierte este objeto ` QString ` en un objeto ` std::u16string_view `.

Esta función se introdujo en Qt 6.7.

QString &QString::operator+=(const QString &other)

Añade la cadena « other » al final de esta cadena y devuelve una referencia a esta cadena.

Ejemplo:

QString x = "free";
QString y = "dom";
x += y;
// x == "freedom"

Esta operación suele ser muy rápida (tiempo constante), ya que QString preasigna espacio adicional al final de los datos de la cadena para que pueda crecer sin necesidad de reasignar toda la cadena cada vez.

Véase también ` append()` y ` prepend()`.

QString &QString::operator+=(QChar ch)

Añade el carácter ch a la cadena.

Esta función sobrecarga la función QString::operator+=().

QString &QString::operator+=(QLatin1StringView str)

Añade a esta cadena la cadena en formato Latin-1 que se obtiene mediante str.

Esta función sobrecarga la función QString::operator+=().

[since 6.0] QString &QString::operator+=(QStringView str)

Añade la vista de cadena str a esta cadena.

Esta función sobrecarga el método QString::operator+=().

Esta función se introdujo en Qt 6.0.

[since 6.5] QString &QString::operator+=(QUtf8StringView str)

Añade la vista de cadena UTF-8 str a esta cadena.

Esta función sobrecarga QString::operator+=().

Esta función se introdujo en Qt 6.5.

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

Añade la matriz de bytes ba a esta cadena. La matriz de bytes se convierte a Unicode mediante la función fromUtf8(). Si hay algún carácter NUL («\0 ») incrustado en la matriz de bytes ba, se incluirá en la transformación.

Puedes desactivar esta función definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga QString::operator+=().

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

Añade la cadena « str » a esta cadena. El puntero const char se convierte a Unicode mediante la función « fromUtf8()».

Puedes desactivar esta función definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga ` QString::operator+=()`.

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

Asigna « other » a esta instancia de « QString ». .

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

Asigna ` other ` a esta cadena y devuelve una referencia a dicha cadena.

QString &QString::operator=(QChar ch)

Establece la cadena para que contenga el único carácter « ch ».

Esta función sobrecarga la función QString::operator=().

QString &QString::operator=(QLatin1StringView str)

Asigna la cadena en formato Latin-1 que muestra str a esta cadena.

Esta función sobrecarga la función QString::operator=().

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

Asigna « ba » a esta cadena. La matriz de bytes se convierte a Unicode mediante la función ` fromUtf8()`.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga ` QString::operator=()`.

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

Asigna ` str ` a esta cadena. El puntero `const char` se convierte a Unicode mediante la función ` fromUtf8()`.

Puedes desactivar este operador definiendo QT_NO_CAST_FROM_ASCII o QT_RESTRICTED_CAST_FROM_ASCII al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por QObject::tr().

Esta función sobrecarga ` QString::operator=()`.

QChar &QString::operator[](qsizetype position)

Devuelve el carácter situado en el position e especificado de la cadena como una referencia modificable.

Ejemplo:

QString str;

if (str[0] == QChar('?'))
    str[0] = QChar('_');

Véase también at().

const QChar QString::operator[](qsizetype position) const

Esta función sobrescribe la función « QString::operator[]()».

Elementos no miembros relacionados

[since 6.1] template <typename T> qsizetype erase(QString &s, const T &t)

Elimina todos los elementos de la cadena « s » 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(QString &s, Predicate pred)

Elimina de la cadena « s » todos los elementos para los que el predicado « pred » devuelva «true». Devuelve el número de elementos eliminados, si los hay.

Esta función se introdujo en Qt 6.1.

Véase también ` erase`.

[noexcept] bool operator!=(const QByteArray &lhs, const QString &rhs)

Devuelve « true » si la matriz de bytes lhs no es igual a la codificación UTF-8 de rhs; en caso contrario, devuelve « false ».

La comparación distingue entre mayúsculas y minúsculas.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. A continuación, deberás llamar explícitamente a ` QString::fromUtf8()`, ` QString::fromLatin1()` o ` QString::fromLocal8Bit()` si deseas convertir la matriz de bytes en un ` QString ` antes de realizar la comparación.

[noexcept] bool operator!=(const QString &lhs, const QString &rhs)

Devuelve « true » si la cadena « lhs » no es igual a la cadena « rhs »; en caso contrario, devuelve « false ».

Véase también Comparing Strings.

[noexcept] bool operator!=(const char *const &lhs, const QString &rhs)

Devuelve « true » si « lhs » no es igual a « rhs »; en caso contrario, devuelve « false ».

Para lhs!= 0, esto equivale a compare( lhs , rhs ) != 0 . Ten en cuenta que ninguna cadena es igual a lhs siendo 0.

[noexcept] bool operator!=(const QString &lhs, const QByteArray &rhs)

La matriz de bytes « rhs » se convierte en un « QUtf8StringView ». Si hay algún carácter NUL («\0 ») incrustado en la matriz de bytes, se incluirá en la transformación.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga ` QString::operator!=()`.

[noexcept] bool operator!=(const QString &lhs, const QLatin1StringView &rhs)

Devuelve « true » si la cadena « lhs » no es igual a la cadena « rhs ». En caso contrario, devuelve « false ».

Esta función sobrecarga QString::operator!=().

[noexcept] bool operator!=(const QString &lhs, const char *const &rhs)

El puntero `const char` de ` rhs ` se convierte en un ` QUtf8StringView`.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga ` QString::operator!=()`.

[noexcept, since 6.4] QString operator""_s(const char16_t *str, size_t size)

Operador literal que crea un objeto « QString » a partir de los primeros size caracteres del literal de cadena char16_t str.

El QString 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 QStringLiteral, pero ahorra tener que escribir tanto cuando hay muchos literales de cadena en el código.

El siguiente código crea una « QString »:

using namespace Qt::StringLiterals;

auto str = u"hello"_s;

Esta función se introdujo en Qt 6.4.

Véase también ` Qt::Literals::StringLiterals`.

QString operator+(QString &&s1, const QString &s2)

QString operator+(const QString &s1, const QString &s2)

Devuelve una cadena que es el resultado de concatenar s1 y s2.

[since 6.9] QString operator+(QStringView lhs, const QString &rhs)

[since 6.9] QString operator+(const QString &lhs, QStringView rhs)

Devuelve una cadena que es el resultado de concatenar « lhs » y « rhs ».

Estas funciones se introdujeron en Qt 6.9.

QString operator+(const QString &s1, const char *s2)

Devuelve una cadena que es el resultado de concatenar s1 y s2 (s2 se convierte a Unicode mediante la función QString::fromUtf8()).

Véase también QString::fromUtf8().

QString operator+(const char *s1, const QString &s2)

Devuelve una cadena que es el resultado de concatenar s1 y s2 (s1 se convierte a Unicode mediante la función QString::fromUtf8()).

Véase también QString::fromUtf8().

[noexcept] bool operator<(const QByteArray &lhs, const QString &rhs)

Devuelve « true » si la matriz de bytes lhs es léxicamente menor que la codificación UTF-8 de rhs; en caso contrario, devuelve « false ».

La comparación distingue entre mayúsculas y minúsculas.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. A continuación, deberás llamar explícitamente a ` QString::fromUtf8()`, ` QString::fromLatin1()` o ` QString::fromLocal8Bit()` si deseas convertir la matriz de bytes en un ` QString ` antes de realizar la comparación.

[noexcept] bool operator<(const char *const &lhs, const QString &rhs)

Devuelve « true » si « lhs » es léxicamente menor que « rhs »; en caso contrario, devuelve « false ». Para « lhs » ≠ 0, esto equivale a « compare(lhs, rhs) < 0 ».

Véase también Comparing Strings.

[noexcept] bool operator<(const QLatin1StringView &lhs, const QString &rhs)

Devuelve ` true ` si ` lhs ` es léxicamente menor que ` rhs`; en caso contrario, devuelve ` false`.

Esta función sobrecarga QString::operator<().

[noexcept] bool operator<(const QString &lhs, const QByteArray &rhs)

La matriz de bytes rhs se convierte en un QUtf8StringView. Si hay algún carácter NUL («\0 ») incrustado en la matriz de bytes, se incluirá en la transformación.

Puedes desactivar este operador QT_NO_CAST_FROM_ASCII al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por QObject::tr().

Esta función sobrecarga la función « QString::operator<()».

[noexcept] bool operator<(const QString &lhs, const QLatin1StringView &rhs)

Devuelve ` true ` si ` lhs ` es léxicamente menor que ` rhs`; en caso contrario, devuelve ` false`.

Esta función sobrecarga QString::operator<().

[noexcept] bool operator<(const QString &lhs, const QString &rhs)

Devuelve ` true ` si la cadena ` lhs ` es léxicamente menor que la cadena ` rhs`; en caso contrario, devuelve ` false`.

Esta función sobrecarga QString::operator<().

Véase también Comparing Strings.

[noexcept] bool operator<(const QString &lhs, const char *const &rhs)

Devuelve ` true ` si la cadena ` lhs ` es léxicamente menor que la cadena ` rhs`. En caso contrario, devuelve ` false`.

El puntero const char de ` rhs ` se convierte en un ` QUtf8StringView`.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga QString::operator<().

QDataStream &operator<<(QDataStream &stream, const QString &string)

Escribe el objeto « string » dado en el objeto « stream » especificado.

Véase también «Serialización detipos de datos de Qt».

[noexcept] bool operator<=(const QByteArray &lhs, const QString &rhs)

Devuelve « true » si la matriz de bytes lhs es léxicamente menor o igual que la codificación UTF-8 de rhs; en caso contrario, devuelve « false ».

La comparación distingue entre mayúsculas y minúsculas.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. A continuación, deberás llamar explícitamente a ` QString::fromUtf8()`, ` QString::fromLatin1()` o ` QString::fromLocal8Bit()` si deseas convertir la matriz de bytes en un ` QString ` antes de realizar la comparación.

[noexcept] bool operator<=(const QString &lhs, const QString &rhs)

Devuelve « true » si la cadena « lhs » es léxicamente menor o igual que la cadena « rhs »; en caso contrario, devuelve « false ».

Véase también Comparing Strings.

[noexcept] bool operator<=(const char *const &lhs, const QString &rhs)

Devuelve « true » si « lhs » es léxicamente menor o igual que « rhs »; en caso contrario, devuelve « false ». Para « lhs » ≠ 0, esto equivale a « compare(lhs, rhs) <= 0 ».

Véase también Comparing Strings.

[noexcept] bool operator<=(const QLatin1StringView &lhs, const QString &rhs)

Devuelve ` true ` si ` lhs ` es léxicamente menor o igual que ` rhs`; en caso contrario, devuelve ` false`.

Esta función sobrecarga QString::operator<=().

[noexcept] bool operator<=(const QString &lhs, const QByteArray &rhs)

La matriz de bytes « rhs » se convierte en un « QUtf8StringView ». Si hay algún carácter NUL («\0 ») incrustado en la matriz de bytes, se incluirá en la transformación.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga QString::operator<=().

[noexcept] bool operator<=(const QString &lhs, const QLatin1StringView &rhs)

Devuelve ` true ` si ` lhs ` es léxicamente menor o igual que ` rhs`; en caso contrario, devuelve ` false`.

Esta función sobrecarga QString::operator<=().

[noexcept] bool operator<=(const QString &lhs, const char *const &rhs)

El puntero `const char` de ` rhs ` se convierte en un ` QUtf8StringView`.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga ` QString::operator<=()`.

[noexcept] bool operator==(const QByteArray &lhs, const QString &rhs)

Devuelve « true » si la matriz de bytes lhs es igual a la codificación UTF-8 de rhs; en caso contrario, devuelve « false ».

La comparación distingue entre mayúsculas y minúsculas.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. A continuación, deberás llamar explícitamente a ` QString::fromUtf8()`, ` QString::fromLatin1()` o ` QString::fromLocal8Bit()` si deseas convertir la matriz de bytes en un ` QString ` antes de realizar la comparación.

[noexcept] bool operator==(const QLatin1StringView &lhs, const QString &rhs)

Devuelve ` true ` si ` lhs ` es igual a ` rhs`; en caso contrario, devuelve ` false`.

Esta función sobrecarga QString::operator==().

[noexcept] bool operator==(const QString &lhs, const QByteArray &rhs)

La matriz de bytes « rhs » se convierte en un « QUtf8StringView ».

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Devuelve true si la cadena lhs es léxicamente igual a rhs. En caso contrario, devuelve false.

Esta función sobrecarga QString::operator==().

[noexcept] bool operator==(const QString &lhs, const QLatin1StringView &rhs)

Devuelve ` true ` si ` lhs ` es igual a ` rhs`; en caso contrario, devuelve ` false`.

Esta función sobrecarga QString::operator==().

[noexcept] bool operator==(const QString &lhs, const QString &rhs)

Devuelve « true » si la cadena « lhs » es igual a la cadena « rhs »; en caso contrario, devuelve « false ».

Nota: Esta función trata las cadenas nulas de la misma forma que las cadenas vacías; para más detalles, véase Distinction Between Null and Empty Strings.

Esta función sobrecarga QString::operator==().

Véase también Comparing Strings.

[noexcept] bool operator==(const QString &lhs, const char *const &rhs)

El puntero ` rhs const char` se convierte en ` QUtf8StringView`.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga QString::operator==().

[noexcept] bool operator==(const char *const &lhs, const QString &rhs)

Devuelve « true » si « lhs » es igual a « rhs »; en caso contrario, devuelve « false ». Ten en cuenta que ninguna cadena es igual a « lhs » cuando este es 0.

Equivalente a lhs != 0 && compare(lhs, rhs) == 0.

Esta función sobrecarga QString::operator==().

[noexcept] bool operator>(const QByteArray &lhs, const QString &rhs)

Devuelve ` true ` si la matriz de bytes ` lhs ` es léxicamente mayor que la codificación UTF-8 de ` rhs`; en caso contrario, devuelve ` false`.

La comparación distingue entre mayúsculas y minúsculas.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. A continuación, deberás llamar explícitamente a ` QString::fromUtf8()`, ` QString::fromLatin1()` o ` QString::fromLocal8Bit()` si deseas convertir la matriz de bytes en un ` QString ` antes de realizar la comparación.

[noexcept] bool operator>(const QString &lhs, const QString &rhs)

Devuelve « true » si la cadena « lhs » es lexicográficamente mayor que la cadena « rhs »; en caso contrario, devuelve « false ».

Véase también Comparing Strings.

[noexcept] bool operator>(const char *const &lhs, const QString &rhs)

Devuelve ` true ` si ` lhs ` es léxicamente mayor que ` rhs`; en caso contrario, devuelve ` false`. Equivale a ` compare(lhs, rhs) > 0`.

Véase también Comparing Strings.

[noexcept] bool operator>(const QLatin1StringView &lhs, const QString &rhs)

Devuelve ` true ` si ` lhs ` es léxicamente mayor que ` rhs`; en caso contrario, devuelve ` false`.

Esta función sobrecarga QString::operator>().

[noexcept] bool operator>(const QString &lhs, const QByteArray &rhs)

La matriz de bytes « rhs » se convierte en un « QUtf8StringView ». Si hay algún carácter NUL («\0 ») incrustado en la matriz de bytes, se incluirá en la transformación.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga QString::operator>().

[noexcept] bool operator>(const QString &lhs, const QLatin1StringView &rhs)

Devuelve ` true ` si ` lhs ` es léxicamente mayor que ` rhs`; en caso contrario, devuelve ` false`.

Esta función sobrecarga la función ` QString::operator>()`.

[noexcept] bool operator>(const QString &lhs, const char *const &rhs)

El puntero `const char` de ` rhs ` se convierte en un ` QUtf8StringView`.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga la función QString::operator>().

[noexcept] bool operator>=(const QByteArray &lhs, const QString &rhs)

Devuelve « true » si la matriz de bytes lhs es mayor o igual que la codificación UTF-8 de rhs; en caso contrario, devuelve « false ».

La comparación distingue entre mayúsculas y minúsculas.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. A continuación, deberás llamar explícitamente a ` QString::fromUtf8()`, ` QString::fromLatin1()` o ` QString::fromLocal8Bit()` si deseas convertir la matriz de bytes en un ` QString ` antes de realizar la comparación.

[noexcept] bool operator>=(const QString &lhs, const QString &rhs)

Devuelve « true » si la cadena « lhs » es léxicamente mayor o igual que la cadena « rhs »; en caso contrario, devuelve « false ».

Véase también Comparing Strings.

[noexcept] bool operator>=(const char *const &lhs, const QString &rhs)

Devuelve « true » si « lhs » es léxicamente mayor o igual que « rhs »; en caso contrario, devuelve « false ». Para « lhs » ≠ 0, esto equivale a « compare(lhs, rhs) >= 0 ».

Véase también Comparing Strings.

[noexcept] bool operator>=(const QLatin1StringView &lhs, const QString &rhs)

Devuelve ` true ` si ` lhs ` es léxicamente mayor o igual que ` rhs`; en caso contrario, devuelve ` false`.

Esta función sobrecarga QString::operator>=().

[noexcept] bool operator>=(const QString &lhs, const QByteArray &rhs)

La matriz de bytes « rhs » se convierte en una « QUtf8StringView ». Si hay algún carácter NUL («\0 ») incrustado en la matriz de bytes, se incluirá en la transformación.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga ` QString::operator>=()`.

[noexcept] bool operator>=(const QString &lhs, const QLatin1StringView &rhs)

Devuelve ` true ` si ` lhs ` es léxicamente mayor o igual que ` rhs`; en caso contrario, devuelve ` false`.

Esta función sobrecarga QString::operator>=().

[noexcept] bool operator>=(const QString &lhs, const char *const &rhs)

El puntero `const char` de ` rhs ` se convierte en un ` QUtf8StringView`.

Puedes desactivar este operador definiendo ` QT_NO_CAST_FROM_ASCII ` al compilar tus aplicaciones. Esto puede resultar útil si, por ejemplo, quieres asegurarte de que todas las cadenas visibles para el usuario pasen por ` QObject::tr()`.

Esta función sobrecarga ` QString::operator>=()`.

QDataStream &operator>>(QDataStream &stream, QString &string)

Lee una cadena del archivo especificado stream y la escribe en el archivo indicado string.

Véase también Serialización detipos de datos de Qt.

Documentación de macros

QStringLiteral(str)

La macro genera los datos para un ` QString ` a partir de la cadena literal ` str ` en tiempo de compilación. En este caso, la creación de un ` QString ` a partir de ella no tiene coste alguno, y los datos de la cadena generada se almacenan en el segmento de solo lectura del archivo objeto compilado.

Si tienes un código similar a este:

// hasAttribute takes a QString argument
if (node.hasAttribute("http-contents-length")) {
    //...
}

entonces se creará un ` QString ` temporal para pasarlo como parámetro de la función ` hasAttribute `. Esto puede resultar bastante costoso, ya que implica una asignación de memoria y la copia/conversión de los datos a la codificación interna de ` QString`.

Este coste puede evitarse utilizando QStringLiteral en su lugar:

if (node.hasAttribute(QStringLiteral(u"http-contents-length"))){
    //...
}

En este caso, los datos internos de ` QString` se generarán en tiempo de compilación; no se producirá ninguna conversión ni asignación en tiempo de ejecución.

El uso de `QStringLiteral` en lugar de un literal de cadena de C++ entre comillas dobles puede acelerar significativamente la creación de instancias de ` QString ` a partir de datos conocidos en tiempo de compilación.

Nota: « QLatin1StringView » puede seguir siendo más eficiente que «QStringLiteral» cuando la cadena se pasa a una función que tiene una sobrecarga que admite « QLatin1StringView » y dicha sobrecarga evita la conversión a « QString ». Por ejemplo, «QString::operator==()» puede comparar directamente con un « QLatin1StringView »:

if (attribute.name() == "http-contents-length"_L1){
    //...
}

Nota: Algunos compiladores presentan errores al codificar cadenas que contienen caracteres fuera del conjunto de caracteres US-ASCII. Asegúrate de anteponer u a tu cadena en esos casos. En los demás casos, es opcional.

Nota: QStringLiteral es intercambiable con operator""_s. Este último ahorra tiempo al escribir cuando hay muchas cadenas literales en el código.

Véase también « QByteArrayLiteral ».

QT_NO_CAST_FROM_ASCII

Desactiva las conversiones automáticas de cadenas de 8 bits (char *) a QStrings de Unicode, así como de los tipos de char de 8 bits (char y unsigned char) a QChar.

Véase también QT_NO_CAST_TO_ASCII, QT_RESTRICTED_CAST_FROM_ASCII y QT_NO_CAST_FROM_BYTEARRAY.

QT_NO_CAST_TO_ASCII

Desactiva la conversión automática de « QString » a cadenas de 8 bits (char *).

Véase también QT_NO_CAST_FROM_ASCII, QT_RESTRICTED_CAST_FROM_ASCII y QT_NO_CAST_FROM_BYTEARRAY.

QT_RESTRICTED_CAST_FROM_ASCII

Desactiva la mayoría de las conversiones automáticas de literales de origen y datos de 8 bits a QStrings Unicode, pero permite el uso de los constructores QChar(char) y QString(const char (&ch)[N], así como del operador de asignación QString::operator=(const char (&ch)[N]). Esto ofrece la mayoría de las ventajas en materia de seguridad de tipos que ofrece QT_NO_CAST_FROM_ASCII, pero no requiere que el código del usuario envuelva los literales de caracteres y cadenas con QLatin1Char, QLatin1StringView o similares.

El uso de esta macro junto con cadenas de origen fuera del rango de 7 bits, elementos no literales o literales con caracteres NUL incrustados tiene un comportamiento indefinido.

Véase también QT_NO_CAST_FROM_ASCII y QT_NO_CAST_TO_ASCII.

const char *qPrintable(const QString &str)

Devuelve ` str ` como un ` const char *`. Esto equivale a ` str`. `toLocal8Bit()`. `constData()`.

El puntero a carácter dejará de ser válido tras la instrucción en la que se utilice qPrintable(). Esto se debe a que la matriz devuelta por QString::toLocal8Bit() quedará fuera del ámbito.

Nota: qDebug(), qInfo(), qWarning(), qCritical() y qFatal() esperan que los argumentos %s estén codificados en UTF-8, mientras que qPrintable() los convierte a la codificación local de 8 bits. Por lo tanto, se debe utilizar qUtf8Printable() para registrar cadenas en lugar de qPrintable().

Véase también qUtf8Printable().

const wchar_t *qUtf16Printable(const QString &str)

Devuelve ` str ` como un ` const ushort *`, pero lo convierte a un ` const wchar_t * ` para evitar advertencias. Esto equivale a ` str.utf16()` más algunas conversiones.

Lo único útil que se puede hacer con el valor de retorno de esta macro es pasarlo a ` QString::asprintf()` para utilizarlo en una conversión ` %ls `. En concreto, ¡el valor de retorno no es un ` const wchar_t*` válido!

En general, el puntero dejará de ser válido tras la instrucción en la que se utilice qUtf16Printable(). Esto se debe a que el puntero puede haberse obtenido a partir de una expresión temporal, que quedará fuera de ámbito.

Ejemplo:

qWarning("%ls: %ls", qUtf16Printable(key), qUtf16Printable(value));

Véase también qPrintable(), qDebug(), qInfo(), qWarning(), qCritical() y qFatal().

const char *qUtf8Printable(const QString &str)

Devuelve ` str ` como un ` const char *`. Esto equivale a ` str`. `toUtf8()`. `constData()`.

El puntero a carácter dejará de ser válido tras la instrucción en la que se utilice qUtf8Printable(). Esto se debe a que la matriz devuelta por QString::toUtf8() quedará fuera del ámbito.

Ejemplo:

qWarning("%s: %s", qUtf8Printable(key), qUtf8Printable(value));

Véase también qPrintable(), qDebug(), qInfo(), qWarning(), qCritical() y qFatal().

© 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.