QString Class

Documentation des fonctions membres

[constexpr noexcept] QString::QString()

Construit une chaîne de caractères nulle. Les chaînes nulles sont également considérées comme vides.

Voir aussi isEmpty(), isNull(), et Distinction Between Null and Empty Strings.

QString::QString(QChar ch)

Construit une chaîne de taille 1 contenant le caractère ch.

QString::QString(QLatin1StringView str)

Construit une copie de la chaîne Latin-1 visualisée par str.

Voir aussi fromLatin1().

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

Construit une chaîne initialisée avec les données de la vue chaîne.

La QString sera nulle si et seulement si sv est nulle.

Cette fonction a été introduite dans Qt 6.8.

Voir aussi fromUtf16().

QString::QString(const QByteArray &ba)

Construit une chaîne initialisée avec le tableau d'octets ba. Le tableau d'octets donné est converti en Unicode à l'aide de fromUtf8().

Vous pouvez désactiver ce constructeur en définissant QT_NO_CAST_FROM_ASCII lors de la compilation de vos applications. Cela peut être utile si vous voulez vous assurer que toutes les chaînes visibles par l'utilisateur passent par QObject::tr(), par exemple.

Voir aussi fromLatin1(), fromLocal8Bit(), et fromUtf8().

QString::QString(const char *str)

Construit une chaîne initialisée avec la chaîne 8 bits str. Le pointeur const char donné est converti en Unicode à l'aide de la fonction fromUtf8().

Vous pouvez désactiver ce constructeur en définissant QT_NO_CAST_FROM_ASCII lors de la compilation de vos applications. Cela peut être utile si vous voulez vous assurer que toutes les chaînes visibles par l'utilisateur passent par QObject::tr(), par exemple.

Voir aussi fromLatin1(), fromLocal8Bit() et fromUtf8().

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

Construit une chaîne initialisée avec la chaîne UTF-8 str. Le pointeur const char8_t donné est converti en Unicode à l'aide de la fonction fromUtf8().

Cette fonction a été introduite dans Qt 6.1.

Voir aussi fromLatin1(), fromLocal8Bit(), et fromUtf8().

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

Construit une chaîne initialisée avec les premiers caractères size du tableau QChar unicode .

Si unicode vaut 0, une chaîne nulle est construite.

Si size est négatif, unicode est supposé pointer vers un tableau '\0'-terminé et sa longueur est déterminée dynamiquement. Le caractère nul de fin de chaîne n'est pas considéré comme faisant partie de la chaîne.

QString effectue une copie profonde des données de la chaîne. Les données unicode sont copiées telles quelles et la marque d'ordre des octets est préservée si elle est présente.

Voir aussi fromRawData().

QString::QString(qsizetype size, QChar ch)

Construit une chaîne de caractères de la valeur donnée size avec chaque caractère défini à ch.

Voir aussi fill().

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

Construit une copie de other.

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

Voir également operator=().

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

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

[noexcept] QString::~QString()

Détruit la chaîne.

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

Ajoute la chaîne str à la fin de cette chaîne.

Exemple :

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

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

Cela revient à utiliser la fonction insert() :

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

La fonction append() est généralement très rapide(temps constant), car QString préalloue de l'espace supplémentaire à la fin des données de la chaîne afin qu'elle puisse croître sans avoir à réallouer la totalité de la chaîne à chaque fois.

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

QString &QString::append(QChar ch)

Ajoute le caractère ch à cette chaîne.

QString &QString::append(QLatin1StringView str)

Ajoute à cette chaîne la chaîne Latin-1 visualisée par str.

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

Ajoute la vue de la chaîne donnée v à cette chaîne et renvoie le résultat.

Cette fonction a été introduite dans Qt 6.0.

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

Ajoute la vue de la chaîne UTF-8 str à cette chaîne.

Cette fonction a été introduite dans Qt 6.5.

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

Ajoute le tableau d'octets ba à cette chaîne. Le tableau d'octets donné est converti en Unicode à l'aide de la fonction fromUtf8().

Vous pouvez désactiver cette fonction en définissant QT_NO_CAST_FROM_ASCII lors de la compilation de vos applications. Cela peut être utile si vous voulez vous assurer que toutes les chaînes visibles par l'utilisateur passent par QObject::tr(), par exemple.

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

Ajoute la chaîne str à cette chaîne. Le pointeur const char donné est converti en Unicode à l'aide de la fonction fromUtf8().

Vous pouvez désactiver cette fonction en définissant QT_NO_CAST_FROM_ASCII lors de la compilation de vos applications. Cela peut être utile si vous voulez vous assurer que toutes les chaînes visibles par l'utilisateur passent par QObject::tr(), par exemple.

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

Ajoute à cette chaîne les caractères len du tableau QChar str .

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

Remplace les occurrences de %N dans cette chaîne par l'argument correspondant de args. Les arguments ne sont pas positionnels : le premier des args remplace le %N par le N le plus bas (tous), le deuxième des args le %N par le N le plus bas suivant, etc.

Args peut consister en tout ce qui se convertit implicitement en QAnyStringView.

Voir aussi QString::arg().

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

Renvoie une copie de cette chaîne dont le marqueur de place le plus bas est remplacé par la chaîne a, c'est-à-dire %1, %2, ..., %99.

fieldWidth spécifie l'espace minimum que a doit occuper. Si a nécessite moins d'espace que fieldWidth, il est ajouté à fieldWidth avec le caractère fillChar. Une valeur positive de fieldWidth produit un texte aligné à droite. Un fieldWidth négatif produit un texte aligné à gauche.

Cet exemple montre comment nous pourrions créer une chaîne status pour signaler la progression du traitement d'une liste de fichiers :

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

Tout d'abord, arg(i) remplace %1. Ensuite, arg(total) remplace %2. Enfin, arg(fileName) remplace %3.

L'un des avantages de l'utilisation de arg() par rapport à asprintf() est que l'ordre des marqueurs de place numérotés peut changer si les chaînes de l'application sont traduites dans d'autres langues, mais chaque arg() remplacera toujours le marqueur de place non remplacé le plus bas, quel que soit l'endroit où il apparaît. De même, si le marqueur de place %i apparaît plus d'une fois dans la chaîne, arg() les remplace tous.

S'il ne reste aucun marqueur de place non remplacé, un message d'avertissement est imprimé et le résultat est indéfini. Les numéros des marqueurs de place doivent être compris entre 1 et 99.

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

L'argument a est exprimé dans la base base, qui est 10 par défaut et doit être comprise entre 2 et 36. Pour les bases autres que 10, a est traité comme un entier non signé.

fieldWidth spécifie la quantité minimale d'espace dont a est rempli par le caractère fillChar. Une valeur positive produit un texte aligné à droite ; une valeur négative produit un texte aligné à gauche.

Le "%" peut être suivi d'un "L", auquel cas la séquence est remplacée par une représentation localisée de a. La conversion utilise la locale par défaut, définie par QLocale::setDefault(). Si aucune locale par défaut n'a été spécifiée, la locale du système est utilisée. L'indicateur 'L' est ignoré si base n'est pas 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"

Voir aussi Number formats.

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

L'argument a est formaté conformément aux spécifications format et precision. Voir Floating-point Formats pour plus de détails.

fieldWidth spécifie la quantité minimale d'espace dont a est rempli par le caractère fillChar. Une valeur positive produit un texte aligné à droite ; une valeur négative produit un texte aligné à gauche.

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

Voir aussi QLocale::toString(), QLocale::FloatingPointPrecisionOption, et Number formats.

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

Construit en toute sécurité une chaîne formatée à partir de la chaîne de format cformat et d'une liste arbitraire d'arguments.

La chaîne de format supporte les spécificateurs de conversion, les modificateurs de longueur et les drapeaux fournis par printf() dans la bibliothèque standard C++. La chaîne cformat et les arguments %s doivent être codés en UTF-8.

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

Pour translations, en particulier si la chaîne contient plus d'une séquence d'échappement, vous devriez envisager d'utiliser la fonction arg() à la place. Cela permet au traducteur de contrôler l'ordre des remplacements.

Voir aussi arg().

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

Remplace le contenu de cette chaîne par une copie de v et renvoie une référence à cette chaîne.

La taille de cette chaîne sera égale à la taille de v, convertie en UTF-16 comme par v.toString(). Contrairement à QAnyStringView::toString(), cette fonction n'alloue de la mémoire que si la taille estimée dépasse la capacité de cette chaîne ou si cette chaîne est partagée.

Cette fonction a été introduite dans Qt 6.6.

Voir aussi QAnyStringView::toString().

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

Remplace le contenu de cette chaîne par une copie des éléments de l'itérateur [first, last) et renvoie une référence à cette chaîne.

La taille de cette chaîne sera égale à la longueur décodée des éléments de l'intervalle [first, last), qui ne doit pas nécessairement être la même que la longueur de l'intervalle lui-même, car cette fonction recode de manière transparente le jeu de caractères d'entrée en UTF-16.

Cette fonction n'allouera de la mémoire que si le nombre d'éléments de l'intervalle ou, pour une entrée non codée en UTF-16, la taille maximale possible de la chaîne résultante, dépasse la capacité de cette chaîne, ou si cette chaîne est partagée.

Contraintes

Participe à la résolution de surcharge uniquement si InputIterator répond aux exigences d'un LegacyInputIterator et si value_type de InputIterator est l'un des types de caractères suivants :

• QChar
• QLatin1Char
• char
• unsigned char
• signed char
• char8_t
• char16_t
• (sur les plates-formes, telles que Windows, où il s'agit d'un type 16 bits) wchar_t
• char32_t

Cette fonction a été introduite dans Qt 6.6.

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

Remplace le contenu de cette chaîne par n copies de c et renvoie une référence à cette chaîne.

La taille de cette chaîne sera égale à n, qui doit être non négative.

Cette fonction n'allouera de la mémoire que si n dépasse la capacité de cette chaîne ou si cette chaîne est partagée.

Cette fonction a été introduite dans Qt 6.6.

Voir aussi fill().

const QChar QString::at(qsizetype position) const

Renvoie le caractère à l'index donné position dans la chaîne.

L'adresse position doit être une position d'index valide dans la chaîne (c'est-à-dire 0 <= position < size()).

Voir aussi operator[]().

QChar &QString::back()

Renvoie une référence au dernier caractère de la chaîne. Identique à operator[](size() - 1).

Cette fonction est fournie pour la compatibilité STL.

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

QChar QString::back() const

Renvoie le dernier caractère de la chaîne. Identique à at(size() - 1).

Cette fonction est fournie pour la compatibilité STL.

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

QString::iterator QString::begin()

Renvoie un itérateur de style STL pointant sur le premier caractère de la chaîne.

Voir aussi constBegin() et end().

QString::const_iterator QString::begin() const

qsizetype QString::capacity() const

Renvoie le nombre maximum de caractères qui peuvent être stockés dans la chaîne sans forcer une réallocation.

Le seul but de cette fonction est de fournir un moyen d'affiner l'utilisation de la mémoire par QString. En général, vous n'aurez que rarement besoin d'appeler cette fonction. Si vous voulez savoir combien de caractères contient la chaîne, appelez size().

Voir également reserve() et squeeze().

QString::const_iterator QString::cbegin() const

Renvoie un itérateur de style STL constant pointant sur le premier caractère de la chaîne.

Voir aussi begin() et cend().

QString::const_iterator QString::cend() const

Renvoie un itérateur de style STL constant pointant juste après le dernier caractère de la chaîne.

Voir aussi cbegin() et end().

void QString::chop(qsizetype n)

Supprime les caractères n de la fin de la chaîne.

Si n est supérieur ou égal à size(), le résultat est une chaîne vide ; si n est négatif, cela équivaut à passer zéro.

Exemple :

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

Si vous souhaitez supprimer des caractères au début de la chaîne, utilisez plutôt remove().

Voir aussi truncate(), resize(), remove() et QStringView::chop().

Renvoie une chaîne contenant les caractères size() - len les plus à gauche de cette chaîne.

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

void QString::clear()

Efface le contenu de la chaîne et la rend nulle.

Voir aussi resize() et isNull().

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

Compare la chaîne s1 avec la chaîne s2 et renvoie un nombre entier négatif si s1 est inférieur à s2, un nombre entier positif s'il est supérieur à s2, et zéro s'ils sont égaux.

Si cs est Qt::CaseSensitive (par défaut), la comparaison est sensible à la casse ; sinon, la comparaison est insensible à la casse.

La comparaison sensible à la casse est basée exclusivement sur les valeurs numériques Unicode des caractères et est très rapide, mais ne correspond pas aux attentes d'un être humain. Envisagez de trier les chaînes visibles par l'utilisateur avec 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

Voir aussi operator==(), operator<(), operator>() et Comparing Strings.

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

Effectue une comparaison avec ch, en utilisant le paramètre de sensibilité à la casse cs.

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

Identique à compare(*this, other, cs).

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

Effectue une comparaison avec s, en utilisant le paramètre de sensibilité à la casse cs.

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

Compare lexicalement cette chaîne avec la chaîne other et renvoie un entier négatif si cette chaîne est inférieure à other, un entier positif si elle est supérieure à other, et zéro si elles sont égales.

Identique à compare(*this, other, cs).

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

Effectue une comparaison entre s1 et s2, en utilisant le paramètre de sensibilité à la casse cs.

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

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

Effectue une comparaison entre s1 et s2, en utilisant le paramètre de sensibilité à la casse cs.

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

QString::const_iterator QString::constBegin() const

Renvoie un itérateur de style STL constant pointant sur le premier caractère de la chaîne.

Voir aussi begin() et constEnd().

const QChar *QString::constData() const

Renvoie un pointeur sur les données stockées dans la chaîne QString. Le pointeur peut être utilisé pour accéder aux caractères qui composent la chaîne.

Notez que le pointeur reste valide tant que la chaîne n'est pas modifiée.

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

QString::const_iterator QString::constEnd() const

Renvoie un itérateur de style STL constant pointant juste après le dernier caractère de la chaîne.

Voir aussi constBegin() et end().

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

Renvoie true si l'expression régulière re correspond à un élément de cette chaîne ; sinon, il renvoie false.

Si la correspondance est réussie et que rmatch n'est pas nullptr, il écrit également les résultats de la correspondance dans l'objet QRegularExpressionMatch pointé par rmatch.

Voir aussi QRegularExpression::match().

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

Renvoie true si cette chaîne contient une occurrence de la chaîne str; sinon, renvoie false.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Exemple :

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

Voir aussi indexOf() et count().

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

Renvoie true si cette chaîne contient une occurrence du caractère ch; sinon, renvoie false.

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

Renvoie true si cette chaîne contient une occurrence de la chaîne latine-1 str; sinon, renvoie false.

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

Renvoie true si cette chaîne contient une occurrence de la vue de la chaîne str; sinon, renvoie false.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Voir aussi indexOf() et count().

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

Renvoie le nombre d'occurrences (pouvant se chevaucher) de la chaîne str dans cette chaîne.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Voir également contains() et indexOf().

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

Renvoie le nombre de fois où l'expression régulière re correspond à la chaîne de caractères.

Pour des raisons historiques, cette fonction compte les correspondances qui se chevauchent. Ainsi, dans l'exemple ci-dessous, il y a quatre occurrences de "ana" ou "ama" :

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

Ce comportement est différent de la simple itération sur les correspondances dans la chaîne à l'aide de QRegularExpressionMatchIterator.

Voir également QRegularExpression::globalMatch().

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

Renvoie le nombre d'occurrences du caractère ch dans la chaîne.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Voir également contains() et indexOf().

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

Renvoie le nombre d'occurrences (pouvant se chevaucher) de la chaîne view str dans cette chaîne.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi contains() et indexOf().

QString::const_reverse_iterator QString::crbegin() const

Renvoie un itérateur inverse de style STL constant pointant sur le premier caractère de la chaîne, dans l'ordre inverse.

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

QString::const_reverse_iterator QString::crend() const

Renvoie un itérateur inverse de style STL constant pointant juste après le dernier caractère de la chaîne, dans l'ordre inverse.

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

QChar *QString::data()

Renvoie un pointeur sur les données stockées dans QString. Le pointeur peut être utilisé pour accéder et modifier les caractères qui composent la chaîne.

Contrairement à constData() et unicode(), les données renvoyées sont toujours terminées par '\0'.

Exemple :

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

Notez que le pointeur ne reste valide que tant que la chaîne n'est pas modifiée par d'autres moyens. Pour un accès en lecture seule, constData() est plus rapide car il ne provoque jamais de copie profonde.

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

const QChar *QString::data() const

Voir également fromRawData().

QString::iterator QString::end()

Renvoie un itérateur de style STL pointant juste après le dernier caractère de la chaîne.

Voir aussi begin() et constEnd().

QString::const_iterator QString::end() const

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

Renvoie true si la chaîne se termine par s; sinon, renvoie false.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

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

Voir aussi startsWith().

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

Renvoie true si la chaîne se termine par c; sinon, renvoie false.

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

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

Renvoie true si la chaîne se termine par la vue de la chaîne str; sinon, renvoie false.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Voir aussi startsWith().

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

Supprime de la chaîne les caractères de l'intervalle semi-ouvert [ first, last ). Renvoie un itérateur vers le caractère situé immédiatement après le dernier caractère effacé (c'est-à-dire le caractère auquel se réfère last avant l'effacement).

Cette fonction a été introduite dans Qt 6.1.

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

Supprime de la chaîne de caractères le caractère indiqué par it. Renvoie un itérateur vers le caractère situé immédiatement après le caractère effacé.

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

Cette fonction a été introduite dans Qt 6.5.

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

Fixe chaque caractère de la chaîne au caractère ch. Si size est différent de -1 (par défaut), la chaîne est préalablement redimensionnée à size.

Exemple :

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

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

Voir aussi resize().

Renvoie une chaîne contenant les n premiers caractères de cette chaîne (c'est-à-dire du début de la chaîne jusqu'à l'élément situé à la position d'index n).

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

Ces fonctions ont été introduites dans Qt 6.0.

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

[static] QString QString::fromCFString(CFStringRef string)

Construit un nouveau QString contenant une copie du CFString string.

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

Convertit la chaîne ECMAScript jsString en QString. Le comportement est indéfini si le paramètre fourni n'est pas une chaîne.

Cette fonction a été introduite dans Qt 6.6.

Voir aussi toEcmaString().

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

Renvoie un QString initialisé avec les premiers caractères size de la chaîne Latin-1 str.

Si size est -1, strlen(str) est utilisé à la place.

Voir aussi toLatin1(), fromUtf8(), et fromLocal8Bit().

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

Renvoie un QString initialisé avec la chaîne de caractères Latin-1 str.

Cette fonction a été introduite dans Qt 6.0.

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

Renvoie un QString initialisé avec la chaîne de caractères Latin-1 str.

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

Renvoie un QString initialisé avec les premiers caractères size de la chaîne de 8 bits str.

Si size est -1, strlen(str) est utilisé à la place.

Sur les systèmes Unix, cette fonction est équivalente à fromUtf8(). Notez que sur les systèmes Apple, cette fonction ne prend pas en compte NSString.defaultCStringEncoding ou CFStringGetSystemEncoding(), car ces fonctions renvoient généralement l'ancien codage "Western (Mac OS Roman)", qui ne doit pas être utilisé sur les systèmes d'exploitation Apple modernes. Sous Windows, c'est la page de code actuelle du système qui est utilisée.

Voir aussi toLocal8Bit(), fromLatin1(), et fromUtf8().

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

Renvoie un QString initialisé avec la chaîne de caractères de 8 bits str.

Sur les systèmes Unix, cette fonction est équivalente à fromUtf8(). Notez que sur les systèmes Apple, cette fonction ne prend pas en compte NSString.defaultCStringEncoding ou CFStringGetSystemEncoding(), car ces fonctions renvoient généralement l'ancien encodage "Western (Mac OS Roman)", qui ne doit pas être utilisé sur les systèmes d'exploitation Apple modernes. Sous Windows, c'est la page de code actuelle du système qui est utilisée.

Cette fonction a été introduite dans Qt 6.0.

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

Renvoie un QString initialisé avec la chaîne de caractères de 8 bits str.

Sur les systèmes Unix, cette fonction est équivalente à fromUtf8(). Notez que sur les systèmes Apple, cette fonction ne prend pas en compte NSString.defaultCStringEncoding ou CFStringGetSystemEncoding(), car ces fonctions renvoient généralement l'ancien encodage "Western (Mac OS Roman)", qui ne doit pas être utilisé sur les systèmes d'exploitation Apple modernes. Sous Windows, c'est la page de code actuelle du système qui est utilisée.

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

Construit un nouveau QString contenant une copie de la NSString string.

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

Construit un QString qui utilise les premiers caractères Unicode de size dans le tableau unicode. Les données contenues dans unicode ne sont pas copiées. L'appelant doit pouvoir garantir que unicode ne sera ni supprimé ni modifié tant que QString (ou une copie non modifiée de celui-ci) existe.

Toute tentative de modification de QString ou de ses copies entraînera la création d'une copie profonde des données, garantissant ainsi que les données brutes ne sont pas modifiées.

Voici un exemple de la façon dont nous pouvons utiliser un QRegularExpression sur des données brutes en mémoire sans avoir à copier les données dans 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)) {
    // ...
}

Cette fonction a été introduite dans Qt 6.10.

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

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

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

Renvoie une copie de la chaîne str. La chaîne donnée est supposée être codée en UTF-8 et est convertie en QString à l'aide de la fonction fromUtf8().

Voir aussi fromLatin1(), fromLocal8Bit(), fromUtf8(), et QByteArray::fromStdString().

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

Renvoie une copie de la chaîne str. La chaîne donnée est supposée être encodée en UTF-16, et est convertie en QString à l'aide de la fonction fromUtf16().

Voir aussi fromUtf16(), fromStdWString(), et fromStdU32String().

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

Renvoie une copie de la chaîne str. La chaîne donnée est supposée être encodée en UTF-32, et est convertie en QString à l'aide de la fonction fromUcs4().

Voir aussi fromUcs4(), fromStdWString(), et fromStdU16String().

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

Renvoie une copie de la chaîne str. La chaîne donnée est supposée être encodée en utf16 si la taille de wchar_t est de 2 octets (par exemple sous Windows) et en ucs4 si la taille de wchar_t est de 4 octets (sur la plupart des systèmes Unix).

Voir aussi fromUtf16(), fromLatin1(), fromLocal8Bit(), fromUtf8(), fromUcs4(), fromStdU16String(), et fromStdU32String().

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

Renvoie un QString initialisé avec les premiers size caractères de la chaîne Unicode unicode (encodée en UTF-32).

Si size vaut -1 (valeur par défaut), unicode doit être '\0'-terminé.

Voir aussi toUcs4(), fromUtf16(), utf16(), setUtf16(), fromWCharArray() et fromStdU32String().

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

Renvoie un QString initialisé avec les premiers octets size de la chaîne UTF-8 str.

Si size est -1, strlen(str) est utilisé à la place.

UTF-8 est un codec Unicode et peut représenter tous les caractères d'une chaîne Unicode comme QString. Cependant, des séquences non valides sont possibles avec UTF-8 et, si l'une d'entre elles est trouvée, elle sera remplacée par un ou plusieurs "caractères de remplacement", ou supprimée. Il s'agit notamment de séquences non Unicode, de non-caractères, de séquences trop longues ou de points de code de substitution encodés en UTF-8.

Cette fonction peut être utilisée pour traiter les données entrantes de manière incrémentale tant que tous les caractères UTF-8 sont terminés dans les données entrantes. Tout caractère non terminé à la fin de la chaîne sera remplacé ou supprimé. Pour effectuer un décodage avec état, veuillez utiliser QStringDecoder.

Voir aussi toUtf8(), fromLatin1(), et fromLocal8Bit().

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

Renvoie un QString initialisé avec la chaîne UTF-8 str.

Cette fonction a été introduite dans Qt 6.0.

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

Renvoie un QString initialisé avec la chaîne UTF-8 str.

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

Cette surcharge n'est disponible que lors de la compilation en mode C++20.

Cette fonction a été introduite dans Qt 6.1.

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

Cette surcharge n'est disponible que lors de la compilation en mode C++20.

Cette fonction a été introduite dans Qt 6.0.

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

Renvoie un QString initialisé avec les premiers size caractères de la chaîne Unicode unicode (encodée ISO-10646-UTF-16).

Si size vaut -1 (valeur par défaut), unicode doit être '\0'-terminé.

Cette fonction vérifie la présence d'une marque d'ordre d'octet (BOM). Si elle est absente, l'ordre des octets de l'hôte est pris en compte.

Cette fonction est lente par rapport aux autres conversions Unicode. Utilisez QString(const QChar *, qsizetype) ou QString(const QChar *) si possible.

QString effectue une copie profonde des données Unicode.

Voir aussi utf16(), setUtf16(), et fromStdU16String().

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

Lit les premières unités de code size du tableau wchar_t vers lequel pointe string, les convertit en Unicode et renvoie le résultat sous forme de QString. Le codage utilisé par wchar_t est supposé être UTF-32 si la taille du type est de quatre octets ou UTF-16 si sa taille est de deux octets.

Si size vaut -1 (valeur par défaut), string doit être '\0'-terminé.

Voir aussi fromUtf16(), fromLatin1(), fromLocal8Bit(), fromUtf8(), fromUcs4() et fromStdWString().

QChar &QString::front()

Renvoie une référence au premier caractère de la chaîne. Identique à operator[](0).

Cette fonction est fournie pour la compatibilité STL.

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

QChar QString::front() const

Renvoie le premier caractère de la chaîne. Identique à at(0).

Cette fonction est fournie pour la compatibilité STL.

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

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

Renvoie la position d'index de la première occurrence de la chaîne Latin-1 vue par str dans cette chaîne, en cherchant vers l'avant à partir de la position d'index from. Retourne -1 si str n'est pas trouvé.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Exemple :

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 vaut -1, la recherche commence au dernier caractère ; s'il vaut -2, à l'avant-dernier caractère, et ainsi de suite.

Voir également lastIndexOf(), contains() et count().

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

Renvoie la position d'index de la première correspondance de l'expression régulière re dans la chaîne, en cherchant vers l'avant à partir de la position d'index from. Renvoie -1 si re ne correspond à rien.

Si la correspondance est réussie et que rmatch n'est pas nullptr, elle écrit également les résultats de la correspondance dans l'objet QRegularExpressionMatch pointé par rmatch.

Exemple :

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

Renvoie la position d'index de la première occurrence de la chaîne str dans cette chaîne, en cherchant vers l'avant à partir de la position d'index from. Retourne -1 si str n'est pas trouvé.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Exemple :

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 vaut -1, la recherche commence au dernier caractère ; s'il vaut -2, à l'avant-dernier caractère, et ainsi de suite.

Voir également lastIndexOf(), contains() et count().

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

Renvoie la position d'index de la première occurrence du caractère ch dans cette chaîne, en effectuant une recherche vers l'avant à partir de la position d'index from. Retourne -1 si ch n'est pas trouvé.

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

Renvoie la position d'index de la première occurrence de la vue de la chaîne str dans cette chaîne, en cherchant vers l'avant à partir de la position d'index from. Retourne -1 si str n'est pas trouvé.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

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

Voir aussi QStringView::indexOf(), lastIndexOf(), contains() et count().

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

Insère la chaîne de caractères str à l'index donné position et renvoie une référence à cette chaîne.

Exemple :

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

Cette chaîne s'agrandit pour tenir compte de l'insertion. Si position se trouve au-delà de la fin de la chaîne, des caractères d'espacement sont ajoutés à la chaîne pour atteindre position, suivi de str.

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

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

Insère ch à l'index donné position dans la chaîne.

Cette chaîne s'allonge pour tenir compte de l'insertion. Si position se trouve au-delà de la fin de la chaîne, des caractères d'espacement sont ajoutés à la chaîne pour atteindre position, suivi de ch.

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

Insère la chaîne Latin-1 vue par str à l'index donné position.

Cette chaîne s'accroît pour tenir compte de l'insertion. Si position se trouve au-delà de la fin de la chaîne, des caractères d'espacement sont ajoutés à la chaîne pour atteindre position, suivi de str.

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

Insère la vue de la chaîne str à l'index donné position et renvoie une référence à cette chaîne.

Cette chaîne s'accroît pour tenir compte de l'insertion. Si position se trouve au-delà de la fin de la chaîne, des caractères d'espacement sont ajoutés à la chaîne pour atteindre position, suivi de str.

Cette fonction a été introduite dans Qt 6.0.

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

Insère la vue de la chaîne UTF-8 str à l'index donné position.

Cette chaîne s'agrandit pour s'adapter à l'insertion. Si position dépasse la fin de la chaîne, des caractères d'espacement sont ajoutés à la chaîne pour atteindre position, suivi de str.

Cette fonction a été introduite dans Qt 6.5.

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

Interprète le contenu de str en UTF-8, insère la chaîne Unicode qu'il encode à l'index donné position et renvoie une référence à cette chaîne.

Cette chaîne s'agrandit pour tenir compte de l'insertion. Si position se trouve au-delà de la fin de la chaîne, des caractères d'espacement sont ajoutés à la chaîne pour atteindre position, suivi de str.

Cette fonction n'est pas disponible lorsque QT_NO_CAST_FROM_ASCII est défini.

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

Insère la chaîne C str à l'index donné position et renvoie une référence à cette chaîne.

Cette chaîne s'accroît pour tenir compte de l'insertion. Si position se trouve au-delà de la fin de la chaîne, des caractères d'espacement sont ajoutés à la chaîne pour atteindre position, suivi de str.

Cette fonction n'est pas disponible lorsque QT_NO_CAST_FROM_ASCII est défini.

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

Insère les premiers caractères size du tableau QChar unicode à l'index donné position dans la chaîne.

Cette chaîne s'accroît pour tenir compte de l'insertion. Si position se trouve au-delà de la fin de la chaîne, des caractères d'espacement sont ajoutés à la chaîne pour atteindre ce position, suivi par size caractères du tableau QChar unicode .

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

Renvoie true si la chaîne ne contient pas de caractères ; sinon, renvoie false.

Exemple :

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

Voir aussi size().

bool QString::isLower() const

Renvoie true si la chaîne est en minuscules, c'est-à-dire qu'elle est identique à son pliage toLower().

Notez que cela ne signifie pas que la chaîne ne contient pas de lettres majuscules (certaines lettres majuscules n'ont pas de pliage minuscule ; elles sont laissées inchangées par toLower()). Pour plus d'informations, voir la norme Unicode, section 3.13.

Voir aussi QChar::toLower() et isUpper().

[constexpr] bool QString::isNull() const

Renvoie true si cette chaîne est nulle ; sinon, renvoie false.

Exemple :

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

Qt fait une distinction entre les chaînes nulles et les chaînes vides pour des raisons historiques. Pour la plupart des applications, l'important est de savoir si une chaîne contient ou non des données, ce qui peut être déterminé à l'aide de la fonction isEmpty().

Voir aussi isEmpty().

bool QString::isRightToLeft() const

Renvoie true si la chaîne est lue de droite à gauche.

Voir aussi QStringView::isRightToLeft().

bool QString::isUpper() const

Renvoie true si la chaîne est en majuscules, c'est-à-dire qu'elle est identique à son pliage toUpper().

Notez que cela ne signifie pas que la chaîne ne contient pas de lettres minuscules (certaines lettres minuscules n'ont pas de pliage majuscule ; elles sont laissées inchangées par toUpper()). Pour plus d'informations, voir la norme Unicode, section 3.13.

Voir également QChar::toUpper() et isLower().

[noexcept] bool QString::isValidUtf16() const

Renvoie true si la chaîne contient des données encodées UTF-16 valides, ou false dans le cas contraire.

Notez que cette fonction n'effectue aucune validation particulière des données ; elle vérifie simplement si elles peuvent être décodées avec succès à partir d'UTF-16. Les données sont supposées être dans l'ordre des octets de l'hôte ; la présence d'un BOM n'a pas de sens.

Voir aussi QStringView::isValidUtf16().

Renvoie la chaîne qui contient les derniers n caractères de cette chaîne.

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

Ces fonctions ont été introduites dans Qt 6.0.

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

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

Renvoie la position d'index de la dernière correspondance de l'expression régulière re dans la chaîne, qui commence avant la position d'index from.

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

Retourne -1 si re ne correspond à rien.

Si la correspondance est réussie et que rmatch n'est pas nullptr, il écrit également les résultats de la correspondance dans l'objet QRegularExpressionMatch pointé par rmatch.

Exemple :

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

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

Renvoie la position d'index de la dernière occurrence de la chaîne str dans cette chaîne, en effectuant une recherche à rebours à partir de la position d'index from.

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

Retourne -1 si str n'est pas trouvé.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Exemple :

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

Voir également indexOf(), contains() et count().

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

Cette fonction a été introduite dans Qt 6.3.

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

Renvoie la position d'index de la dernière occurrence de la chaîne str dans cette chaîne. Retourne -1 si str n'est pas trouvé.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Exemple :

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

Cette fonction a été introduite dans Qt 6.2.

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

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

Renvoie la position d'index de la dernière occurrence de la vue de la chaîne str dans cette chaîne. Retourne -1 si str n'est pas trouvé.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Cette fonction a été introduite dans Qt 6.2.

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

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

Renvoie la position d'index de la dernière correspondance de l'expression régulière re dans la chaîne. Retourne -1 si re ne correspond à rien.

Si la correspondance est réussie et que rmatch n'est pas nullptr, il écrit également les résultats de la correspondance dans l'objet QRegularExpressionMatch pointé par rmatch.

Exemple :

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

Cette fonction a été introduite dans Qt 6.2.

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

Renvoie la position d'index de la dernière occurrence de la chaîne str dans cette chaîne. Retourne -1 si str n'est pas trouvé.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Exemple :

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

Cette fonction a été introduite dans Qt 6.2.

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

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

Renvoie la position d'index de la dernière occurrence du caractère ch dans cette chaîne, en effectuant une recherche à rebours à partir de la position d'index from.

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

Renvoie la position d'index de la dernière occurrence de la chaîne de caractères latins-1 vue par str dans cette chaîne, en effectuant une recherche à rebours à partir de la position d'index from.

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

Retourne -1 si str n'est pas trouvé.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Exemple :

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

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

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

Renvoie la position d'index de la dernière occurrence de la vue de la chaîne str dans cette chaîne, en effectuant une recherche à rebours à partir de la position d'index from.

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

Retourne -1 si str n'est pas trouvé.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

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

Renvoie une sous-chaîne contenant les n caractères les plus à gauche de cette chaîne (c'est-à-dire du début de cette chaîne jusqu'à l'élément situé à la position d'index n, mais sans l'inclure).

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

La chaîne entière est renvoyée si n est supérieur ou égal à size(), ou inférieur à zéro.

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

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

Renvoie une chaîne de taille width qui contient cette chaîne complétée par le caractère fill.

Si truncate est false et que le caractère size() de la chaîne est supérieur à width, la chaîne renvoyée est une copie de la chaîne.

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

Si truncate est true et que size() de la chaîne est supérieur à width, tous les caractères d'une copie de la chaîne après la position width sont supprimés et la copie est renvoyée.

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

Voir également rightJustified().

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

Renvoie le nombre de caractères de cette chaîne. Équivalent à size().

Voir aussi resize().

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

Compare s1 avec s2 et renvoie un entier inférieur, égal ou supérieur à zéro si s1 est inférieur, égal ou supérieur à s2.

La comparaison est effectuée en fonction des paramètres locaux et de la plate-forme. Utilisez cette fonction pour présenter à l'utilisateur des listes triées de chaînes de caractères.

Voir aussi compare(), QLocale, et Comparing Strings.

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

Compare cette chaîne avec la chaîne other et renvoie un entier inférieur, égal ou supérieur à zéro si cette chaîne est inférieure, égale ou supérieure à la chaîne other.

La comparaison est effectuée en fonction des paramètres locaux et de la plate-forme. Utilisez cette fonction pour présenter à l'utilisateur des listes triées de chaînes de caractères.

Identique à localeAwareCompare(*this, other).

Cette fonction a été introduite dans Qt 6.0.

Voir aussi Comparing Strings.

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

Compare cette chaîne avec la chaîne other et renvoie un entier inférieur, égal ou supérieur à zéro si cette chaîne est inférieure, égale ou supérieure à la chaîne other.

La comparaison est effectuée en fonction des paramètres locaux et de la plate-forme. Utilisez cette fonction pour présenter à l'utilisateur des listes triées de chaînes de caractères.

Identique à localeAwareCompare(*this, other).

Voir également Comparing Strings.

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

Compare s1 avec s2 et renvoie un entier inférieur, égal ou supérieur à zéro si s1 est inférieur, égal ou supérieur à s2.

La comparaison est effectuée en fonction des paramètres locaux et de la plate-forme. Utilisez cette fonction pour présenter à l'utilisateur des listes triées de chaînes de caractères.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi Comparing Strings.

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

Ces fonctions ont été introduites dans Qt 6.8.

Renvoie une chaîne qui contient n caractères de cette chaîne, à partir de l'indice position spécifié jusqu'à l'élément situé à la position d'indice \a position + n, mais sans l'inclure.

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

Renvoie une chaîne nulle si l'indice position dépasse la longueur de la chaîne. S'il y a moins de n caractères disponibles dans la chaîne à partir de position, ou si n est -1 (par défaut), la fonction renvoie tous les caractères disponibles à partir de position.

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

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

Renvoie la chaîne de caractères dans la normalisation Unicode donnée mode, conformément à la norme Unicode donnée version.

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

Si les données de cette chaîne ne sont pas terminées par des caractères nuls, cette méthode fera une copie profonde des données et les rendra terminées par des caractères nuls.

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

Cette fonction a été introduite dans Qt 6.10.

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

Renvoie une copie de cette chaîne de caractères dont la terminaison est toujours nulle.

Ces fonctions ont été introduites dans Qt 6.10.

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

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

Renvoie une chaîne de caractères équivalente au nombre n selon la base spécifiée base.

La base est 10 par défaut et doit être comprise entre 2 et 36. Pour les bases autres que 10, n est traité comme un entier non signé.

Le formatage utilise toujours QLocale::C, c'est-à-dire l'anglais/les États-Unis. Pour obtenir une représentation sous forme de chaîne de caractères localisée d'un nombre, utilisez QLocale::toString() avec la locale appropriée.

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

Voir aussi setNum().

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

Renvoie une chaîne représentant le nombre à virgule flottante n.

Renvoie une chaîne représentant n, formatée selon les formats spécifiés format et precision.

Pour les formats avec un exposant, l'exposant indiquera son signe et aura au moins deux chiffres, en plaçant l'exposant à gauche avec zéro si nécessaire.

Voir aussi setNum(), QLocale::toString(), QLocale::FloatingPointPrecisionOption, et Number formats.

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

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

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

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

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

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

Prépare la chaîne str au début de cette chaîne et renvoie une référence à cette chaîne.

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

Exemple :

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

Voir également append() et insert().

QString &QString::prepend(QChar ch)

Ajoute le caractère ch à cette chaîne.

QString &QString::prepend(QLatin1StringView str)

Ajoute à cette chaîne la chaîne Latin-1 visualisée par str.

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

Prépare la vue de la chaîne str au début de cette chaîne et renvoie une référence à cette chaîne.

Cette fonction a été introduite dans Qt 6.0.

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

Ajoute la vue de la chaîne UTF-8 str à cette chaîne.

Cette fonction a été introduite dans Qt 6.5.

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

Ajoute le tableau d'octets ba à cette chaîne. Le tableau d'octets est converti en Unicode à l'aide de la fonction fromUtf8().

Vous pouvez désactiver cette fonction en définissant QT_NO_CAST_FROM_ASCII lors de la compilation de vos applications. Cela peut être utile si vous voulez vous assurer que toutes les chaînes visibles par l'utilisateur passent par QObject::tr(), par exemple.

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

Ajoute la chaîne str à cette chaîne. Le pointeur const char est converti en Unicode à l'aide de la fonction fromUtf8().

Vous pouvez désactiver cette fonction en définissant QT_NO_CAST_FROM_ASCII lors de la compilation de vos applications. Cela peut être utile si vous voulez vous assurer que toutes les chaînes visibles par l'utilisateur passent par QObject::tr(), par exemple.

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

Ajoute les caractères len du tableau QChar str à cette chaîne et renvoie une référence à cette chaîne.

void QString::push_back(const QString &other)

Cette fonction est fournie à des fins de compatibilité STL. Elle ajoute la chaîne other donnée à la fin de cette chaîne. Elle est équivalente à append(other).

Voir aussi append().

void QString::push_back(QChar ch)

Ajoute le caractère ch à la fin de cette chaîne.

void QString::push_front(const QString &other)

Cette fonction est fournie à des fins de compatibilité STL. Elle fait précéder la chaîne other donnée au début de cette chaîne. Elle est équivalente à prepend(other).

Voir aussi prepend().

void QString::push_front(QChar ch)

Ajoute le caractère ch au début de la chaîne.

QString::reverse_iterator QString::rbegin()

Renvoie un itérateur inversé de style STL pointant sur le premier caractère de la chaîne, dans l'ordre inverse.

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

QString::const_reverse_iterator QString::rbegin() const

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

Supprime toutes les occurrences de l'expression régulière re dans la chaîne et renvoie une référence à la chaîne. Par exemple :

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

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

Voir également indexOf(), lastIndexOf() et replace().

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

Supprime toutes les occurrences du caractère ch dans cette chaîne et renvoie une référence à cette chaîne.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Exemple :

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

C'est la même chose que replace(ch, "", cs).

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

Voir également replace().

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

Supprime toutes les occurrences de la chaîne str donnée dans cette chaîne et renvoie une référence à cette chaîne.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

C'est la même chose que replace(str, "", cs).

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

Voir également replace().

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

Supprime les caractères n de la chaîne, à partir de l'indice position donné, et renvoie une référence à la chaîne.

Si l'indice position spécifié se trouve dans la chaîne, mais que position + n se trouve au-delà de la fin de la chaîne, la chaîne est tronquée à l'indice position spécifié.

Si n est <= 0, rien n'est modifié.

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

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

Voir également insert() et replace().

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

Supprime de cette chaîne toutes les occurrences de la chaîne Latin-1 donnée, visualisée par str, et renvoie une référence à cette chaîne.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

C'est la même chose que replace(str, "", cs).

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

Voir aussi replace().

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

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

Cette fonction a été introduite dans Qt 6.5.

Voir aussi remove().

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

Supprime le premier caractère de cette chaîne. Si la chaîne est vide, cette fonction ne fait rien.

Cette fonction a été introduite dans Qt 6.5.

Voir aussi remove().

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

Supprime de la chaîne tous les éléments pour lesquels le prédicat pred renvoie la valeur true. Renvoie une référence à la chaîne.

Cette fonction a été introduite dans Qt 6.1.

Voir aussi remove().

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

Supprime le dernier caractère de cette chaîne. Si la chaîne est vide, cette fonction ne fait rien.

Cette fonction a été introduite dans Qt 6.5.

Voir aussi remove().

QString::reverse_iterator QString::rend()

Renvoie un itérateur inversé de style STL pointant juste après le dernier caractère de la chaîne, dans l'ordre inverse.

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

QString::const_reverse_iterator QString::rend() const

QString QString::repeated(qsizetype times) const

Renvoie une copie de cette chaîne répétée au nombre spécifié de times.

Si times est inférieur à 1, une chaîne vide est renvoyée.

Exemple :

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

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

Remplace les caractères n commençant à l'index position par la chaîne after et renvoie une référence à cette chaîne.

Exemple :

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

Voir aussi insert() et remove().

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

Remplace chaque occurrence de l'expression régulière re dans la chaîne par after. Renvoie une référence à la chaîne. Par exemple :

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

Pour les expressions régulières contenant des groupes de capture, les occurrences de \1, \2..., dans after sont remplacées par la chaîne capturée par le groupe de capture correspondant.

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

Voir aussi indexOf(), lastIndexOf(), remove(), QRegularExpression, et QRegularExpressionMatch.

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

Remplace chaque occurrence du caractère before par le caractère after et renvoie une référence à cette chaîne.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

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

Remplace chaque occurrence du caractère c par la chaîne after et renvoie une référence à cette chaîne.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

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

Remplace chaque occurrence du caractère ch dans la chaîne par after et renvoie une référence à cette chaîne.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

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

Remplace chaque occurrence dans cette chaîne de la chaîne Latin-1 vue par before par la chaîne Latin-1 vue par after, et renvoie une référence à cette chaîne.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

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

Remplace chaque occurrence dans cette chaîne de la chaîne Latin-1 vue par before par la chaîne after, et renvoie une référence à cette chaîne.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

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

Remplace chaque occurrence de la chaîne before par la chaîne after et renvoie une référence à cette chaîne.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

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

Remplace chaque occurrence de la chaîne before par la chaîne after et renvoie une référence à cette chaîne.

Si cs est Qt::CaseSensitive (par défaut), la recherche est sensible à la casse ; sinon, la recherche est insensible à la casse.

Exemple :

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

Exemple : Note : Le texte de remplacement n'est pas réanalysé après son insertion :

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

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

Remplace les caractères n commençant à l'index position par le caractère after et renvoie une référence à cette chaîne.

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

Remplace les caractères n commençant à l'index position par les premiers caractères alen du tableau QChar after et renvoie une référence à cette chaîne.

n ne doit pas être négatif.

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