QString Class

Documentation sur les fonctions des membres

[constexpr noexcept] QString::QString()

Crée une chaîne nulle. Les chaînes nulles sont également considérées comme vides.

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

QString::QString(QChar ch)

Crée une chaîne de taille 1 contenant le caractère « ch ».

QString::QString(QLatin1StringView str)

Crée une copie de la chaîne Latin-1 telle qu'elle est affichée par str.

Voir également fromLatin1().

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

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

La chaîne 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)

Crée une chaîne initialisée avec le tableau d'octets ba. Le tableau d'octets fourni 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 s’avérer utile si vous souhaitez vous assurer que toutes les chaînes visibles par l’utilisateur passent par ` QObject::tr()`, par exemple.

Voir également ` 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 fourni 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 s’avérer utile si vous souhaitez vous assurer que toutes les chaînes visibles par l’utilisateur passent par ` QObject::tr()`, par exemple.

Voir également fromLatin1(), fromLocal8Bit() et fromUtf8().

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

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

Cette fonction a été introduite dans Qt 6.1.

Voir également fromLatin1(), fromLocal8Bit() et fromUtf8().

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

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

Si unicode est égal à 0, une chaîne vide est construite.

Si size est négatif, unicode est supposé pointer vers un tableau terminé par «\0 » et sa longueur est déterminée dynamiquement. Le caractère nul de fin 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 le marqueur d'ordre des octets (Byte Order Mark) est conservé s'il est présent.

Voir également fromRawData().

QString::QString(qsizetype size, QChar ch)

Construit une chaîne à partir de l'size on fournie, chaque caractère étant défini comme suit : ch.

Voir aussi fill().

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

Crée une copie de other.

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

Voir également operator=().

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

Crée une instance de QString par « move », de sorte qu'elle pointe vers le même objet que celui vers lequel pointait other.

[noexcept] QString::~QString()

Supprime 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 s'allonger sans avoir à réallouer la chaîne entière à 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 traitée par la fonction str.

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

Ajoute la vue de chaîne fournie 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 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 fourni 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 s’avérer utile si vous souhaitez 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 fourni 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 s’avérer utile si vous souhaitez 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 les caractères len provenant du tableau QChar str à cette chaîne.

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

Remplace les occurrences de « %N » dans cette chaîne par l’argument correspondant issu de « args ». Les arguments ne sont pas positionnels : le premier de « args » remplace « %N » par la valeur la plus basse de « N » (toutes), le deuxième de « args » remplace « %N » par la valeur suivante la plus basse de « N », etc.

Args peut être constitué de n’importe quel élément se convertissant implicitement en QAnyStringView.

Voir également QString::arg().

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

Renvoie une copie de cette chaîne dans laquelle le marqueur de position ayant le numéro 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 complété jusqu’à fieldWidth avec le caractère fillChar. Une valeur positive de fieldWidth produit un texte aligné à droite. Une valeur négative de fieldWidth produit un texte aligné à gauche.

Cet exemple montre comment créer une chaîne status pour indiquer la progression lors 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 position 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 position non remplacé ayant le numéro le plus bas, quel que soit l’endroit où il apparaît. De plus, si le marqueur de position %i apparaît plusieurs fois dans la chaîne, arg() les remplace tous.

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

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

L'argument ` a ` est exprimé en base ` base`, qui est de 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 l’espace minimum jusqu’auquel a est complété et rempli avec le caractère fillChar. Une valeur positive produit un texte aligné à droite ; une valeur négative produit un texte aligné à gauche.

Le caractère « % » peut être suivi d’un « L » ; dans ce cas, la séquence est remplacée par une représentation localisée de ` a`. La conversion utilise les paramètres régionaux par défaut, définis par ` QLocale::setDefault()`. Si aucun paramètre régional par défaut n’a été spécifié, ce sont ceux du système qui sont utilisés. L’indicateur « L » est ignoré si ` base ` n’est pas égal à 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> requires if_floating_point<T> 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. Pour plus de détails, consultez Floating-point Formats.

fieldWidth Spécifie l’espace minimum jusqu’auquel ` a ` est complété et rempli avec 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 également QLocale::toString(), QLocale::FloatingPointPrecisionOption et Number formats.

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

Crée 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 prend en charge les spécificateurs de conversion, les modificateurs de longueur et les indicateurs fournis par la fonction printf() de la bibliothèque C++ standard. La chaîne cformat et les arguments %s doivent être encodés en UTF-8.

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

Pour translations, en particulier si les chaînes contiennent plusieurs séquences d'échappement, il est préférable d'utiliser la fonction arg() à la place. Cela permet au traducteur de contrôler l'ordre des remplacements.

Voir également 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 à celle de ` v`, convertie en UTF-16 comme si elle avait été traitée par ` v.toString()`. Contrairement à ` QAnyStringView::toString()`, cette fonction n’alloue toutefois de la mémoire que si la taille estimée dépasse la capacité de cette chaîne ou si celle-ci est partagée.

Cette fonction a été introduite dans Qt 6.6.

Voir également QAnyStringView::toString().

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

Remplace le contenu de cette chaîne par une copie des éléments de la plage 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 sera pas nécessairement 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 la plage, ou, pour une entrée non encodé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

Ne participe à la résolution des surcharges que si ` InputIterator ` satisfait aux exigences d’un ` LegacyInputIterator ` et si le ` 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 plateformes, 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 un nombre non négatif.

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

Cette fonction a été introduite dans Qt 6.6.

Voir également fill().

const QChar QString::at(qsizetype position) const

Renvoie le caractère situé à l'position d'index indiquée dans la chaîne.

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

Voir également operator[]().

QChar &QString::back()

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

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

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

QChar QString::back() const

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

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

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

QString::iterator QString::begin()

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

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

QString::const_iterator QString::begin() const

qsizetype QString::capacity() const

Renvoie le nombre maximal de caractères pouvant être stockés dans la chaîne sans nécessiter de réallocation.

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

Voir également ` reserve()` et ` squeeze()`.

QString::const_iterator QString::cbegin() const

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

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

QString::const_iterator QString::cend() const

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

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

void QString::chop(qsizetype n)

Supprime les caractères n à 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 revient à 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 la fonction remove().

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

Renvoie une chaîne contenant les caractères situés le plus à gauche de cette chaîne, selon la formule suivante : size() - len.

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

void QString::clear()

Efface le contenu de la chaîne et la met à null.

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 entier négatif si « s1 » est inférieur à « s2 », un entier positif s'il est supérieur à « s2 », et zéro si les deux chaînes sont égales.

Si cs est défini sur Qt::CaseSensitive (valeur par défaut), la comparaison tient compte de la casse ; dans le cas contraire, elle ne tient pas compte de la casse.

La comparaison sensible à la casse repose exclusivement sur les valeurs Unicode numériques des caractères et est très rapide, mais elle ne correspond pas à ce à quoi s’attendrait un utilisateur. Pensez au tri de 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 également operator==(), operator<(), operator>() et Comparing Strings.

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

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

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

Équivalent à `compare(*this, other, cs)`.

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

Effectue une comparaison entre cette valeur et 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.

Equivalent à 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 constant de type STL pointant vers le premier caractère de la chaîne.

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

const QChar *QString::constData() const

Renvoie un pointeur vers les données stockées dans ` QString`. Ce pointeur permet d'accéder aux caractères qui composent la chaîne.

Notez que le pointeur ne reste valide que 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 const de type STL pointant juste après le dernier caractère de la chaîne.

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

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

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

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

Voir également QRegularExpression::match().

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

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

Si cs est égal à Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de 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 au moins 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 « latin-1 » str; sinon, renvoie « false ».

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

Renvoie « true » si cette chaîne contient au moins une occurrence de la chaîne « view str » ; sinon, renvoie « false ».

Si cs est Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de la casse.

Voir également 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 défini sur Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de la casse.

Voir également contains() et indexOf().

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

Renvoie le nombre d'occurrences de l'expression régulière re dans la chaîne.

Pour des raisons historiques, cette fonction compte les correspondances qui se chevauchent ; ainsi, dans l'exemple ci-dessous, on dénombre quatre occurrences de « ana » ou « ama » :

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

Ce comportement diffère d'une simple itération sur les correspondances de 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 défini sur Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de 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 (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de la casse.

Cette fonction a été introduite dans Qt 6.0.

Voir également contains() et indexOf().

QString::const_reverse_iterator QString::crbegin() const

Renvoie un itérateur inversé de type STL (const) pointant vers le premier caractère de la chaîne, dans l'ordre inverse.

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

QString::const_reverse_iterator QString::crend() const

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

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

QChar *QString::data()

Renvoie un pointeur vers les données stockées dans ` QString`. Ce pointeur permet d'accéder aux caractères qui composent la chaîne et de les modifier.

Contrairement aux fonctions ` 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, la fonction ` constData()` est plus rapide car elle ne provoque jamais de copie profonde.

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

const QChar *QString::data() const

Voir également fromRawData().

void QString::detach()

Garantit que les données de cette chaîne ne sont plus partagées avec d'autres instances.

QString::iterator QString::end()

Renvoie un itérateur de type 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 vaut Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de la casse.

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

Voir également 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 chaîne « view str » ; sinon, renvoie « false ».

Si cs vaut Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de la casse.

Voir également startsWith().

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

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

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 le caractère indiqué par ` it `. Renvoie un itérateur pointant vers le caractère situé immédiatement après celui qui a été supprimé.

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)

Remplace chaque caractère de la chaîne par le caractère ch. Si size est différent de -1 (valeur 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 x premiers caractères de cette chaîne ( n ), c’est-à-dire depuis le début de cette chaîne jusqu’à l’élément situé à l’index n, non compris.

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)

Crée un nouvel objet ` QString ` contenant une copie de la chaîne `CFString` de type ` 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 également toEcmaString().

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

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

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

Voir également toLatin1(), fromUtf8() et fromLocal8Bit().

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

Renvoie un objet ` QString ` initialisé avec la chaîne Latin-1 « str ».

Cette fonction a été introduite dans Qt 6.0.

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

Renvoie un objet ` QString ` initialisé avec la chaîne Latin-1 « str ».

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

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

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

Sur les systèmes Unix, cela équivaut à fromUtf8(). Notez que sur les systèmes Apple, cette fonction ne tient pas compte de NSString.defaultCStringEncoding ni de CFStringGetSystemEncoding(), car ces fonctions renvoient généralement l’encodage hérité « 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 codes actuelle du système qui est utilisée.

Voir également ` toLocal8Bit()`, ` fromLatin1()` et ` fromUtf8()`.

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

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

Sur les systèmes Unix, cela équivaut à fromUtf8(). Notez que sur les systèmes Apple, cette fonction ne tient pas compte de NSString.defaultCStringEncoding ni de CFStringGetSystemEncoding(), car ces fonctions renvoient généralement l’encodage hérité « Western (Mac OS Roman) », qui ne doit pas être utilisé sur les systèmes d’exploitation Apple modernes. Sous Windows, la page de codes actuelle du système est utilisée.

Cette fonction a été introduite dans Qt 6.0.

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

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

Sur les systèmes Unix, cela équivaut à ` fromUtf8()`. Notez que sur les systèmes Apple, cette fonction ne tient pas compte de `NSString.defaultCStringEncoding ` ni de `CFStringGetSystemEncoding()`, car ces fonctions renvoient généralement l’encodage hérité « Western (Mac OS Roman) », qui ne doit pas être utilisé sur les systèmes d’exploitation Apple modernes. Sous Windows, la page de codes actuelle du système est utilisée.

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

Crée un nouvel objet ` QString ` contenant une copie de la chaîne ` string ` de type `NSString`.

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

Crée un objet ` QString ` utilisant les ` size ` premiers caractères Unicode du 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 soient pas modifiées.

Voici un exemple illustrant comment utiliser une chaîne « QRegularExpression » sur des données brutes en mémoire sans avoir à copier ces données dans une chaîne « 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 également 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 fournie est supposée être encodée en UTF-8 et est convertie en « QString » à l’aide de la fonction fromUtf8().

Voir également 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 fournie est supposée être encodée en UTF-16 et est convertie en « QString » à l'aide de la fonction fromUtf16().

Voir également fromUtf16(), fromStdWString() et fromStdU32String().

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

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

Voir également fromUcs4(), fromStdWString() et fromStdU16String().

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

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

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

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

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

Si size vaut -1 (valeur par défaut), unicode doit se terminer par «\0 ».

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

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

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

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

UTF-8 est un codec Unicode et peut représenter tous les caractères d’une chaîne Unicode telle que QString. Cependant, des séquences non valides sont possibles avec UTF-8 et, si de telles séquences sont détectées, elles seront remplacées par un ou plusieurs « caractères de remplacement », ou supprimées. Il s’agit notamment des séquences non Unicode, des éléments non alphabétiques, des séquences trop longues ou des 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émentielle, à condition que tous les caractères UTF-8 soient correctement terminés au sein des 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 également toUtf8(), fromLatin1() et fromLocal8Bit().

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

Renvoie un objet ` 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 objet ` 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 objet ` QString ` initialisé avec les ` size ` premiers caractères de la chaîne Unicode ` unicode ` (codée en ISO-10646-UTF-16).

Si size est égal à -1 (valeur par défaut), unicode doit se terminer par «\0 ».

Cette fonction vérifie la présence d’un indicateur d’ordre des octets (BOM). S’il est absent, l’ordre des octets de l’hôte est supposé.

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 également utf16(), setUtf16() et fromStdU16String().

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

Lit les ` size ` unités de code du tableau ` wchar_t ` dont le début est pointé par ` string `, les convertit en Unicode et renvoie le résultat sous la forme d’un ` QString`. L’encodage 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), l’ string doit être terminée par «\0 ».

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

QChar &QString::front()

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

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

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

QChar QString::front() const

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

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

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

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

Renvoie l'index de la première occurrence de la chaîne « Latin-1 » identifiée par « str » dans cette chaîne, en effectuant la recherche vers l'avant à partir de l'index « from ». Renvoie -1 si « str » n'est pas trouvé.

Si cs est Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de 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 ; si elle vaut -2, elle commence à 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 l'index de la première occurrence de l'expression régulière re dans la chaîne, en effectuant une recherche vers l'avant à partir de l'index from. Renvoie -1 si re n'a été trouvé nulle part.

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 l'index de la première occurrence de la chaîne « str » dans cette chaîne, en effectuant la recherche vers l'avant à partir de l'index « from ». Renvoie -1 si « str » n'est pas trouvé.

Si cs est égal à Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de 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 est égal à -1, la recherche commence au dernier caractère ; s’il est égal à -2, elle commence à l’avant-dernier caractère, et ainsi de suite.

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

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

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

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

Renvoie l’index de la première occurrence de la chaîne « view str » dans cette chaîne, en effectuant la recherche vers l’avant à partir de l’index « from ». Renvoie -1 si « str » n’est pas trouvé.

Si cs est égal à Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de la casse.

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

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

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

Insère la chaîne « str » à l'index spécifié 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'allonge pour accueillir 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 cet position, suivi de str.

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

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

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

La chaîne s'allonge pour accueillir l'insertion. Si position se trouve au-delà de la fin de la chaîne, des espaces sont ajoutés à la chaîne pour atteindre cet position, suivi de ch.

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

Insère la chaîne Latin-1 affichée par str à l'index indiqué position.

Cette chaîne s'allonge pour accueillir 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 cet position, suivi de str.

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

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

La chaîne s'allonge pour accueillir 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 cet position, suivis de str.

Cette fonction a été introduite dans Qt 6.0.

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

Insère la chaîne UTF-8 « str » à l'index spécifié « position ».

Cette chaîne s'allonge pour s'adapter à 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 cette position, suivis 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 ` au format UTF-8, insère la chaîne Unicode qu’il encode à l’index spécifié ` position ` et renvoie une référence à cette chaîne.

Cette chaîne s'allonge pour accueillir 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 cet position, suivis 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 spécifié « position » et renvoie une référence à cette chaîne.

Cette chaîne s'allonge pour accueillir 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 cet position, suivis 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 x size premiers caractères du tableau QChar unicode à l'index position spécifié dans la chaîne.

La chaîne s'allonge pour accueillir l'insertion. Si position se trouve au-delà de la fin de la chaîne, des espaces sont ajoutés à la chaîne pour atteindre cette position position, suivis des size caractères du tableau QChar unicode .

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

Renvoie « true » si la chaîne ne contient aucun caractère ; 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 si elle est identique à son résultat après application de la fonction « toLower() ».

Notez que cela ne signifie pas que la chaîne ne contient pas de lettres majuscules (certaines lettres majuscules n'ont pas de forme minuscule correspondante ; elles restent inchangées par la fonction toLower()). Pour plus d’informations, reportez-vous à la norme Unicode, section 3.13.

Voir également 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 la distinction entre les chaînes nulles et les chaînes vides pour des raisons historiques. Pour la plupart des applications, ce qui importe, c'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 se lit de droite à gauche.

Voir aussi QStringView::isRightToLeft().

bool QString::isUpper() const

Renvoie « true » si la chaîne est en majuscules, c'est-à-dire si elle est identique à son résultat après application de la fonction « toUpper() ».

Notez que cela ne signifie pas que la chaîne ne contient pas de lettres minuscules (certaines lettres minuscules n’ont pas de forme majuscule correspondante ; elles restent inchangées par la fonction toUpper()). Pour plus d’informations, reportez-vous à 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 en 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 celles-ci peuvent être décodées correctement à partir du format 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 aucune signification.

Voir également QStringView::isValidUtf16().

Renvoie la chaîne contenant les x derniers caractères de cette chaîne, en respectant la n.

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

Ces fonctions ont été introduites dans Qt 6.0.

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

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

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

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

Renvoie -1 si re n’a donné aucun résultat.

Si la recherche aboutit et que rmatch n’est pas nullptr, elle écrit également les résultats de la recherche 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 l'indice de la dernière occurrence de la chaîne « str » dans cette chaîne, en effectuant la recherche à rebours à partir de l'indice « from ».

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

Renvoie -1 si « str » n'est pas trouvé.

Si « cs » est « Qt::CaseSensitive » (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de 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 l'index de la dernière occurrence de la chaîne « str » dans cette chaîne. Renvoie -1 si « str » n'est pas trouvé.

Si cs est Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de 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 également indexOf(), contains() et count().

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

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

Si cs est Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de la casse.

Cette fonction a été introduite dans Qt 6.2.

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

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

Renvoie l'indice de la dernière occurrence de l'expression régulière re dans la chaîne. Renvoie -1 si re n'a été trouvé nulle part.

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.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 l'indice de la dernière occurrence de la chaîne « str » dans cette chaîne. Renvoie -1 si « str » n'est pas trouvé.

Si cs est Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de 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 également indexOf(), contains() et count().

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

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

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

Renvoie l’index de la dernière occurrence de la chaîne Latin-1 identifiée par la fonction ` str ` dans cette chaîne, en effectuant une recherche vers l’arrière à partir de l’index ` from`.

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

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

Si ` cs ` est ` Qt::CaseSensitive ` (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de 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] qsizetype QString::lastIndexOf(QStringView str, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Renvoie l'indice de la dernière occurrence de la chaîne « view str » dans cette chaîne, en effectuant une recherche vers l'arrière à partir de l'indice « from ».

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

Renvoie -1 si str n’est pas trouvé.

Si « cs » est « Qt::CaseSensitive » (valeur par défaut), la recherche tient compte de la casse ; dans le cas contraire, elle ne tient pas compte de la casse.

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

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

Si vous savez que n ne peut pas être hors limites, utilisez plutôt first() dans votre nouveau code, car cette fonction 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 également 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 contenant cette chaîne complétée par le caractère fill.

Si truncate est false et que la fonction size() de la chaîne de caractères est supérieure à width, alors 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 la valeur de size() de la chaîne est supérieure à width, tous les caractères de la copie de la chaîne situés après la position width sont supprimés, puis 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 contenus dans cette chaîne. Équivalent à ` size()`.

Voir aussi resize().

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

Compare s1 à 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 régionaux et de la plate-forme. Utilisez cette fonction pour présenter à l’utilisateur des listes de chaînes triées.

Voir également compare(), QLocale et Comparing Strings.

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

Compare cette chaîne à 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 régionaux et de la plate-forme. Utilisez cette fonction pour présenter à l’utilisateur des listes de chaînes triées.

Identique à ` localeAwareCompare(*this, other)`.

Cette fonction a été introduite dans Qt 6.0.

Voir également Comparing Strings.

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

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

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

Identique à ` localeAwareCompare(*this, other)`.

Voir également Comparing Strings.

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

Compare s1 à 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 régionaux et de la plate-forme. Utilisez cette fonction pour présenter à l'utilisateur des listes de chaînes triées.

Cette fonction a été introduite dans Qt 6.0.

Voir également Comparing Strings.

Elle renvoie le nombre maximal d'éléments que la chaîne peut théoriquement contenir. En pratique, ce nombre peut être bien inférieur, car il est limité par la quantité de mémoire disponible sur le système.

Ces fonctions ont été introduites dans Qt 6.8.

Renvoie une chaîne contenant les caractères d'n s de cette chaîne, à partir de l'index spécifié position jusqu'à l'élément situé à l'index position + n.

Si vous savez que position et n ne peuvent pas être hors limites, utilisez plutôt sliced() dans votre nouveau code, car cette fonction est plus rapide.

Renvoie une chaîne vide si l'index 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 l'index position donné, ou si n est égal à -1 (valeur par défaut), la fonction renvoie tous les caractères disponibles à partir de l'index position spécifié.

Voir également 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 selon la normalisation Unicode spécifiée mode, conformément à la section version de la norme Unicode.

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

Si cette chaîne de caractères n'est pas terminée par un caractère nul, cette méthode effectuera une copie profonde des données et les terminera par un caractère nul.

Une chaîne de caractères ( QString ) est terminée par un caractère « \0 » par défaut ; cependant, dans certains cas (par exemple lors de l'utilisation de ` fromRawData()`), la chaîne de caractères ne se termine pas nécessairement par un caractère « », ce qui peut poser problème lors de l'appel de méthodes qui attendent une chaîne terminée par un caractère « ».

Cette fonction a été introduite dans Qt 6.10.

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

Renvoie une copie de cette chaîne qui se termine toujours par un caractère nul.

Ces fonctions ont été introduites dans Qt 6.10.

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

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

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

La base est de 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 « English/UnitedStates ». Pour obtenir une représentation sous forme de chaîne localisée d’un nombre, utilisez QLocale::toString() avec les paramètres de localisation appropriés.

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

Voir également setNum().

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

Renvoie une chaîne de caractères représentant le nombre à virgule flottante n.

Renvoie une chaîne de caractères représentant n, formatée selon les paramètres spécifiés format et precision.

Pour les formats comportant un exposant, celui-ci affiche son signe et comporte au moins deux chiffres, en étant complété par des zéros à gauche si nécessaire.

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

Ajoute la chaîne « str » au début de cette chaîne et renvoie une référence à celle-ci.

Cette opération est généralement très rapide (temps constant), car QString préalloue de l'espace supplémentaire au début des données de la chaîne, ce qui lui permet de s'allonger sans avoir à réallouer la chaîne entière à 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 » au début de cette chaîne.

QString &QString::prepend(QLatin1StringView str)

Ajoute au début de cette chaîne la chaîne au format Latin-1 traitée par la fonction ` str `.

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

Ajoute la vue de 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 au début de cette chaîne la vue de la chaîne UTF-8 str.

Cette fonction a été introduite dans Qt 6.5.

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

Ajoute le tableau d’octets ba au début de 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 s’avérer utile si vous souhaitez 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 » au début de 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 s'avérer utile si vous souhaitez 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 au début de cette chaîne les caractères len issus du tableau QChar str , puis renvoie une référence à cette chaîne.

void QString::push_back(const QString &other)

Cette fonction est fournie à des fins de compatibilité avec la STL ; elle ajoute la chaîne other à la fin de cette chaîne. Elle équivaut à append(other).

Voir également append().

void QString::push_back(QChar ch)

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

void QString::push_front(const QString &other)

Cette fonction est fournie à des fins de compatibilité avec la STL ; elle ajoute la chaîne « other » au début de cette chaîne. Elle équivaut à ` prepend(other)`.

Voir aussi prepend().

void QString::push_front(QChar ch)

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

QString::reverse_iterator QString::rbegin()

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

Voir également ` 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 à celle-ci. Par exemple :

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

La suppression d'éléments préserve la capacité de la chaîne et ne réduit pas la quantité de mémoire allouée. Pour réduire la capacité excédentaire 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 défini sur Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de la casse.

Exemple :

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

Cela revient au même que ` replace(ch, "", cs)`.

La suppression d’éléments préserve la capacité de la chaîne et ne réduit pas la quantité de mémoire allouée. Pour libérer la capacité excédentaire 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 » dans cette chaîne, puis renvoie une référence à cette chaîne.

Si cs est défini sur Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de la casse.

Cette fonction est identique à ` replace(str, "", cs)`.

La suppression d’éléments préserve la capacité de la chaîne et ne réduit pas la quantité de mémoire allouée. Pour libérer la capacité excédentaire 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'index position indiqué, et renvoie une référence à la chaîne.

Si l'index position spécifié se trouve dans la chaîne, mais que position + n dépasse la fin de la chaîne, celle-ci est tronquée à l'index position spécifié.

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

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

La suppression d’éléments préserve la capacité de la chaîne et ne réduit pas la quantité de mémoire allouée. Pour se débarrasser de la capacité excédentaire et libérer autant de mémoire que possible, appelez squeeze() après la dernière modification de la taille 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 spécifiée, telle qu’interprétée par str, et renvoie une référence à cette chaîne.

Si ` cs ` est défini sur ` Qt::CaseSensitive ` (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de la casse.

Cette fonction est identique à replace(str, "", cs).

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

Cette fonction a été introduite dans Qt 6.5.

Voir également remove().

[since 6.5] 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 également 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 « vrai ». 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 type STL pointant juste après le dernier caractère de la chaîne, dans l'ordre inverse.

Voir également 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 le nombre spécifié de fois 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 de la chaîne n à partir de 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 également 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 également 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 égal à Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de la casse.

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

Remplace toutes les occurrences du caractère « c » par la chaîne « after » et renvoie une référence à cette chaîne.

Si cs est égal à Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de 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 égal à Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de 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 affichée par before par la chaîne Latin-1 affichée par after, puis renvoie une référence à cette chaîne.

Si cs est égal à Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de 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 affichée par before par la chaîne after, puis renvoie une référence à cette chaîne.

Si cs est Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de la casse.

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

Remplace toutes les occurrences de la chaîne « before » par la chaîne « after » et renvoie une référence à cette chaîne.

Si cs est égal à Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; sinon, elle ne tient pas compte de la casse.

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

Remplace toutes les occurrences de la chaîne « before » par la chaîne « after » et renvoie une référence à cette chaîne.

Si cs est égal à Qt::CaseSensitive (valeur par défaut), la recherche tient compte de la casse ; dans le cas contraire, elle ne tient pas compte de la casse.

Exemple :

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