Developpez.com - Qt
X

Choisissez d'abord la catégorieensuite la rubrique :

Viadeo Twitter Google Bookmarks ! Facebook Digg del.icio.us MySpace Yahoo MyWeb Blinklist Netvouz Reddit Simpy StumbleUpon Bookmarks Windows Live Favorites 
Logo Documentation Qt ·  Page d'accueil  ·  Toutes les classes  ·  Toutes les fonctions  ·  Vues d'ensemble  · 

QString

La classe QString fournit une chaîne de caractères Unicode. Plus d'informations...

#include <QString>

Voir la position dans l'arbre des classes.

Héritage

Hérité par QConstString, QDBusObjectPath et QDBusSignature.

Note : toutes les fonctions de cette classe sont réentrantes, excepté pour ascii(), latin1(), utf8() et local8Bit() qui sont non réentrantes.

Description détaillée

La classe QString fournit une chaîne de caractères Unicode.

QString stocke une chaîne de QChar de 16 bits, où chaque QChar correspond à un caractère Unicode 4.0. Un caractère Unicode avec un code de valeur au-dessus de 65535 est stocké en utilisant des paires de substitution, c'est-à-dire deux QChar consécutifs.

Unicode est un standard international qui prend en charge la plupart des systèmes d'écriture utilisés aujourd'hui. Il s'agit d'un sur-ensemble de US-ASCII (ANSI X3.4-1986) et Latin-1 (ISO 8859-1). Tous les caractères US-ASCII/Latin-1 sont disponibles à la même position.

En pratique, QString utilise un partage implicite (copie à l'écriture - pattern COW) pour réduire la consommation de mémoire et éviter les copies inutiles de données. Ceci aide aussi à réduire la surcharge inhérente au stockage des caractères 16 bits au lieu de caractères 8 bits.

En plus de QString, Qt fournit aussi la classe QByteArray pour stocker des octets bruts et les chaînes 8 bits traditionnelles terminées par \0. Dans la plupart des cas, QString est la classe à utiliser. Elle est utilisée dans toute l'API Qt, et le support Unicode permet une traduction facile de vos applications. Les deux principaux cas où QByteArray est approprié sont lorsque vous avez besoin de stocker des données binaires brutes et lorsque la consommation de mémoire est cruciale (comme Qt pour Linux embarqué).

Initialiser une chaîne de caractères

Une façon d'initialiser une QString est tout simplement de passer un const char * à son constructeur. Par exemple, le code suivant crée une QString de taille 5 contenant « Hello » :

QString str = "Hello";

QString convertit la donnée const char * en Unicode en utilisant la fonction fromAscii(). Par défaut, fromAscii() traite un caractère au-dessus de 128 comme un caractère Latin-1 mais cela peut être modifié en appelant QTextCodec::setCodecForCStrings().

Dans toutes les fonctions de QString qui prennent des paramètres const char *, le const char * est interprété comme une chaîne de caractères classique comme en langage C, terminée par \0. Il est possible de passer un paramètre const char * à 0.

Vous pouvez aussi fournir une chaîne sous forme d'un tableau de QChar :

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

QString fait une copie complète des données QChar, afin qu'elle puisse être ensuite modifiée sans effet de bord. Si, pour des raisons de performance, vous ne voulez pas faire une copie complète des données des caractères, utilisez plutôt QString::fromRawData().

Une autre approche est de définir la taille de la chaîne de caractères en utilisant resize() et d'initialiser les données caractère par caractère. QString utilise des index commençant à 0, comme les tableaux C++. Pour accéder à un caractère à une position particulière, vous pouvez utiliser operator[](). Sur les chaînes non constantes, operator[]() retourne une référence au caractère qui peut être utilisée sur la partie gauche d'une affectation. Par exemple :

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

Pour un accès en lecture seule, la fonction at() propose une syntaxe alternative :

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

La fonction at() peut être plus rapide que operator[](), parce qu'elle ne déclenche jamais de copie en profondeur. Vous pouvez aussi utiliser les fonctions left(), right() ou mid() pour extraire plusieurs caractères à la fois.

Une QString peut inclure des caractères \0 (QChar::Null). La fonction size() retourne toujours la taille de la chaîne de caractères complète, incluant les caractères \0.

Après un appel à la fonction resize(), les nouveaux caractères alloués ont des valeurs indéfinies. Pour fixer tous les caractères d'une chaîne à une valeur particulière, utilisez la fonction fill().

QString fournit des dizaines de surcharges conçues pour simplifier l'usage des chaînes de caractères. Par exemple, si vous voulez comparer une QString avec une chaîne de caractères littérale, vous pouvez écrire ce type de code et il produira le résultat attendu :

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

Vous pouvez également passer des chaînes de caractères littérales à des fonctions qui prennent des QString en argument, appelant ainsi le constructeur QString(const char *). De même, vous pouvez passer une QString à une fonction qui prend un argument const char * en utilisant la macro qPrintable(), qui retourne la QString donnée en const char *. Cela est équivalent à l'appel de <QString>.toLocal8Bit().constData().

Manipuler les données d'une chaîne de caractères

QString fournit les fonctions de base suivantes pour modifier les données : append(), prepend(), insert(), replace() et remove(). Par exemple :

QString str = "and";
str.prepend("rock ");     // str == "rock and"
str.append(" roll");      // str == "rock and roll"
str.replace(5, 3, "&");   // str == "rock & roll"

Si vous construisez une QString graduellement et que vous connaissez à l'avance approximativement le nombre de caractères que la QString contiendra, vous pouvez appeler reserve(), qui demande à QString de préallouer un espace mémoire suffisant. Vous pouvez également appeler capacity() pour récupérer l'espace mémoire alloué par une QString.

Les deux premiers arguments des fonctions replace() et remove() sont la position du début de l'effacement et le nombre de caractères qui doivent être effacés. Si vous voulez remplacer toutes les occurrences d'une sous-chaîne de caractères particulière par une autre, utilisez l'une des surcharges de replace() à deux paramètres.

Un besoin fréquent est de retirer les espaces blancs d'une chaîne de caractères (\n, \t, ' ', etc.). Si vous voulez retirer les espaces blancs des deux extrémités d'une QString, utilisez la fonction trimmed(). Si vous voulez retirer les espaces blancs des deux extrémités et remplacer plusieurs espaces blancs consécutifs par un espace simple à l'intérieur de la chaîne de caractères, utilisez simplified().

Si vous voulez trouver toutes les occurrences d'un caractère particulier ou d'une sous-chaîne dans une QString, utilisez les fonctions indexOf() ou lastIndexOf(). La première cherche en avant en commençant par l'index de position donné ; la dernière cherche en arrière. Les deux renvoient l'index de position du caractère ou de la sous-chaîne si elles le trouvent ; sinon elles renvoient -1. Par exemple, vous retrouvez ci-dessous une boucle typique qui trouve toutes les occurrences d'une sous-chaîne particulière :

QString str = "Nous devons être <b>gras</b>, très <b>gras</b>";
int j = 0;
 
while ((j = str.indexOf("<b>", j)) != -1) {
    qDebug() << "Le tag <b> a été trouvé à la position" << j;
    ++j;
}

QString fournit de nombreuses fonctions pour convertir des nombres en chaînes de caractères et inversement. Voir les fonctions arg(), setNum(), les fonctions statiques number() et les fonctions toInt(), toDouble() et similaires.

Pour obtenir une version en majuscules ou minuscules d'une chaîne, utilisez toUpper() ou toLower().

Les listes de chaînes sont gérées par la classe QStringList. Vous pouvez séparer une chaîne de caractères en une liste de chaînes en utilisant la fonction split() et joindre une liste de chaîne en une seule chaîne avec un séparateur optionnel en utilisant QStringList::join(). Vous pouvez obtenir une liste de chaînes à partir d'une autre qui contient une sous-chaîne particulière ou qui correspond à une QRegExp particulière en utilisant la fonction QStringList::find().

Requêtes sur les données d'une chaîne de caractères

Si vous voulez savoir si une QString commence ou se termine par une sous-chaîne particulière, utilisez startsWith() ou endsWith(). Si vous voulez simplement vérifier qu'une QString contient un caractère particulier ou une sous-chaîne, utilisez la fonction contains(). Si vous voulez trouver combien de fois un caractère particulier ou une sous-chaîne apparaît dans une chaîne, utilisez count().

Les QString peuvent être comparées en utilisant des surcharges d'opérateurs comme operator<(), operator<=(), operator==(), operator>=(), etc. Notez que la comparaison se base exclusivement sur les valeurs Unicode numériques des caractères. Cela est très rapide mais pas vraiment ce qu'un humain attendrait ; la fonction QString::localeAwareCompare() est un meilleur choix pour trier des chaînes de caractères provenant d'une interface utilisateur.

Pour obtenir un pointeur sur les caractères, appelez data() ou constData(). Ces fonctions retournent un pointeur sur le début des données QChar. La validité du pointeur est garantie jusqu'à ce qu'une fonction non const soit appelée sur la QString.

Conversion entre chaînes de caractères 8-Bit et Unicode

QString fournit les quatre fonctions suivantes qui retournent une version const char * de la chaîne sous forme d'un QByteArray : toAscii(), toLatin1(), toUtf8() et toLocal8Bit().

  • toAscii() retourne une chaîne de caractères encodée sur 8 bits utilisant le codec spécifié par QTextCodec::codecForCStrings (par défaut, il s'agit de Latin 1).
  • toLatin1() retourne une chaîne de caractères Latin-1 (ISO 8859-1) encodée sur 8 bits.
  • toUtf8() retourne une chaîne de caractères UTF-8 encodé sur 8 bits. UTF-8 est un sur-ensemble de US-ASCII (ANSI X3.4-1986) qui supporte la totalité des caractères Unicode grâce à plusieurs séquences multibytes.
  • toLocal8Bit() retourne une chaîne de caractères sur 8 bits utilisant l'encodage local.

Pour convertir à partir d'un de ces encodages, QString fournit les fonctions fromAscii(), fromLatin1(), fromUtf8() et fromLocal8Bit(). D'autres encodages sont supportés à travers la classe QTextCodec.

Comme mentionné ci-dessus, QString fournit de nombreuses fonctions et opérateurs qui rendent aisée l'interaction avec des chaînes de caractères const char *. Mais cette fonctionnalité est à double tranchant : cela rend QString plus facile à utiliser si toutes les chaînes de caractères sont US-ASCII ou Latin-1, mais il y a toujours le risque qu'une conversion implicite à partir de ou vers const char * soit effectuée en utilisant un mauvais encodage, sur 8 bits. Pour minimiser ces risques, vous pouvez désactiver ces conversions implicites en définissant les symboles préprocesseur suivants :

  • QT_NO_CAST_FROM_ASCII désactive les conversions automatiques à partir des chaînes de caractères littérales du langage C et les pointeurs Unicode ;
  • QT_NO_CAST_TO_ASCII désactive les conversions automatiques à partir de QString vers les chaînes de caractères du langage C.

Une manière de définir ces symboles préprocesseur globalement pour votre application est d'ajouter les entrées suivantes à votre fichier de projet qmake :

DEFINES += QT_NO_CAST_FROM_ASCII \
            QT_NO_CAST_TO_ASCII

Vous devez ensuite appeler explicitement fromAscii(), fromLatin1(), fromUtf8() ou fromLocal8Bit() pour construire une QString à partir d'une chaîne de caractères sur 8 bits ou utiliser la classe QLatin1String, par exemple :

 QString url = QLatin1String("http://www.unicode.org/");

De la même manière, vous devez appeler toAscii(), toLatin1(), toUtf8() ou toLocal8Bit() explicitement pour convertir la QString en une chaîne de caractères 8 bits. D'autres encodages sont supportés à travers la classe QTextCodec.

Note pour les programmeurs C

En raison du système de type du C++ et le fait que QString est implicitement partagée, les QString peuvent être traitées comme des int ou d'autres types de base. Par exemple :

QString Widget::boolToString(bool b)
{
    QString result;
    if (b)
        result = "True";
    else
        result = "False";
    return result;
}

La variable result est une variable normale allouée sur la pile. Quand return est appelé, parce que nous faisons un retour par valeur, le constructeur par copie est appelé et une copie de la chaîne de caractères est retournée. Grâce au partage implicite, le contenu de la chaîne n'est pas copié.

Distinction entre null et chaîne de caractères vide

Pour des raisons historiques, QString fait la distinction entre une chaîne de caractères null et vide. Une chaîne de caractères null est une chaîne qui est initialisée en utilisant le constructeur par défaut de QString ou en passant (const char *)0 au constructeur. Une chaîne de caractères vide (empty) est n'importe quelle chaîne avec une taille de 0. Une chaîne de caractères null est toujours vide mais une chaîne vide n'est pas nécessairement null :

     QString().isNull();               // retourne vrai
     QString().isEmpty();              // retourne vrai
 
     QString("").isNull();             // retourne faux
     QString("").isEmpty();            // retourne vrai
 
     QString("abc").isNull();          // retourne faux
     QString("abc").isEmpty();         // retourne faux

Toutes les fonctions sauf isNull() traitent les chaînes de caractères null de la même façon que les vides. Par exemple, toAscii(). constData() retourne un pointeur sur un caractère \0 pour une chaîne de caractères null (pas un pointeur null) et QString() est identique à QString( » »). Nous vous recommandons d'utiliser toujours la fonction isEmpty() et d'éviter isNull().

L'argument format

Dans les fonctions membres où un argument format peut être spécifié (par exemple, arg(), number()), il peut prendre l'une des valeurs suivantes :

Format Signification
e sous la forme [-]9.9e[+|-]999
E sous la forme [-]9.9E[+|-]999
f sous la forme [-]9.9
g le plus concis entre e et f
G le plus concis entre E et f

Une précision est également spécifiée avec l'argument format. Pour les formats e, E et f, la précision représente le nombre de chiffres après la virgule (ou point décimal). Pour les formats g et G, la précision représente le nombre maximum de chiffres significatifs (en omettant les zéros terminaux).

Construction de chaîne de caractères plus efficacement

En utilisant l'opérateur +, il est facile de construire une chaîne de caractères complexe à partir de plusieurs sous-chaînes. Vous allez souvent écrire du code comme ceci :

QString foo;
QString type = "long";
 
foo->setText(QLatin1String("vector<") + type + QLatin1String(">::iterator"));
 
if (foo.startsWith("(" + type + ") 0x"))
    ...

Ces constructions de chaînes sont correctes mais contiennent cependant plusieurs inefficacités cachées. Depuis Qt 4.6, vous pouvez les éliminer.

Tout d'abord, les utilisations multiples de l'opérateur + signifient généralement plusieurs allocations mémoire. Quand vous concaténez n sous-chaînes de caractères, avec n > 2, il peut y avoir jusque n - 1 appel à l'allocateur de mémoire.

Ensuite, QLatin1String ne stocke pas sa longueur en interne mais fait appel à qstrlen() quand elle a besoin de connaître sa longueur.

Dans 4.6, une classe template interne QStringBuilder a été ajoutée avec plusieurs fonctions utilitaires. Cette classe est marquée interne et n'apparaît pas dans la documentation, parce que vous n'êtes pas censé l'instancier dans votre code. Son utilisation sera automatique comme décrit ci-dessous. La classe peut être trouvée dans src/corelib/tools/qstringbuilder.cpp si vous voulez y jeter un coup d'?il.

QStringBuilder utilise des templates d'expression et réimplémente l'opérateur %, ce qui permet, lorsque vous utilisez % pour la concaténation à la place de +, de différer les concaténations multiples jusqu'à ce que le résultat final soit sur le point d'être affecté à une QString. À ce moment, l'espace mémoire requis pour le résultat final est connu. L'allocateur de mémoire est ensuite appelé une seule fois pour obtenir l'espace requis et les sous-chaînes y sont copiées une par une.

QLatin1Literal est une deuxième classe interne qui peut remplacer QLatin1String, qui ne peut pas changer pour des raisons de compatibilité. QLatin1Literal stocke sa longueur, ce qui économise du temps quand QStringBuilder calcule l'espace mémoire nécessaire pour la chaîne finale.

Un gain supplémentaire d'efficacité provient des inlining et de la réduction du comptage des références (la QString créée à partir d'un QStringBuilder possède typiquement un compteur de références à 1, alors que QString::append() nécessite un test supplémentaire).

Il y a trois manières d'accéder à cette méthode améliorée de construction de chaînes. La méthode la plus rapide est d'inclure QStringBuilder où vous voulez l'utiliser et d'ensuite utiliser l'opérateur % au lieu de + lors de la concaténation :

#include <QStringBuilder>
 
QString hello("hello");
QStringRef el(&hello, 2, 3);
QLatin1String world("world");
QString message =  hello % el % world % QChar('!');

Une approche plus globale est d'inclure cette définition :

#define QT_USE_FAST_CONCATENATION

En plus d'utiliser % au lieu de +.

La troisième approche, la plus commode mais pas entièrement compatible, est d'utiliser deux définitions :

#define QT_USE_FAST_CONCATENATION
#define QT_USE_FAST_OPERATOR_PLUS

Le + sera automatiquement remplacé en %.

Voir aussi fromRawData(), QChar, QLatin1String, QByteArray et QStringRef.

Type

typedef QString::ConstIterator

Synonyme de style Qt pour QString::const_iterator.

typedef QString::Iterator

Synonyme de style Qt pour QString::iterator.

enum QString::NormalizationForm

Cette énumération décrit les diverses formes normalisées de texte Unicode.

Constante Valeur Description
QString::NormalizationForm_D   Décomposition canonique
QString::NormalizationForm_C 1 Décomposition canonique suivie d'une composition canonique
QString::NormalizationForm_KD 2 Décomposition de compatibilité
QString::NormalizationForm_KC 3 Décomposition de compatibilité suivie d'une composition canonique

Voir aussi normalized() et l'annexe 15 du standard Unicode.

enum QString::SectionFlagflags QString::SectionFlags

Cette énumération spécifie les drapeaux pouvant être utilisés pour modifier divers aspects du comportement de la fonction section() vis-à-vis des séparateurs et des champs vides.

Constante Valeur Description
QString::SectionDefault 0x00 Les champs vides sont pris en compte, les séparateurs de début et de fin ne sont pas inclus et la comparaison du séparateur est sensible à la casse.
QString::SectionSkipEmpty 0x01 Les champs vides sont ignorés, c'est-à-dire qu'ils ne sont pas pris en compte par start et end.
QString::SectionIncludeLeadingSep 0x02 Inclure le séparateur de début (si présent) dans la chaîne résultat.
QString::SectionIncludeTrailingSep 0x04 Inclure le séparateur de fin (si présent) dans la chaîne résultat.
QString::SectionCaseInsensitiveSeps 0x08 La comparaison du séparateur est insensible à la casse.

Le type SectionFlags est un typedef de QFlags<SectionFlag>. Il stocke une combinaison OU de valeurs SectionFlag.

Voir aussi section().

enum QString::SplitBehavior

Cette énumération spécifie le comportement de la fonction split() vis-à-vis des chaînes vides.

Constante Valeur Description
QString::KeepEmptyParts   Si un champ est vide, l'inclure dans le résultat.
QString::SkipEmptyParts 1 Si un champ est vide, ne pas l'inclure dans le résultat.

Voir aussi split().

typedef QString::const_iterator

Le typedef QString::const_iterator fournit un itérateur constant dans le style STL pour QString.

Voir aussi QString::iterator.

typedef QString::iterator

Le typedef QString::iterator fournit un itérateur non constant dans le style STL pour QString.

Voir aussi QString::const_iterator.

Fonctions membres

QString::QString ()

Construit une chaîne nulle. Les chaînes nulles sont aussi vides. Voir aussi isEmpty().

QString::QString ( const QChar * unicode, int size )

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

QString fait une copie en profondeur de la chaîne. Les données Unicode sont copiées telles quelles et la marque d'ordre des octets est conservée si elle est présente.

QString::QString ( const QChar * unicode )

Construit une chaîne initialisée avec les caractères du tableau de QChar unicode, qui doit être fini avec un 0.

QString fait une copie en profondeur de la chaîne. Les données Unicode sont copiées telles quelles et la marque d'ordre des octets est conservée si elle est présente.

Cette fonction a été introduite dans Qt 4.7.

QString::QString ( QChar ch )

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

QString::QString ( int size, QChar ch )

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

Voir aussi fill().

QString::QString ( const QLatin1String & str )

Construit une copie de la chaîne Latin-1 str.

Voir aussi fromLatin1().

QString::QString ( const QString & other )

Construit une copie de other.

Cette opération est effectuée en temps constant, car QString est implicitement partagée. Ceci rend le retour d'une QString dans une fonction très rapide. Si une instance partagée est modifiée, elle sera copiée (copy-on-write) et cela prend un temps linéaire.

Voir aussi operator=().

QString::QString ( const char * str )

Construit une chaîne initialisée avec la chaîne 8 bits str. Le pointeur sur caractère constant est converti en Unicode en utilisant la fonction fromAscii().

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

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

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 en utilisant la fonction fromAscii(). La copie s'arrête au premier caractère null ; sinon, tout le tableau d'octets est copié.

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

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

QString::~QString ()

Détruit la chaîne de caractères.

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"

Ceci est équivalent à l'utilisation de la fonction insert() :

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

La fonction append() est généralement très rapide (temps constant), parce que QString préalloue de l'espace supplémentaire à la fin des données de la chaîne contenue pour qu'elle puisse grandir sans devoir réallouer la chaîne à chaque fois.

Voir aussi operator+=(), prepend() et insert().

QString & QString::append ( const QStringRef & reference )

Ajoute la reference donnée à cette chaîne et retourne le résultat.

Cette fonction a été introduite dans Qt 4.4.

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

Cette fonction surcharge append().

Ajoute la chaîne Latin-1 str à cette chaîne.

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

Cette fonction surcharge append().

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

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

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

Cette fonction surcharge append().

Ajoute la chaîne str à cette chaîne. Le pointeur sur caractère constant est converti en Unicode en utilisant la fonction fromAscii().

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

QString & QString::append ( QChar ch )

Cette fonction surcharge append().

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

QString QString::arg ( const QString & a, int fieldWidth = 0, const QChar & fillChar = QLatin1Char( ' ' ) ) const

Renvoie une copie de cette chaîne avec le marqueur d'emplacement ayant le plus petit numéro remplacé par la chaîne a, c'est-à-dire %1, %2... %99.

fieldWidth spécifie l'espace minimum que l'argument a occupera. Si a requiert moins d'espace, elle est complétée jusqu'à fieldWidth avec le caractère fillChar. Un fieldWidth positif produit un texte aligné à droite. Un fieldWidth négatif produit un texte aligné à gauche.

Cet exemple montre une méthode de création d'une chaîne status pour informer de l'avancement de la copie d'une liste de fichiers :

QString i;           // numéro du fichier courant
QString total;       // nombre de fichiers à traiter
QString fileName;    // nom du fichier courant
 
QString status = QString("Traitement du fichier %1 sur %2 : %3")
                .arg(i).arg(total).arg(fileName);

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

Un avantage d'utiliser arg() plutôt que sprintf() est que l'ordre des marqueurs d'emplacement numérotés peut changer, si les chaînes de l'application sont traduites dans d'autres langues, et arg() continuera à remplacer le marqueur non remplacé de plus petit numéro, quel que soit l'endroit où il apparaît. De plus, si le marqueur %i apparaît plus d'une fois dans la chaîne, arg() les remplacera tous.

S'il ne reste plus de marqueur non remplacé, un message d'avertissement est émis et le résultat est indéfini. Les marqueurs doivent être dans la plage 1 à 99.

QString QString::arg ( const QString & a1, const QString & a2 ) const

Cette fonction surcharge arg().

Elle fait la même chose que str.arg(a1).arg(a2), à part que les chaînes a1 et a2 sont remplacées d'un seul coup. Le résultat peut être différent par exemple si a1 contient %1 :

QString str;
str = "%1 %2";
 
str.arg("%1f", "Hello");        // renvoie "%1f Hello"
str.arg("%1f").arg("Hello");    // renvoie "Hellof %2"

QString QString::arg ( const QString & a1, const QString & a2, const QString & a3 ) const

Cette fonction surcharge arg().

Elle fait la même chose que str.arg(a1).arg(a2).arg(a3), à part que les chaînes a1, a2 et a3 sont remplacées d'un seul coup.

QString QString::arg ( const QString & a1, const QString & a2, const QString & a3, const QString & a4 ) const

Cette fonction surcharge arg().

Elle fait la même chose que str.arg(a1).arg(a2).arg(a3).arg(a4), à part que les chaînes a1, a2, a3 et a4 sont remplacées d'un seul coup.

QString QString::arg ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5 ) const

Cette fonction surcharge arg().

Elle fait la même chose que str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5), à part que les chaînes a1, a2, a3, a4 et a5 sont remplacées d'un seul coup.

QString QString::arg ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5, const QString & a6 ) const

Cette fonction surcharge arg().

Elle fait la même chose que str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6)), à part que les chaînes a1, a2, a3, a4, a5 et a6 sont remplacées d'un seul coup.

QString QString::arg ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5, const QString & a6, const QString & a7 ) const

Cette fonction surcharge arg().

Elle fait la même chose que str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6).arg(a7), à part que les chaînes a1, a2, a3, a4, a5, a6 et a7 sont remplacées d'un seul coup.

QString QString::arg ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5, const QString & a6, const QString & a7, const QString & a8 ) const

Cette fonction surcharge arg().

Elle fait la même chose que str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6).arg(a7).arg(a8), à part que les chaînes a1, a2, a3, a4, a5, a6, a7 et a8 sont remplacées d'un seul coup.

QString QString::arg ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5, const QString & a6, const QString & a7, const QString & a8, const QString & a9 ) const

Cette fonction surcharge arg().

Elle fait la même chose que str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6).arg(a7).arg(a8).arg(a9), à part que les chaînes a1, a2, a3, a4, a5, a6, a7, a8 et a9 sont remplacées d'un seul coup.

QString QString::arg ( int a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const

Cette fonction surcharge arg().

L'argument a est exprimé en base base, qui vaut 10 par défaut et peut valoir entre 2 et 36. Pour les bases autres que 10, a est traité comme un entier non signé.

fieldWidth spécifie l'espace minimum occupé par a, qui est éventuellement complété avec le caractère de remplissage fillChar. Une valeur positive produit un texte aligné à droite, une valeur négative produit un texte aligné à gauche.

Le symbole % peut être suivi par un L, auquel cas la séquence est remplacée par une représentation localisée de a. La conversion utilise la localisation par défaut, fixée par QLocale::setDefault(). Si aucune localisation par défaut n'a été spécifiée, la localisation « C » sera utilisée. Le drapeau L est ignoré si base est différente de 10.

QString str;
str = QString("63 en décimal vaut %1 en hexadécimal")
        .arg(63, 0, 16);
// str == "63 en décimal vaut 3f en hexadécimal"
 
 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"

Si fillChar vaut   (le nombre 0, de code ASCII 48), le zéro local est utilisé. Pour les nombres négatifs, les zéros de remplissage peuvent apparaître avant le signe moins.

QString QString::arg ( uint a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const

Cette fonction surcharge arg().

L'argument base spécifie la base à utiliser pour la conversion de l'entier a en chaîne de caractères. La base doit être comprise entre 2 et 36.

Si fillChar vaut 0 (le nombre 0, de code ASCII 48), le zéro local est utilisé. Pour les nombres négatifs, les zéros de remplissage peuvent apparaître avant le signe moins.

QString QString::arg ( long a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const

Cette fonction surcharge arg().

fieldWidth spécifie l'espace minimum occupé par a, qui est éventuellement complété avec le caractère de remplissage fillChar. Une valeur positive produit un texte aligné à droite, une valeur négative produit un texte aligné à gauche.

L'argument a est exprimé en base base, qui vaut 10 par défaut et peut valoir entre 2 et 36.

Le symbole % peut être suivi par un L, auquel cas la séquence est remplacée par une représentation localisée de a. La conversion utilise la localisation par défaut. La localisation par défaut est déterminée par les paramètres du système au démarrage de l'application, et peut être modifiée avec QLocale::setDefault(). Le drapeau ‹L› est ignoré si base est différente de 10.

QString str;
str = QString("63 en décimal vaut %1 en hexadécimal")
        .arg(63, 0, 16);
// str == "63 en décimal vaut 3f en hexadécimal"
 
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"

Si fillChar vaut 0 (le nombre 0, de code ASCII 48), le zéro local est utilisé. Pour les nombres négatifs, les zéros de remplissage peuvent apparaître avant le signe moins.

QString QString::arg ( ulong a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const

Cette fonction surcharge arg().

fieldWidth spécifie l'espace minimum occupé par a, qui est éventuellement complété avec le caractère de remplissage fillChar. Une valeur positive produit un texte aligné à droite, une valeur négative produit un texte aligné à gauche.

L'argument base spécifie la base à utiliser pour la conversion de l'entier a en chaîne de caractères. La base doit être comprise entre 2 et 36, avec 8 pour l'octal, 10 pour le décimal et 16 pour l'hexadécimal.

Si fillChar vaut 0 (le nombre 0, de code ASCII 48), le zéro local est utilisé. Pour les nombres négatifs, les zéros de remplissage peuvent apparaître avant le signe moins.

QString QString::arg ( qlonglong a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const

Cette fonction surcharge arg().

fieldWidth spécifie l'espace minimum occupé par a, qui est éventuellement complété avec le caractère de remplissage fillChar. Une valeur positive produit un texte aligné à droite, une valeur négative produit un texte aligné à gauche.

L'argument base spécifie la base à utiliser pour la conversion de l'entier a en chaîne de caractères. La base doit être comprise entre 2 et 36, avec 8 pour l'octal, 10 pour le décimal et 16 pour l'hexadécimal.

Si fillChar vaut 0 (le nombre 0, de code ASCII 48), le zéro local est utilisé. Pour les nombres négatifs, les zéros de remplissage peuvent apparaître avant le signe moins.

QString QString::arg ( qulonglong a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const

Cette fonction surcharge arg().

fieldWidth spécifie l'espace minimum occupé par a, qui est éventuellement complété avec le caractère de remplissage fillChar. Une valeur positive produit un texte aligné à droite, une valeur négative produit un texte aligné à gauche.

L'argument base spécifie la base à utiliser pour la conversion de l'entier a en chaîne de caractères. La base doit être comprise entre 2 et 36, avec 8 pour l'octal, 10 pour le décimal et 16 pour l'hexadécimal.

Si fillChar vaut 0 (le nombre 0, de code ASCII 48), le zéro local est utilisé. Pour les nombres négatifs, les zéros de remplissage peuvent apparaître avant le signe moins.

QString QString::arg ( short a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const

Cette fonction surcharge arg().

fieldWidth spécifie l'espace minimum occupé par a, qui est éventuellement complété avec le caractère de remplissage fillChar. Une valeur positive produit un texte aligné à droite, une valeur négative produit un texte aligné à gauche.

L'argument base spécifie la base à utiliser pour la conversion de l'entier a en chaîne de caractères. La base doit être comprise entre 2 et 36, avec 8 pour l'octal, 10 pour le décimal et 16 pour l'hexadécimal.

Si fillChar vaut 0 (le nombre 0, de code ASCII 48), le zéro local est utilisé. Pour les nombres négatifs, les zéros de remplissage peuvent apparaître avant le signe moins.

QString QString::arg ( ushort a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const

Cette fonction surcharge arg().

fieldWidth spécifie l'espace minimum occupé par a, qui est éventuellement complété avec le caractère de remplissage fillChar. Une valeur positive produit un texte aligné à droite, une valeur négative produit un texte aligné à gauche.

L'argument base spécifie la base à utiliser pour la conversion de l'entier a en chaîne de caractères. La base doit être comprise entre 2 et 36, avec 8 pour l'octal, 10 pour le décimal et 16 pour l'hexadécimal.

Si fillChar vaut 0 (le nombre 0, de code ASCII 48), le zéro local est utilisé. Pour les nombres négatifs, les zéros de remplissage peuvent apparaître avant le signe moins.

QString QString::arg ( QChar a, int fieldWidth = 0, const QChar & fillChar = QLatin1Char( ' ' ) ) const

Cette fonction surcharge arg().

QString QString::arg ( char a, int fieldWidth = 0, const QChar & fillChar = QLatin1Char( ' ' ) ) const

Cette fonction surcharge arg().

L'argument a est interprété comme un caractère Latin-1.

QString QString::arg ( double a, int fieldWidth = 0, char format = ‹g›, int precision = -1, const QChar & fillChar = QLatin1Char( ' ' ) ) const

Cette fonction surcharge arg().

L'argument a est formaté suivant le format et la précision donnés. Voir l'argument format pour plus de détails.

fieldWidth spécifie l'espace minimum occupé par a, qui est éventuellement complété avec le caractère de remplissage 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"

Le symbole % peut être suivi par un L, auquel cas la séquence est remplacée par une représentation localisée de a. La conversion utilise la localisation par défaut, fixée par QLocale::setDefault(). Si aucune localisation par défaut n'a été spécifiée, la localisation « C » sera utilisée.

Si fillChar vaut   (le nombre 0, de code ASCII 48), le zéro local est utilisé. Pour les nombres négatifs, les zéros de remplissage peuvent apparaître avant le signe moins.

Voir aussi QLocale::toString().

const QChar QString::at ( int position ) const

Retourne le caractère de la chaîne situé à l'index position donné.

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

Voir aussi operator[]().

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().

const_iterator QString::begin () const

Cette fonction surcharge begin().

int QString::capacity () const

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

Le seul intérêt de cette fonction est de donner un moyen de gérer finement l'utilisation de la mémoire par QString. En général, vous devrez rarement l'appeler. Si vous voulez connaître le nombre de caractères de la chaîne, appelez size().

Voir aussi reserve() et squeeze().

void QString::chop ( int n )

Retire n caractères à partir de la fin de la chaîne.

Si n est plus grand que size(), le résultat est une chaîne vide.

Exemple :

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

Si vous voulez retirer des caractères depuis le début de la chaîne, utilisez remove().

Voir aussi truncate(), resize() et remove().

void QString::clear ()

Supprime le contenu de la chaîne, qui devient une chaîne vide.

Voir aussi resize() et isEmpty().

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

Compare s1 avec s2 et renvoie un entier plus petit que, égal à ou plus grand que zéro, suivant que s1 est plus petite que, égale à ou plus grande que s2.

Si cs est Qt::CaseSensitive, la comparaison est sensible à la casse ; sinon, elle 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 à ce qu'un humain attend. Triez les chaînes visibles par l'utilisateur de préférence 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

Cette fonction a été introduite dans Qt 4.2.

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

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

Cette fonction surcharge compare().

Effectue une comparaison sensible à la casse de s1 et de s2.

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

Cette fonction surcharge compare().

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

Cette fonction a été introduite dans Qt 4.2.

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

Cette fonction surcharge compare().

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

Cette fonction a été introduite dans Qt 4.2.

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

Cette fonction surcharge compare().

Compare lexicalement cette chaîne avec la chaîne other et renvoie un entier plus petit que, égal à ou plus grand que zéro suivant que cette chaîne est plus petite que, égale à ou plus grande que la chaîne other.

Équivalent à compare(*this, other).

int QString::compare ( const QString & other, Qt::CaseSensitivity cs ) const

Cette fonction surcharge compare().

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

Cette fonction a été introduite dans Qt 4.2.

int QString::compare ( const QLatin1String & other, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const

Cette fonction surcharge compare().

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

Cette fonction a été introduite dans Qt 4.2.

int QString::compare ( const QStringRef & ref, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const

Cette fonction surcharge compare().

Compare cette chaîne avec ref, référence à une chaîne, et renvoie un entier plus petit que, égal à ou plus grand que zéro suivant que cette chaîne est plus petite que, égale à ou plus grande que ref.

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

Cette fonction surcharge compare().

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 QString. Le pointeur peut être utilisé pour accéder aux caractères composant la chaîne. Pour en faciliter l'usage, les données sont terminées par un \0.

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

Voir aussi data() et operator[]().

const_iterator QString::constEnd () const

Renvoie un itérateur de style STL constant pointant sur un élément imaginaire situé après le dernier élément de la liste.

Voir aussi constBegin() et end().

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 (la valeur par défaut), la recherche est sensible à la casse ; sinon elle est insensible à la casse.

Exemple :

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

Voir aussi indexOf() et count().

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

Cette fonction surcharge contains().

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

bool QString::contains ( const QRegExp & rx ) const

Cette fonction surcharge contains().

Renvoie true si l'expression régulière rx correspond à la chaîne ; sinon renvoie false.

bool QString::contains ( QRegExp & rx ) const

Cette fonction surcharge contains().

Renvoie true si l'expression régulière rx correspond à la chaîne ; sinon renvoie false.

S'il y a correspondance, l'expression régulière rx contiendra les captures trouvées (voir QRegExp::matchedLength, QRegExp::cap).

Cette fonction a été introduite dans Qt 4.5.

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

Renvoie le nombre d'occurrences (avec des recouvrements éventuels) de la chaîne str dans cette chaîne.

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

Voir aussi contains() et indexOf().

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

Cette fonction surcharge count().

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

int QString::count ( const QRegExp & rx ) const

Cette fonction surcharge count().

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

Cette fonction compte les correspondances y compris avec recouvrement, par exemple ci-dessous, on trouve quatre instances de « ana » ou « ama »:

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

int QString::count () const

Cette fonction surcharge count().

Identique à size().

QChar * QString::data ()

Renvoie un pointeur sur les données stockées dans la QString. Le pointeur peut être utilisé pour accéder aux caractères composant la chaîne et les modifier. Pour en faciliter l'usage, les données sont terminées par un \0.

Exemple :

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

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

Voir aussi constData() et operator[]().

const QChar * QString::data () const

Il s'agit d'une fonction surchargée.

iterator QString::end ()

Renvoie un itérateur de style STL pointant sur un élément imaginaire situé après le dernier élément de la liste.

Voir aussi begin() et constEnd().

const_iterator QString::end () const

Cette fonction surcharge end().

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 (la valeur par défaut), la recherche est sensible à la casse ; sinon elle est insensible à la casse.

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

Voir aussi startsWith().

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

Cette fonction surcharge endsWith().

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

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

Cette fonction surcharge endsWith().

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

Affecte la valeur ch à tous les caractères de la chaîne. Si size est différente de -1 (la valeur par défaut), la chaîne est d'abord dimensionnée à la taille size.

Exemple :

QString str = "Berlin";
str.fill('z');
// str == "zzzzzz"
 
str.fill('A', 2);
// str == "AA"

Voir aussi resize().

QString QString::fromAscii ( const char * str, int size = -1 ) [static]

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

Si size vaut -1 (la valeur par défaut), on utilise à sa place qstrlen(str).

Notez que, contrairement à ce que laisse imaginer son nom, cette fonction utilise en fait le codec défini par QTextCodec::setCodecForCStrings() pour convertir str en Unicode. En fonction du codec, elle peut ne pas accepter une entrée US-ASCII (ANSI X3.4-1986) valide. Si aucun codec n'a été défini, cette fonction est équivalente à fromLatin1().

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

QString QString::fromLatin1 ( const char * str, int size = -1 ) [static]

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

Si size vaut -1 (la valeur par défaut), on utilise à sa place qstrlen(str).

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

QString QString::fromLocal8Bit ( const char * str, int size = -1 ) [static]

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

Si size vaut -1 (la valeur par défaut), on utilise à sa place qstrlen(str).

QTextCodec::codecForLocale() est utilisée pour la conversion vers Unicode.

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

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

Construit une QString à partir des size premiers caractères Unicode du tableau unicode. Les données dans unicode ne sont pas copiées. L'appelant doit être en mesure de garantir que l'argument unicode ne sera pas détruit ou modifié tant que la QString (ou une de ses copies non modifiées) existe.

Toute tentative de modification de la QString ou d'une de ses copies entraînera une copie profonde des données, ce qui assure que les données brutes ne sont jamais modifiées.

Voici un exemple d'utilisation d'une QRegExp sur des données brutes en mémoire en évitant la copie des données dans une QString :

QRegExp pattern;
static const QChar unicode[] = {
        0x005A, 0x007F, 0x00A4, 0x0060,
        0x1009, 0x0020, 0x0020};
int size = sizeof(unicode) / sizeof(QChar);
 
QString str = QString::fromRawData(unicode, size);
if (str.contains(QRegExp(pattern))) {
    // ...
}

Attention : une chaîne créée avec fromRawData() n'est pas terminée par un \0, sauf si les données brutes contiennent un caractère \0 à la position size. Cela signifie que la fonction unicode() ne renverra pas une chaîne terminée par un \0 (contrairement à ce que fait utf16(), mais au prix d'une copie des données brutes).

Voir aussi fromUtf16() et setRawData().

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

Renvoie une copie de la chaîne str. La chaîne donnée est convertie en Unicode en utilisant la fonction fromAscii().

Ce constructeur est disponible seulement si Qt est configuré avec la compatibilité STL activée.

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

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

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

Ce constructeur est disponible seulement si Qt est configuré avec la compatibilité STL activée.

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

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

Renvoie une QString initialisée avec les size premiers caractères de la chaîne Unicode unicode (en encodage ISO-10646-UCS-4).

Si size vaut -1 (la valeur par défaut), on utilise à sa place qstrlen(str).

Cette fonction a été introduite dans Qt 4.2.

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

QString QString::fromUtf8 ( const char * str, int size = -1 ) [static]

Renvoie une QString initialisée avec les size premiers caractères de la chaîne UTF-8 str.

Si size vaut -1 (la valeur par défaut), on utilise à sa place qstrlen(str).

UTF-8 est un codec Unicode et peut représenter tous les caractères d'une chaîne Unicode comme le fait QString. Cependant, des séquences invalides sont possibles en UTF-8 ; les séquences invalides détectées seront remplacées par un ou plusieurs « caractères de remplacement » ou supprimées. Cela inclut les séquences non Unicode, les non-caractères, les séquences trop longues ou les points de code de demi-zone encodés en UTF-8.

Les non-caractères sont des points de code que le standard Unicode réserve et qui ne doivent pas être utilisés dans l'échange de texte. Ce sont les deux derniers points de code de chaque plan Unicode (U+FFFE, U+FFFF, U+1FFFE, U+1FFFF, U+2FFFE, etc.), ainsi que les 16 points de code dans la plage U+FDD0..U+FDDF (inclus).

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

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

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

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

Cette fonction vérifie la présence d'un BOM (Byte Order Mark ou Marqueur d'Ordre des Octets). S'il est absent, elle utilise l'ordre du système hôte.

Cette fonction est lente comparée aux autres conversions Unicode. Utilisez de préférence QString(const QChar *, int) ou QString(const QChar *).

QString effectue une copie profonde des données Unicode.

Voir aussi utf16() et setUtf16().

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

Renvoie une copie de string, avec une interprétation de l'encodage de string dépendant de la taille de wchar. Si wchar est codé sur quatre octets, string est interprétée en UCS-4 ; sur deux octets, elle est interprétée en UCS-2.

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

Cette fonction a été introduite dans Qt 4.2.

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

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

Renvoie la position de la première occurrence de la chaîne str dans cette chaîne, en recherchant vers la fin de la chaîne depuis la position from. Renvoie -1 si str n'est pas trouvée.

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

Exemple :

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

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

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

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

Renvoie la position de la première occurrence de la chaîne str dans cette chaîne, en recherchant vers la fin de la chaîne depuis la position from. Renvoie -1 si str n'est pas trouvée.

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

Exemple :

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

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

Cette fonction a été introduite dans Qt 4.5.

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

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

Cette fonction surcharge indexOf().

Renvoie la position de la première occurrence du caractère ch dans cette chaîne, en recherchant vers la fin de la chaîne depuis la position from. Renvoie -1 si ch n'est pas trouvé.

int QString::indexOf ( const QRegExp & rx, int from = 0 ) const

Cette fonction surcharge indexOf().

Renvoie la position de la première correspondance de l'expression régulière rx dans cette chaîne, en recherchant vers la fin de la chaîne depuis la position from. Renvoie -1 si aucune correspondance n'est trouvée.

Exemple :

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

int QString::indexOf ( QRegExp & rx, int from = 0 ) const

Cette fonction surcharge indexOf().

Renvoie la position de la première correspondance de l'expression régulière rx dans cette chaîne, en recherchant vers la fin de la chaîne depuis la position from. Renvoie -1 si aucune correspondance n'est trouvée.

Si des correspondances sont trouvées, l'expression régulière rx contiendra les captures correspondantes (voir QRegExp::matchedLength, QRegExp::cap).

Exemple :

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

Cette fonction a été introduite dans Qt 4.5.

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

Insère la chaîne Latin-1 str à la position donnée et renvoie une référence à la chaîne.

Exemple :

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

Si la position donnée est plus grande que size(), le tableau est d'abord étendu en utilisant resize().

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

QString & QString::insert ( int position, const QLatin1String & str )

Cette fonction surcharge insert().

Insère la chaîne Latin-1 str à la position donnée.

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

Cette fonction surcharge insert().

Insère les premiers size caractères du tableau de QChar array unicode à la position donnée.

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

Cette fonction surcharge insert().

Insère ch à la position donnée dans la chaîne.

bool QString::isEmpty () const

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

Exemple :

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

Voir aussi size().

bool QString::isNull () const

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

Exemple :

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

Qt fait une distinction entre les chaînes nulles et les chaînes vides pour des raisons historiques. Pour la plupart des applications, ce qui compte est de savoir si la chaîne contient des données ou pas, et cela peut être déterminé en utilisant la fonction isEmpty().

Voir aussi isEmpty().

bool QString::isRightToLeft () const

Renvoie true si la chaîne se lit de droite à gauche.

int QString::lastIndexOf ( const QString & str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const

Renvoie la position de la première occurrence de la chaîne str dans cette chaîne, en recherchant vers le début de la chaîne depuis la position from. Si from vaut -1, la recherche commence au dernier caractère ; s'il vaut -2, elle commence à l'avant-dernier caractère et ainsi de suite. Renvoie -1 si str n'est pas trouvée.

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

Exemple :

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

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

int QString::lastIndexOf ( const QLatin1String & str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const

Renvoie la position de la première occurrence de la chaîne str dans cette chaîne, en recherchant vers le début de la chaîne depuis la position from. Si from vaut -1, la recherche commence au dernier caractère ; s'il vaut -2, elle commence à l'avant-dernier caractère et ainsi de suite. Renvoie -1 si str n'est pas trouvée.

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

Exemple :

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

Cette fonction a été introduite dans Qt 4.5.

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

int QString::lastIndexOf ( QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const

Cette fonction surcharge lastIndexOf().

Renvoie la position de la dernière occurrence du caractère ch dans cette chaîne, en recherchant vers le début de la chaîne depuis la position from.

int QString::lastIndexOf ( const QRegExp & rx, int from = -1 ) const

Cette fonction surcharge lastIndexOf().

Renvoie la position de la dernière occurrence de l'expression régulière rx dans cette chaîne, en recherchant vers le début de la chaîne depuis la position from. Renvoie -1 si aucune correspondance avec rx n'est trouvée.

Exemple :

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

int QString::lastIndexOf ( QRegExp & rx, int from = -1 ) const

Cette fonction surcharge lastIndexOf().

Renvoie la position de la dernière occurrence de l'expression régulière rx dans cette chaîne, en recherchant vers le début de la chaîne depuis la position from. Renvoie -1 si aucune correspondance avec rx n'est trouvée.

Si des correspondances sont trouvées, l'expression régulière rx contiendra les captures correspondantes (voir QRegExp::matchedLength, cap|QRegExp::cap]]).

Exemple :

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

Cette fonction a été introduite dans Qt 4.5.

QString QString::left ( int n ) const

Renvoie une sous-chaîne contenant les n caractères de gauche de la chaîne.

Si n est plus grand que size() ou inférieur à zéro, elle renvoie la chaîne entière.

QString x = "Télévision";
QString y = x.left(4);      // y == "Télé"

Voir aussi right(), mid() et startsWith().

QString QString::leftJustified ( int width, QChar fill = QLatin1Char( ' ' ), bool truncate = false ) const

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

Si truncate est faux et que la taille de la chaîne est plus grande que width, la fonction renvoie une copie de la chaîne.

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

Si truncate est vrai et que la taille de la chaîne est plus grande que width, les caractères de la copie de la chaîne situés après la position width sont supprimés et cette copie est renvoyée.

QString str = "Télévision";
str = str.leftJustified(5, '.', true);    // str == "Télév"

Voir aussi rightJustified().

QStringRef QString::leftRef ( int n ) const

Renvoie une référence de sous-chaîne sur les n caractères de gauche de la chaîne.

Si n est plus grand que size() ou inférieur à zéro, elle renvoie une référence à la chaîne entière.

QString x = "Télévision";
QStringRef y = x.leftRef(4);        // y == "Télé"

Cette fonction a été introduite dans Qt 4.4.

Voir aussi left(), rightRef(), midRef() et startsWith().

int QString::length () const

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

Voir aussi setLength().

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

Compare la chaîne s1 avec s2 et renvoie un entier plus petit que, égal à ou plus grand que zéro suivant que s1 est plus petite que, égale à ou plus grande que s2.

La comparaison est effectuée en tenant compte de la localisation et de la plateforme. Utilisez cette fonction pour la présentation de chaînes triées à l'utilisateur.

Sur Mac OS X depuis Qt 4.3, cette fonction compare en utilisant le paramètre « Ordre des listes triées » dans le panneau des préférences internationales.

Voir aussi compare() et QTextCodec::locale().

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

Cette fonction surcharge localeAwareCompare().

Compare cette chaîne avec la chaîne other et renvoie un entier plus petit que, égal à ou plus grand que zéro suivant que cette chaîne est plus petite que, égale à ou plus grande que la chaîne other.

La comparaison est effectuée en tenant compte de la localisation et de la plateforme. Utilisez cette fonction pour la présentation de chaînes triées à l'utilisateur.

Identique à localeAwareCompare(*this, other).

Cette fonction a été introduite dans Qt 4.5.

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

Cette fonction surcharge localeAwareCompare().

Compare la chaîne s1 avec s2 et renvoie un entier plus petit que, égal à ou plus grand que zéro suivant que s1 est plus petite que, égale à ou plus grande que s2.

La comparaison est effectuée en tenant compte de la localisation et de la plateforme. Utilisez cette fonction pour la présentation de chaînes triées à l'utilisateur.

Cette fonction a été introduite dans Qt 4.5.

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

Cette fonction surcharge localeAwareCompare().

Compare cette chaîne avec la chaîne other et renvoie un entier plus petit que, égal à ou plus grand que zéro suivant que cette chaîne est plus petite que, égale à ou plus grande que la chaîne other.

La comparaison est effectuée en tenant compte de la localisation et de la plateforme. Utilisez cette fonction pour la présentation de chaînes triées à l'utilisateur.

Identique à localeAwareCompare(*this, other).

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

Renvoie une chaîne contenant n caractères de cette chaîne, en commençant à la position spécifiée.

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

Exemple :

QString x = "Neuf ananas";
QString y = x.mid(5, 4);            // y == "anan"
QString z = x.mid(5);               // z == "ananas"

Voir aussi left() et right().

QStringRef QString::midRef ( int position, int n = -1 ) const

Renvoie une référence à une sous-chaîne contenant n caractères de cette chaîne, en commençant à la position spécifiée.

Renvoie une référence vide si position dépasse la longueur de la chaîne.

S'il y a moins de n caractères dans la chaîne à partir de la position donnée ou si n vaut -1 (la valeur par défaut), la fonction renvoie tous les caractères à partir de la position spécifiée.

Exemple :

QString x = "Neuf ananas";
QString y = x.mid(5, 4);            // y == "anan"
QString z = x.mid(5);               // z == "ananas"

Cette fonction a été introduite dans Qt 4.4.

Voir aussi mid(), leftRef() et rightRef().

QString QString::normalized ( NormalizationForm mode ) const

Renvoie la chaîne dans le mode de normalisation Unicode mode.

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

Il s'agit d'une fonction surchargée.

Renvoie la chaîne dans le mode de normalisation Unicode mode, suivant la version spécifiée du standard Unicode.

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

Renvoie une chaîne représentant le nombre n dans la base spécifiée.

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é.

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

Voir aussi setNum().

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

Renvoie une chaîne représentant le nombre n, formatée suivant le format et la précision spécifiés. Voir l'argument format pour plus de détails.

Contrairement à QLocale::toString(), cette fonction ne tient pas compte des paramètres régionaux de l'utilisateur.

Voir aussi setNum() et QLocale::toString().

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

Il s'agit d'une fonction surchargée.

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

Il s'agit d'une fonction surchargée.

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

Il s'agit d'une fonction surchargée.

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

Il s'agit d'une fonction surchargée.

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

Il s'agit d'une fonction surchargée.

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

Ajoute la chaîne str en tête de cette chaîne et renvoie une référence à la chaîne.

Exemple :

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

Voir aussi append() et insert().

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

Cette fonction surcharge prepend().

Ajoute la chaîne Latin-1 str en tête de cette chaîne

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

Cette fonction surcharge prepend().

Ajoute le tableau d'octets ba en tête de cette chaîne. Le tableau d'octets est converti en Unicode en utilisant la fonction fromAscii().

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

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

Cette fonction surcharge prepend().

Ajoute la chaîne str en tête de cette chaîne. Le pointeur const char est converti en Unicode en utilisant la fonction fromAscii().

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

QString & QString::prepend ( QChar ch )

Cette fonction surcharge prepend().

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

void QString::push_back ( const QString & other )

Cette fonction est fournie pour la compatibilité avec la 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 )

Il s'agit d'une fonction surchargée.

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

void QString::push_front ( const QString & other )

Cette fonction est fournie pour la compatibilité avec la STL, elle ajoute 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 )

Il s'agit d'une fonction surchargée.

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

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

Supprime n caractères de la chaîne, en commençant à la position donnée, et renvoie une référence à la chaîne.

Si la position spécifiée est à l'intérieur de la chaîne mais que position + n est au-delà de la fin de la chaîne, la chaîne est tronquée à partir de position.

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

Voir aussi insert() 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 à la chaîne.

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

Exemple :

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

Équivalent à replace(ch,  » », cs).

Voir aussi 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 et renvoie une référence à la chaîne.

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

Équivalent à replace(ch, "", cs).

Voir aussi replace().

QString & QString::remove ( const QRegExp & rx )

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

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

Voir aussi indexOf(), lastIndexOf() et replace().

QString QString::repeated ( int times ) const

Renvoie une copie de cette chaîne répétée un nombre times de fois.

Si times est plus petit que 1, renvoie une chaîne vide.

Exemple :

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

Cette fonction a été introduite dans Qt 4.5.

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

Remplace n caractères en commençant à l'indice 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 ( int position, int n, const QChar * unicode, int size )

Cette fonction surcharge replace().

Remplace n caractères en commençant à l'indice position par les size premiers caractères du tableau de QChar unicode et renvoie une référence à cette chaîne.

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

Cette fonction surcharge replace().

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

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

Cette fonction surcharge replace().

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 Qt::CaseSensitive (la valeur par défaut), la recherche est sensible à la casse ; sinon elle est insensible à la casse.

Exemple :

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

Note : le texte de remplacement n'est pas relu après son insertion.

Exemple :

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

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

Cette fonction surcharge replace().

Remplace toutes les occurrences des premiers blen caractères de before avec les premiers alen caractères de after et renvoie une référence à cette chaîne.

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

Cette fonction a été introduite dans Qt 4.5.

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

Cette fonction surcharge replace().

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

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

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

Cette fonction surcharge replace().

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

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

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

Cette fonction surcharge replace().

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 Qt::CaseSensitive (la valeur par défaut), la recherche est sensible à la casse ; sinon elle est insensible à la casse.

Note : le texte n'est pas relu après un remplacement.

Cette fonction a été introduite dans Qt 4.5.

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

Cette fonction surcharge replace().

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 Qt::CaseSensitive (la valeur par défaut), la recherche est sensible à la casse ; sinon elle est insensible à la casse.

Note : le texte n'est pas relu après un remplacement.

Cette fonction a été introduite dans Qt 4.5.

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

Cette fonction surcharge replace().

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 Qt::CaseSensitive (la valeur par défaut), la recherche est sensible à la casse ; sinon elle est insensible à la casse.

Note : le texte n'est pas relu après un remplacement.

Cette fonction a été introduite dans Qt 4.5.

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

Cette fonction surcharge replace().

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

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

Note : le texte n'est pas relu après un remplacement.

Cette fonction a été introduite dans Qt 4.5.

QString & QString::replace ( const QRegExp & rx, const QString & after )

Cette fonction surcharge replace().

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

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

Pour les expressions régulières contenant des parenthèses de capture, les occurrences de \1, \2, ..., dans after sont remplacées par rx.cap(1), cap(2)...

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

Voir aussi indexOf(), lastIndexOf(), remove() et QRegExp::cap().

void QString::reserve ( int size )

Tente une réservation de mémoire pour au moins size caractères. Si vous savez à l'avance quelle sera la taille maximale de la chaîne, en appelant cette fonction vous pouvez espérer améliorer les performances dans le cas où vous changez souvent la taille de la chaîne. Si size est une sous-estimation, dans le pire des cas la QString sera un peu plus lente.

Le seul but de cette fonction est de permettre une gestion fine de l'usage mémoire de QString. En général, vous aurez rarement à appeler cette fonction. Si vous voulez changer la taille de la chaîne, appelez resize().

Cette fonction est utile pour du code devant construire une longue chaîne et voulant éviter des allocations répétées. Dans cet exemple, nous ajoutons des caractères à la chaîne jusqu'à ce qu'une condition soit vraie et nous estimons que la taille est assez grande pour que l'appel à reserve() soit rentable :

QString result;
int maxSize;
bool condition;
QChar nextChar;
 
result.reserve(maxSize);
 
while (condition)
    result.append(nextChar);
 
result.squeeze();

Voir aussi squeeze() et capacity().

void QString::resize ( int size )

Fixe la taille de la chaîne à size caractères.

Si size est plus grande que la taille courante, la chaîne est étendue pour la passer à size caractères de long, avec les caractères supplémentaires ajoutés en fin de chaîne. Les nouveaux caractères ne sont pas initialisés.

Si size est inférieure à la taille courante, des caractères sont supprimés à partir de la fin.

Exemple :

QString s = "Hello world";
s.resize(5);
// s == "Hello"
 
s.resize(8);
// s == "Hello???" (où ? représente des caractères quelconques)

Si vous voulez ajouter un certain nombre de caractères identiques à la chaîne, utilisez operator+=() de la façon suivante, plutôt que resize() :

QString t = "Hello";
t += QString(10, 'X');
// t == "HelloXXXXXXXXXX"

Si vous voulez étendre la chaîne jusqu'à une certaine longueur et remplir les nouvelles positions avec un caractère particulier, utilisez la fonction leftJustified() :

QString r = "Hello";
r = r.leftJustified(10, ' ');
// r == "Hello     "

Passer une size négative est équivalent à passer zéro.

Voir aussi truncate() et reserve().

Renvoie une sous-chaîne contenant les n caractères de droite de la chaîne.

Si n est plus grand que size() ou inférieur à zéro, la fonction renvoie la chaîne entière.

QString x = "Pamplemousse";
QString y = x.right(6);      // y == "mousse"

Voir aussi left(), mid() et endsWith().

QString QString::rightJustified ( int width, QChar fill = QLatin1Char( ' ' ), bool truncate = false ) const

Renvoie une chaîne dont la taille est width contenant le caractère de remplissage fill suivi de la chaîne d'origine. Par exemple :

QString s = "pomme";
QString t = s.rightJustified(8, '.');    // t == "...pomme"

Si truncate est faux et que la taille de la chaîne est supérieure à width, la chaîne renvoyée sera une copie de la chaîne.

Si truncate est vrai et que la taille de la chaîne est supérieure à width, la chaîne renvoyée sera tronquée à la position width.

QString str = "Pamplemousse";
str = str.rightJustified(5, '.', true);    // str == "Pampl"

Voir aussi leftJustified().

QStringRef QString::rightRef ( int n ) const

Renvoie une référence à une sous-chaîne contenant les n caractères de droite de la chaîne.

Si n est plus grand que size() ou inférieur à zéro, la fonction renvoie une référence à la chaîne entière.

QString x = "Pamplemousse";
QStringRef y = x.right(6);      // y == "mousse"

Voir aussi right(), leftRef(), midRef() et endsWith().

QString QString::section ( QChar sep, int start, int end = -1, SectionFlags flags = SectionDefault ) const

Cette fonction renvoie une section de la chaîne.

La chaîne est traitée comme une séquence de champs séparés par le caractère sep. La chaîne renvoyée contient les champs de la position start à la position end incluse. Si end n'est pas spécifiée, tous les champs depuis la position start jusqu'à la fin de la chaîne sont inclus. Les champs sont numérotés 0, 1, 2... en comptant depuis la gauche et -1, -2... en comptant de droite à gauche.

L'argument flags peut être utilisé pour modifier le comportement de la fonction, par exemple la sensibilité à la casse, ignorer ou pas les champs vides ou la façon de traiter les séparateurs de début et de fin ; voir SectionFlags.

QString str;
QString csv = "forename,middlename,surname,phone";
QString path = "/usr/local/bin/myapp"; // Le premier champ est vide
QString::SectionFlag flag = QString::SectionSkipEmpty;
 
str = csv.section(',', 2, 2);   // str == "surname"
str = path.section('/', 3, 4);  // str == "bin/myapp"
str = path.section('/', 3, 3, flag); // str == "myapp"

Si start ou end sont négatifs, les champs sont comptés depuis la droite de la chaîne, le champ le plus à droite ayant le numéro -1, le champ suivant à sa gauche le numéro -2 et ainsi de suite.

str = csv.section(',', -3, -2);  // str == "middlename,surname"
str = path.section('/', -1); // str == "myapp"

Voir aussi split().

QString QString::section ( const QString & sep, int start, int end = -1, SectionFlags flags = SectionDefault ) const

Cette fonction surcharge section().

QString str;
QString data = "forename**middlename**surname**phone";
 
str = data.section("**", 2, 2); // str == "surname"
str = data.section("**", -3, -2); // str == "middlename**surname"

Voir aussi split().

QString QString::section ( const QRegExp & reg, int start, int end = -1, SectionFlags flags = SectionDefault ) const

Cette fonction surcharge section().

La chaîne est traitée comme une séquence de champs séparés par l'expression régulière reg.

QString line = "forename\tmiddlename  surname \t \t phone";
QRegExp sep("\\s+");
str = line.section(sep, 2, 2); // s == "surname"
str = line.section(sep, -3, -2); // s == "middlename  surname"

Attention : cette version QRegExp est beaucoup plus coûteuse que les versions caractère et chaîne.

Voir aussi split() et simplified().

QString & QString::setNum ( int n, int base = 10 )

Affecte à la chaîne la valeur textuelle de n dans la base spécifiée et renvoie une référence à la chaîne.

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é.

QString str;
str.setNum(1234);       // str == "1234"

Le formatage utilise toujours QLocale::C, c'est-à-dire, Anglais/USA. Pour obtenir une représentation localisée d'un nombre, utilisez QLocale::toString() avec la localisation appropriée.

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

Il s'agit d'une fonction surchargée.

QString & QString::setNum ( long n, int base = 10 )

Il s'agit d'une fonction surchargée.

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

Il s'agit d'une fonction surchargée.

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

Il s'agit d'une fonction surchargée.

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

Il s'agit d'une fonction surchargée.

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

Il s'agit d'une fonction surchargée.

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

Il s'agit d'une fonction surchargée.

QString & QString::setNum ( double n, char format = ‹g›, int precision = 6 )

Il s'agit d'une fonction surchargée.

Affecte à la chaîne la valeur textuelle de n, formatée suivant format et precision, et renvoie une référence à la chaîne.

Le format peut être f, F, e, E, g ou G (voir la documentation de la fonction arg() pour une explication des formats).

Contrairement à QLocale::toString(), cette fonction ne tient pas compte des paramètres régionaux de l'utilisateur.

QString & QString::setNum ( float n, char format = ‹g›, int precision = 6 )

Il s'agit d'une fonction surchargée.

Affecte à la chaîne la valeur textuelle de n, formatée suivant format et precision, et renvoie une référence à la chaîne.

QString & QString::setRawData ( const QChar * unicode, int size )

Demande à la QString de prendre comme contenu les size premiers caractères Unicode du tableau unicode. Les données de l'argument unicode ne sont pas copiées. L'appelant doit pouvoir garantir que l'argument unicode ne sera pas supprimé ou modifié tant que la QString (ou une de ses copies non modifiées) existe.

Cette fonction peut être utilisée à la place de fromRawData() pour réutiliser des objets QString existants afin d'économiser des réallocations de mémoire.

Cette fonction a été introduite dans Qt 4.7.

Voir aussi fromRawData().

QString & QString::setUnicode ( const QChar * unicode, int size )

Redimensionne la chaîne à size caractères et copie unicode dans la chaîne.

Si unicode vaut 0, rien n'est copié mais la chaîne est quand même redimensionnée à size.

Voir aussi unicode() et setUtf16().

QString & QString::setUtf16 ( const ushort * unicode, int size )

Redimensionne la chaîne à size caractères et copie unicode dans la chaîne.

Si unicode vaut 0, rien n'est copié mais la chaîne est quand même redimensionnée à size.

Notez que contrairement à fromUtf16(), cette fonction ne tient pas compte des BOM (Byte Order Mark) et de l'ordre des octets éventuellement différents.

Voir aussi utf16() et setUnicode().

QString QString::simplified () const

Renvoie une chaîne dont les blancs de début et de fin ont été retirés et dont chaque séquence de blancs interne a été remplacée par un espace simple.

Un blanc est défini comme un caractère pour lequel QChar::isSpace() renvoie true, ce qui inclut les caractères ASCII \t, \n, \v, \f, \r et " ".

Exemple :

QString str = "  plein\t de\nblancs\r\n ";
str = str.simplified();
// str == "plein de blancs";

Voir aussi trimmed().

int QString::size () const

Renvoie le nombre de caractères de la chaîne.

Le dernier caractère de la chaîne est à la position size() - 1. De plus, QString garantit que le caractère à la position size() est toujours \0, ce qui permet d'utiliser la valeur renvoyée par data() et constData() comme argument pour des fonctions attendant des chaînes avec un \0 final.

Exemple :

QString str = "World";
int n = str.size();         // n == 5
str.data()[0];              // renvoie 'W'
str.data()[4];              // renvoie 'd'
str.data()[5];              // renvoie ''\0''

Voir aussi isEmpty() et resize().

QStringList QString::split ( const QString & sep, SplitBehavior behavior = KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const

Découpe la chaîne en sous-chaînes à chaque occurrence de sep et renvoie la liste de ces chaînes. Si sep n'est pas trouvé dans la chaîne, split() renvoie une liste contenant cette chaîne comme seul élément.

cs spécifie si la recherche de sep doit être sensible à la casse.

Si behavior est QString::SkipEmptyParts, le résultat ne contiendra pas les portions vides. Par défaut, les portions vides sont incluses.

Exemple :

QString str = "a,,b,c";
 
QStringList list1 = str.split(",");
// list1: [ "a", "", "b", "c" ]
 
QStringList list2 = str.split(",", QString::SkipEmptyParts);
// list2: [ "a", "b", "c" ]

Voir aussi QStringList::join() et section().

QStringList QString::split ( const QChar & sep, SplitBehavior behavior = KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const

Il s'agit d'une fonction surchargée.

QStringList QString::split ( const QRegExp & rx, SplitBehavior behavior = KeepEmptyParts ) const

Il s'agit d'une fonction surchargée.

Découpe la chaîne en sous-chaînes à chaque correspondance de l'expression régulière rx et renvoie la liste de ces chaînes. Si rx n'a aucune correspondance dans la chaîne, split() renvoie une liste contenant cette chaîne comme seul élément.

Voici un exemple dans lequel nous extrayons les mots d'une phrase en utilisant un ou plusieurs blancs comme séparateur :

QString str;
QStringList list;
 
str = "Un  texte\n\tavec  des blancs étranges.";
list = str.split(QRegExp("\\s+"));
// list: [ "Un", "texte", "avec", "des", "blancs", "étranges." ]

Voici un exemple similaire mais qui utilise n'importe quelle séquence de caractères non-mot comme séparateur :

str = "Cette fois, une phrase normale.";
list = str.split(QRegExp("\\W+"), QString::SkipEmptyParts);
// list: [ "Cette", "fois", "une", "phrase", "normale" ]

Voici un troisième exemple où nous utilisons une assertion de longueur zéro, \b (frontière de mot), pour découper la chaîne en séquence alternant les mots et les non-mots :

str = "Maintenant: ce petit fragment.";
list = str.split(QRegExp("\\b"));
// list: [ "", "Maintenant", ": ", "ce", " ", "petit", " ", "fragment", "." ]

Voir aussi QStringList::join() et section().

QString & QString::sprintf ( const char * cformat, ... )

Construction sécurisée d'une chaîne formatée à partir la chaîne de formatage cformat et d'une liste arbitraire d'arguments.

La séquence d'échappement %lc attend un caractère Unicode de type ushort (comme celui renvoyé par QChar::unicode()). La séquence d'échappement %ls attend un pointeur vers un tableau terminé par un zéro de caractère Unicode de type ushort (comme celui renvoyé par QString::utf16()).

Note : Cette fonction attend une chaîne UTF-8 pour %s et Latin-1 pour la chaîne de formatage.

La chaîne de formatage autorise la plupart des spécificateurs de conversion du printf() de la bibliothèque standard C++. Il ne respecte pas les modificateurs de longueur (comme h pour short ou ll pour long long). Si vous en avez besoin, utilisez la fonction standard snprintf() à la place :

size_t BufSize;
char buf[BufSize];
 
::snprintf(buf, BufSize, "%lld", 123456789LL);
QString str = QString::fromAscii(buf);

Attention : nous ne recommandons pas l'usage de QString::sprintf() dans du nouveau code Qt. Envisagez plutôt d'utiliser QTextStream ou arg(), qui gèrent tous les deux les chaînes Unicode de façon transparente et qui vérifient les types. Voici un exemple d'utilisation de QTextStream :

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

Pour les traductions, en particulier si les chaînes contiennent plus d'une séquence d'échappement, vous devriez plutôt envisager d'utiliser la fonction arg(). Elle permet au traducteur de contrôler l'ordre de remplacement.

Voir aussi arg().

void QString::squeeze ()

Libère l'espace mémoire qui n'est pas requis pour stocker les données.

Le seul intérêt de cette fonction est de donner un moyen de gérer finement l'utilisation de la mémoire par QString. En général, vous aurez rarement besoin de l'appeler.

Voir aussi reserve() et capacity().

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

Renvoie true si la chaîne commence par s ; sinon renvoie false.

Si cs est Qt::CaseSensitive, la comparaison est sensible à la casse ; sinon elle est insensible à la casse.

QString str = "Bananes";
str.startsWith("Ban");     // renvoie true
str.startsWith("Car");     // renvoie false

Voir aussi endsWith().

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

Cette fonction surcharge startsWith().

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

Cette fonction surcharge startsWith().

Renvoie true si la chaîne commence par c ; sinon renvoie false.

QByteArray QString::toAscii () const

Renvoie une représentation an 8 bits de la chaîne dans un QByteArray.

Si un codec a été fixé avec QTextCodec::setCodecForCStrings(), il est utilisé pour convertir d'Unicode vers des caractères 8 bits ; sinon cette fonction fait la même chose que toLatin1().

Notez que, malgré son nom, cette fonction ne renvoie pas forcément une chaîne US-ASCII (ANSI X3.4-1986) et son résultat peut ne pas être compatible avec l'US-ASCII.

Voir aussi fromAscii(), toLatin1(), toUtf8(), toLocal8Bit() et QTextCodec.

QString QString::toCaseFolded () const

Renvoie l'équivalent en casse uniforme de la chaîne. Pour la plupart des caractères Unicode, le traitement est identique à celui de toLower().

double QString::toDouble ( bool * ok = 0 ) const

Renvoie la chaîne convertie en valeur double.

Renvoie 0.0 si la conversion échoue.

Si une erreur de conversion se produit, *ok est fixé à false ; sinon *ok est fixé à true.

QString str = "1234.56";
double val = str.toDouble();   // val == 1234.56

La conversion en double peut se faire pour divers formats de représentation des flottants :

bool ok;
double d;
 
d = QString( "1234.56e-02" ).toDouble(&ok); // ok == true, d == 12.3456

Cette fonction essaie d'interpréter la chaîne en fonction de la localisation courante. La localisation courante est demandée au système au démarrage de l'application et peut être changée en appelant QLocale::setDefault(). Si la chaîne ne peut pas être interprétée en fonction de la localisation courante, la fonction utilise par défaut la localisation « C ».

QLocale::setDefault(QLocale::C);
d = QString( "1234,56" ).toDouble(&ok); // ok == false
d = QString( "1234.56" ).toDouble(&ok); // ok == true, d == 1234.56
 
QLocale::setDefault(QLocale::German);
d = QString( "1234,56" ).toDouble(&ok); // ok == true, d == 1234.56
d = QString( "1234.56" ).toDouble(&ok); // ok == true, d == 1234.56

À cause de l'ambiguïté entre le point décimal et le séparateur de milliers dans plusieurs localisations, cette fonction ne gère pas les séparateurs de milliers. Si vous devez convertir ce type de nombres, utilisez QLocale::toDouble().

QLocale::setDefault(QLocale::C);
d = QString( "1234,56" ).toDouble(&ok); // ok == false

Voir aussi number(), QLocale::setDefault(), QLocale::toDouble() et trimmed().

float QString::toFloat ( bool * ok = 0 ) const

Renvoie la chaîne convertie en une valeur float.

Si une erreur de conversion se produit, *ok est fixé à false ; sinon *ok est fixé à true. Renvoie 0.0 si la conversion échoue.

Exemple :

QString str1 = "1234.56";
str1.toFloat();             // retourne 1234.56
 
bool ok;
QString str2 = "R2D2";
str2.toFloat(&ok);          // retourne 0.0, fixe ok à false

Voir aussi number(), toDouble() et toInt().

int QString::toInt ( bool * ok = 0, int base = 10 ) const

Renvoie la chaîne convertie en int en utilisant la base base, décimale par défaut et qui doit être comprise entre 2 et 36 ou 0. Renvoie 0 si la conversion échoue.

Si une erreur de conversion se produit, *ok est fixé à false ; sinon *ok est fixé à true.

Si base vaut 0, on utilise la convention du langage C : si la chaîne commence par « 0x », on utilise la base 16 ; si la chaîne commence par «   », on utilise la base 8 ; sinon, on utilise la base 10.

Exemple :

QString str = "FF";
bool ok;
int hex = str.toInt(&ok, 16);       // hex == 255, ok == true
int dec = str.toInt(&ok, 10);       // dec == 0, ok == false

Voir aussi number(), toUInt() et toDouble().

QByteArray QString::toLatin1 () const

Renvoie une représentation Latin-1 de la chaîne sous forme d'un QByteArray.

Le tableau d'octets renvoyé est indéfini si la chaîne contient des caractères non Latin-1. Ces caractères peuvent être supprimés ou remplacés par des points d'interrogation.

Voir aussi fromLatin1(), toAscii(), toUtf8(), toLocal8Bit() et QTextCodec.

QByteArray QString::toLocal8Bit () const

Renvoie une représentation en encodage local 8 bits de la chaîne sous forme d'un QByteArray. Le tableau d'octets renvoyé est indéfini si la chaîne contient des caractères non gérés par l'encodage local 8 bits.

QTextCodec::codecForLocale() est utilisé pour effectuer la conversion depuis Unicode. Si l'encodage local ne peut pas être déterminé, cette fonction fait le même traitement que toLatin1().

Si la chaîne contient des caractères ne pouvant pas être encodés par l'encodage local, le tableau d'octets renvoyé est indéfini. Ces caractères peuvent être supprimés ou remplacés par d'autres.

Voir aussi fromLocal8Bit(), toAscii(), toLatin1(), toUtf8() et QTextCodec.

long QString::toLong ( bool * ok = 0, int base = 10 ) const

Renvoie la chaîne convertie en long en utilisant la base base, décimale par défaut et qui doit être comprise entre 2 et 36 ou 0. Renvoie 0 si la conversion échoue.

Si une erreur de conversion se produit, *ok est fixé à false ; sinon *ok est fixé à true.

Si base vaut 0, on utilise la convention du langage C : si la chaîne commence par « 0x », on utilise la base 16 ; si la chaîne commence par «   », on utilise la base 8 ; sinon, on utilise la base 10.

Exemple :

QString str = "FF";
bool ok;
 
long hex = str.toLong(&ok, 16);     // hex == 255, ok == true
long dec = str.toLong(&ok, 10);     // dec == 0, ok == false

Voir aussi number(), toULong() et toInt().

qlonglong QString::toLongLong ( bool * ok = 0, int base = 10 ) const

Renvoie la chaîne convertie en long long en utilisant la base base, décimale par défaut et qui doit être comprise entre 2 et 36 ou 0. Renvoie 0 si la conversion échoue.

Si une erreur de conversion se produit, *ok est fixé à false ; sinon *ok est fixé à true.

Si base vaut 0, on utilise la convention du langage C : si la chaîne commence par « 0x », on utilise la base 16 ; si la chaîne commence par «   », on utilise la base 8 ; sinon, on utilise la base 10.

Exemple :

QString str = "FF";
bool ok;
 
qint64 hex = str.toLongLong(&ok, 16);      // hex == 255, ok == true
qint64 dec = str.toLongLong(&ok, 10);      // dec == 0, ok == false

Voir aussi number(), toULongLong() et toInt().

QString QString::toLower () const

Renvoie une copie de la chaîne en minuscules.

QString str = "Qt by NOKIA";
str = str.toLower();        // str == "qt by nokia"

Voir aussi toUpper().

short QString::toShort ( bool * ok = 0, int base = 10 ) const

Renvoie la chaîne convertie en short en utilisant la base base, décimale par défaut et qui doit être comprise entre 2 et 36 ou 0. Renvoie 0 si la conversion échoue.

Si une erreur de conversion se produit, *ok est fixé à false ; sinon *ok est fixé à true.

Si base vaut 0, on utilise la convention du langage C : si la chaîne commence par « 0x », on utilise la base 16 ; si la chaîne commence par «   », on utilise la base 8 ; sinon, on utilise la base 10.

Exemple :

QString str = "FF";
bool ok;
 
short hex = str.toShort(&ok, 16);   // hex == 255, ok == true
short dec = str.toShort(&ok, 10);   // dec == 0, ok == false

Voir aussi number(), toUShort() et toInt().

std::string QString::toStdString () const

Renvoie un objet std::string avec les données contenues dans cette QString. Les données Unicode sont converties en caractères 8 bits en utilisant la fonction toAscii().

Cet opérateur est utile pour passer une QString à une fonction acceptant un objet std::string.

Si la QString contient des caractères Unicode que le codec QTextCodec::codecForCStrings() ne gère pas, l'usage de cet opérateur peut conduire à une perte d'informations.

Cet opérateur n'est disponible que si Qt est configuré avec la compatibilité STL activée.

Voir aussi toAscii(), toLatin1(), toUtf8() et toLocal8Bit().

std::wstring QString::toStdWString () const

Renvoie un objet std::wstring avec les données contenues dans cette QString. La std::wstring est encodée en UTF 16 sur les plateformes où wchar_t est codé sur deux octets (par exemple Windows) et en UCS 4 sur les plateformes où wchar_t l'est sur quatre octets (la plupart des systèmes Unix).

Cet opérateur est utile pour passer une QString à une fonction acceptant un objet std::wstring.

Cet opérateur n'est disponible que si Qt est configuré avec la compatibilité STL activée.

Voir aussi utf16(), toAscii(), toLatin1(), toUtf8() et toLocal8Bit().

uint QString::toUInt ( bool * ok = 0, int base = 10 ) const

Renvoie la chaîne convertie en unsigned int en utilisant la base base, décimale par défaut et qui doit être comprise entre 2 et 36 ou 0. Renvoie 0 si la conversion échoue.

Si une erreur de conversion se produit, *ok est fixé à false ; sinon *ok est fixé à true.

Si base vaut 0, on utilise la convention du langage C : si la chaîne commence par « 0x », on utilise la base 16 ; si la chaîne commence par «   », on utilise la base 8 ; sinon, on utilise la base 10.

Exemple :

QString str = "FF";
bool ok;
 
uint hex = str.toUInt(&ok, 16);     // hex == 255, ok == true
uint dec = str.toUInt(&ok, 10);     // dec == 0, ok == false

Voir aussi number() et toInt().

ulong QString::toULong ( bool * ok = 0, int base = 10 ) const

Renvoie la chaîne convertie en unsigned long en utilisant la base base, décimale par défaut et qui doit être comprise entre 2 et 36 ou 0. Renvoie 0 si la conversion échoue.

Si une erreur de conversion se produit, *ok est fixé à false ; sinon *ok est fixé à true.

Si base vaut 0, on utilise la convention du langage C : si la chaîne commence par « 0x », on utilise la base 16 ; si la chaîne commence par «   », on utilise la base 8 ; sinon, on utilise la base 10.

Exemple :

QString str = "FF";
bool ok;
 
ulong hex = str.toULong(&ok, 16);   // hex == 255, ok == true
ulong dec = str.toULong(&ok, 10);   // dec == 0, ok == false

Voir aussi number().

qulonglong QString::toULongLong ( bool * ok = 0, int base = 10 ) const

Renvoie la chaîne convertie en unsigned long long en utilisant la base base, décimale par défaut et qui doit être comprise entre 2 et 36 ou 0. Renvoie 0 si la conversion échoue.

Si une erreur de conversion se produit, *ok est fixé à false ; sinon *ok est fixé à true.

Si base vaut 0, on utilise la convention du langage C : si la chaîne commence par « 0x », on utilise la base 16 ; si la chaîne commence par «   », on utilise la base 8 ; sinon, on utilise la base 10.

Exemple :

QString str = "FF";
bool ok;
 
quint64 hex = str.toULongLong(&ok, 16);    // hex == 255, ok == true
quint64 dec = str.toULongLong(&ok, 10);    // dec == 0, ok == false

Voir aussi number() et toLongLong().

ushort QString::toUShort ( bool * ok = 0, int base = 10 ) const

Renvoie la chaîne convertie en unsigned short en utilisant la base base, décimale par défaut et qui doit être comprise entre 2 et 36 ou 0. Renvoie 0 si la conversion échoue.

Si une erreur de conversion se produit, *ok est fixé à false ; sinon *ok est fixé à true.

Si base vaut 0, on utilise la convention du langage C : si la chaîne commence par « 0x », on utilise la base 16 ; si la chaîne commence par «   », on utilise la base 8 ; sinon, on utilise la base 10.

Exemple :

QString str = "FF";
bool ok;
 
ushort hex = str.toUShort(&ok, 16);     // hex == 255, ok == true
ushort dec = str.toUShort(&ok, 10);     // dec == 0, ok == false

Voir aussi number() et toShort().

QVector<uint> QString::toUcs4 () const

Retourne une représentation UCS-4/UTF-32 de la chaîne en tant que QVector<uint>.

UCS-4 est un codec Unicode sans perte. Tous les caractères de cette chaîne peuvent être encodés en UCS-4. Le vecteur n'est pas terminé par un caractère nul.

Cette fonction a été introduite dans Qt 4.2.

Voir aussi fromUtf8(), toAscii(), toLatin1(), toLocal8Bit(), QTextCodec, fromUcs4() et toWCharArray().

QString QString::toUpper () const

Retourne une copie de la chaîne en majuscule.

QString str = "TeXt";
str = str.toUpper();        // str == "TEXT"

Voir aussi toLower().

QByteArray QString::toUtf8 () const

Retourne une représentation UTF-8 de la chaîne en tant que QByteArray.

UTF-8 est un codec Unicode et peut représenter tous les caractères dans une chaîne Unicode comme QString.

Cependant, dans l'espace Unicode, il y a certains codes qui ne sont pas considérés comme des caractères. Le standard Unicode réserve les deux derniers codes de chaque plan Unicode (U+FFFE, U+FFFF, U+1FFFE, U+1FFFF, U+2FFFE, etc.), ainsi que seize codes dans la plage U+FDD0..U+FDDF, inclus, comme des non-caractères. Si le moindre d'entre eux apparaît dans la chaîne, il n'apparaîtra pas dans la représentation UTF-8 ou pourrait être remplacé par un ou plusieurs caractères de remplacement.

Voir aussi fromUtf8(), toAscii(), toLatin1(), toLocal8Bit() et QTextCodec.

int QString::toWCharArray ( wchar_t * array ) const

Remplit le tableau array avec les données contenues dans cet objet QString. Le tableau est encodé en UTF-16 sur les plateformes où wchar_t a une longueur de deux octets, comme sous Windows, et en UCS-4 sur les plateformes où ce type a une taille de quatre octets (la majorité des systèmes Unix).

array doit être alloué par l'appelant et contenir suffisamment d'espace pour contenir l'entièreté de la chaîne (allouer un tableau de même longueur que la chaîne est toujours suffisant).

Retourne la vraie longueur de la chaîne dans array.

Note : cette fonction ne met pas à la fin du tableau de caractère nul.

Cette fonction a été introduite dans Qt 4.2.

Voir aussi utf16(), toUcs4(), toAscii(), toLatin1(), toUtf8(), toLocal8Bit() et toStdWString().

QString QString::trimmed () const

Retourne une chaîne qui a son espace blanc supprimé au début et à la fin.

L'espace blanc signifie tout caractère pour lequel QChar::isSpace() retourne true. Ceci inclut les caractères ASCII \t, \n, \v, \f, \r et " ".

Exemple :

QString str = "  lots\t of\nwhitespace\r\n ";
str = str.trimmed();
// str == "lots\t of\nwhitespace"

À l'inverse de simplified(), trimmed() laisse les espaces blancs uniques à l'intérieur de la chaîne.

Voir aussi simplified().

void QString::truncate ( int position )

Tronque la chaîne à l'index position.

Si la position spécifiée est au-delà de la fin de la chaîne, rien ne se passe.

Exemple :

QString str = "Vladivostok";
str.truncate(4);
// str == "Vlad"

Si position est négatif, il est équivalent à passer un zéro.

Voir aussi chop(), resize() et left().

const QChar * QString::unicode () const

Retourne une représentation Unicode terminée par le caractère \0 de la chaîne. Le résultat reste valide jusqu'à ce que la chaîne soit changée.

Voir aussi setUnicode() et utf16().

const ushort * QString::utf16 () const

Retourne la QString en tant que tableau terminé par un caractère \0 de réels courts non signés. Le résultat reste valide jusqu'à ce que la chaîne soit changée.

La chaîne retournée est ordonnée en fonction des habitudes de l'hôte.

Voir aussi setUtf16() et unicode().

QString & QString::vsprintf ( const char * cformat, va_list ap )

Méthode équivalente à sprintf() mais prend une va_list au lieu d'une liste d'arguments variables. Voir la documentation de sprintf() pour une explication de cformat.

Cette méthode n'appelle pas la macro va_end, l'appelant est responsable d'appeler va_end sur ap.

Voir aussi sprintf().

bool QString::operator!= ( const QString & other ) const

Retourne true si cette chaîne est différente de other ; sinon, retourne false.

La comparaison se base exclusivement sur les valeurs numériques Unicode des caractères et est très rapide, mais ce n'est pas ce qu'un humain attendrait. Préférez le tri pour les chaînes pour l'interface utilisateur avec la fonction localeAwareCompare().

bool QString::operator!= ( const QLatin1String & other ) const

Cette fonction surcharge operator!=().

bool QString::operator!= ( const QByteArray & other ) const

Cette fonction surcharge operator!=().

Le tableau de bits other est converti en QString en utilisant la fonction fromAscii(). Si le moindre caractère NULL (\0) est dans ce tableau, il sera inclus dans la transformation.

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

bool QString::operator!= ( const char * other ) const

Cette fonction surcharge operator!=().

Le pointeur sur caractère constant other est converti en une QString en utilisant la fonction fromAscii()

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

QString & QString::operator+= ( const QString & other )

Ajoute la chaîne other à la fin de cette chaîne et retourne une référence à cette chaîne.

Exemple :

QString x = "free";
QString y = "dom";
x += y;
// x == "freedom"

Cette opération est généralement très rapide (temps constant), parce que QString préalloue de l'espace supplémentaire à la fin de la chaîne pour qu'elle puisse grandir sans devoir réallouer la chaîne en entier à chaque fois.

Voir aussi append() et prepend().

QString & QString::operator+= ( const QLatin1String & str )

Cette fonction surcharge operator+=().

Ajoute la chaîne Latin-1 str à cette chaîne.

QString & QString::operator+= ( const QByteArray & ba )

Cette fonction surcharge operator+=().

Ajoute le tableau de bits ba à cette chaîne. Le tableau de bits est converti en Unicode en utilisant la fonction fromAscii(). Si le moindre caractère NULL (\0) est dans le tableau ba, il sera inclus dans la transformation.

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

QString & QString::operator+= ( const char * str )

Cette fonction surcharge operator+=().

Ajoute la chaîne str à cette chaîne. Le pointeur sur caractère constant est converti en Unicode en utilisant la fonction fromAscii()

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

QString & QString::operator+= ( const QStringRef & str )

Cette fonction surcharge operator+=().

Ajoute la chaîne section referenced by str à cette chaîne.

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

Cette fonction surcharge operator+=().

Ajoute le caractère ch à cette chaîne. Le caractère est converti en Unicode en utilisant la fonction fromAscii()

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

QString & QString::operator+= ( QChar ch )

Cette fonction surcharge operator+=().

Ajoute le caractère ch to the string.

bool QString::operator< ( const QString & other ) const

Retourne true si cette chaîne est lexicalement plus petite que la chaîne other ; sinon, retourne false.

La comparaison se base exclusivement sur les valeurs numériques Unicode des caractères et est très rapide, mais ce n'est pas ce qu'un humain attendrait. Préférez le tri pour les chaînes pour l'interface utilisateur avec la fonction QString::localeAwareCompare().

bool QString::operator< ( const QLatin1String & other ) const

Cette fonction surcharge operator<().

bool QString::operator< ( const QByteArray & other ) const

Cette fonction surcharge operator<().

Le tableau de bits other est converti en QString en utilisant la fonction fromAscii(). Si le moindre caractère NULL (\0) est dans ce tableau, il sera inclus dans la transformation.

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

bool QString::operator< ( const char * other ) const

Cette fonction surcharge operator<().

Le pointeur sur caractère constant other est converti en une QString en utilisant la fonction fromAscii()

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

bool QString::operator<= ( const QString & other ) const

Retourne true si cette chaîne est lexicalement plus petite ou égale à la chaîne other ; sinon, retourne false.

La comparaison se base exclusivement sur les valeurs numériques Unicode des caractères et est très rapide, mais ce n'est pas ce qu'un humain attendrait. Préférez le tri pour les chaînes pour l'interface utilisateur avec la fonction localeAwareCompare().

bool QString::operator<= ( const QLatin1String & other ) const

Cette fonction surcharge operator<=().

bool QString::operator<= ( const QByteArray & other ) const

Cette fonction surcharge operator<=().

Le tableau de bits other est converti en QString en utilisant la fonction fromAscii(). Si le moindre caractère NULL (\0) est dans ce tableau, il sera inclus dans la transformation.

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

bool QString::operator<= ( const char * other ) const

Cette fonction surcharge operator<=().

Le pointeur sur caractère constant other est converti en une QString en utilisant la fonction fromAscii()

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

QString & QString::operator= ( const QString & other )

Assigne other à cette chaîne et retourne une référence sur cette chaîne.

QString & QString::operator= ( const QLatin1String & str )

Cette fonction surcharge operator=().

Assigne la chaîne Latin-1 str à cette chaîne.

QString & QString::operator= ( const QByteArray & ba )

Cette fonction surcharge operator=().

Assigne ba à cette chaîne. Le tableau de bits est converti en Unicode en utilisant la fonction fromAscii(). Cette fonction arrête la conversion au premier caractère NULL trouvé ou à la fin du tableau ba.

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

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

Cette fonction surcharge operator=().

Assigne str à cette chaîne. Le pointeur sur caractère constant est converti en Unicode en utilisant la fonction fromAscii().

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

QString & QString::operator= ( char ch )

Cette fonction surcharge operator=().

Assigne le caractère ch à cette chaîne. Il est converti en Unicode en utilisation la fonction fromAscii().

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

QString & QString::operator= ( QChar ch )

Cette fonction surcharge operator=().

Définit la chaîne comme ne contenant que le seul caractère ch.

bool QString::operator== ( const QString & other ) const

Retourne true si la chaîne other est égale à celle-ci ; sinon, retourne false.

La comparaison se base exclusivement sur les valeurs numériques Unicode des caractères et est très rapide, mais ce n'est pas ce qu'un humain attendrait. Préférez le tri pour les chaînes pour l'interface utilisateur avec la fonction localeAwareCompare().

bool QString::operator== ( const QLatin1String & other ) const

Cette fonction surcharge operator==().

bool QString::operator== ( const QByteArray & other ) const

Cette fonction surcharge operator==().

Le tableau de bits other est converti en QString en utilisant la fonction fromAscii(). Cette fonction arrête la conversion au premier caractère NULL trouvé ou à la fin du tableau de bits.

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

bool QString::operator== ( const char * other ) const

Cette fonction surcharge operator==().

Le pointeur sur caractère constant other est converti en une QString en utilisant la fonction fromAscii()

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

bool QString::operator> ( const QString & other ) const

Retourne true si cette chaîne est lexicalement plus grand que la chaîne other ; sinon, retourne false.

La comparaison se base exclusivement sur les valeurs numériques Unicode des caractères et est très rapide, mais ce n'est pas ce qu'un humain attendrait. Préférez le tri pour les chaînes pour l'interface utilisateur avec la fonction localeAwareCompare().

bool QString::operator> ( const QLatin1String & other ) const

Cette fonction surcharge operator>().

bool QString::operator> ( const QByteArray & other ) const

Cette fonction surcharge operator>().

Le tableau de bits other est converti en QString en utilisant la fonction fromAscii(). Si le moindre caractère NULL (\0) est dans ce tableau, il sera inclus dans la transformation.

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

bool QString::operator> ( const char * other ) const

Cette fonction surcharge operator>().

Le pointeur sur caractère constant other est converti en une QString en utilisant la fonction fromAscii()

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

bool QString::operator>= ( const QString & other ) const

Retourne true si cette chaîne est lexicalement plus grande ou égale à la chaîne other ; sinon retourne false.

La comparaison se base exclusivement sur les valeurs numériques Unicode des caractères et est très rapide, mais ce n'est pas ce qu'un humain attendrait. Préférez le tri pour les chaînes pour l'interface utilisateur avec la fonction localeAwareCompare().

bool QString::operator>= ( const QLatin1String & other ) const

Cette fonction surcharge operator>=().

bool QString::operator>= ( const QByteArray & other ) const

Cette fonction surcharge operator>=().

Le tableau de bits other est converti en QString en utilisant la fonction fromAscii(). Si le moindre caractère NULL (\0) est dans ce tableau, il sera inclus dans la transformation.

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

bool QString::operator>= ( const char * other ) const

Cette fonction surcharge operator>=().

Le pointeur sur un caractère constant other est converti en QString en utilisant la fonction fromAscii().

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII à la compilation de l'application. Ceci peut être utile si vous voulez vous assurer que toutes les chaînes visibles à l'utilisateur passent par QObject::tr(), par exemple.

QCharRef QString::operator[] ( int position )

Retourne le caractère à la position spécifiée dans la chaîne comme une référence modifiable.

Exemple :

QString str;
 
if (str[0] == QChar('?'))
    str[0] = QChar('_');

La valeur de retour est de type QCharRef, une classe d'aide pour QString. Quand vous recevez un objet de type QCharRef, vous pouvez l'utiliser comme si c'était un QChar &. Si vous l'assignez, cette opération sera appliquée sur le caractère dans la QString sur laquelle vous avez une référence.

Voir aussi at().

const QChar QString::operator[] ( int position ) const

Cette fonction surcharge operator[]().

QCharRef QString::operator[] ( uint position )

Cette fonction surcharge operator[]().

Retourne le caractère à la position spécifiée dans la chaîne comme une référence modifiable. Équivalent à at(position).

const QChar QString::operator[] ( uint position ) const

Cette fonction surcharge operator[]().

En relation mais non membres de la classe

bool operator!= ( const char * s1, const QString & s2 )

Retourne true si s1 n'est pas égale à s2 ; sinon, retourne false. Pour s1 non NULL, ceci est équivalent à compare( s1, s2 ) != 0. Notez qu'aucune chaîne n'est égale à s1 si cette dernière est nulle.

Voir aussi QString::compare().

const QString operator+ ( const QString & s1, const QString & s2 )

Retourne une chaîne qui est le résultat de la concaténation de s1 et s2.

const QString operator+ ( const QString & s1, const char * s2 )

Retourne une chaîne qui est le résultat de la concaténation de s1 et s2 (s2 est convertie en Unicode en utilisant la fonction QString::fromAscii()).

Voir aussi QString::fromAscii().

const QString operator+ ( const char * s1, const QString & s2 )

Retourne une chaîne qui est le résultat de la concaténation de s1 et s2 (s1 est convertie en Unicode en utilisant la fonction QString::fromAscii()).

Voir aussi QString::fromAscii().

const QString operator+ ( char ch, const QString & s )

Retourne une chaîne qui est le résultat de la concaténation du caractère ch et de la chaîne s.

const QString operator+ ( const QString & s, char ch )

Retourne une chaîne qui est le résultat de la concaténation de la chaîne s et du caractère ch.

bool operator< ( const char * s1, const QString & s2 )

Retourne true si s1 est lexicalement inférieure à s2 ; sinon, retourne false. Pour s1 non NULL, ceci est équivalent à compare(s1, s2) < 0.

La comparaison se base exclusivement sur les valeurs numériques Unicode des caractères et est très rapide, mais ce n'est pas ce qu'un humain attendrait. Préférez le tri pour les chaînes pour l'interface utilisateur avec la fonction QString::localeAwareCompare().

Voir aussi QString::compare().

QDataStream & operator<< ( QDataStream & stream, const QString & string )

Écrit la chaîne donnée string dans le flux stream.

Voir aussi Sérialiser les types de données Qt.

bool operator<= ( const char * s1, const QString & s2 )

Retourne true si s1 est lexicalement inférieure ou égale à s2 ; sinon, retourne false. Pour s1 non NULL, ceci est équivalent à compare(s1, s2) <= 0.

La comparaison se base exclusivement sur les valeurs numériques Unicode des caractères et est très rapide, mais ce n'est pas ce qu'un humain attendrait. Préférez le tri pour les chaînes pour l'interface utilisateur avec la fonction QString::localeAwareCompare().

Voir aussi QString::compare().

bool operator== ( const char * s1, const QString & s2 )

Cette fonction surcharge operator==().

Retourne true si s1 est égale à s2 ; sinon, retourne false. Notez qu'aucune chaîne n'est égale à s1 si cette dernière est nulle.

Équivalent à s1 != 0 && compare(s1, s2) == 0.

Voir aussi QString::compare().

bool operator> ( const char * s1, const QString & s2 )

Retourne true si s1 est lexicalement plus grande que s2 ; sinon, retourne false. Équivalent à compare(s1, s2) > 0.

La comparaison se base exclusivement sur les valeurs numériques Unicode des caractères et est très rapide, mais ce n'est pas ce qu'un humain attendrait. Préférez le tri pour les chaînes pour l'interface utilisateur avec la fonction QString::localeAwareCompare().

Voir aussi QString::compare().

bool operator>= ( const char * s1, const QString & s2 )

Retourne true si s1 est lexicalement plus grande ou égale à s2 ; sinon, retourne false. Pour s1 non NULL, ceci est équivalent à compare(s1, s2) >= 0.

La comparaison se base exclusivement sur les valeurs numériques Unicode des caractères et est très rapide, mais ce n'est pas ce qu'un humain attendrait. Préférez le tri pour les chaînes pour l'interface utilisateur avec la fonction QString::localeAwareCompare().

QDataStream & operator>> ( QDataStream & stream, QString & string )

Lit une chaîne du flux stream dans la chaîne string.

Voir aussi Sérialisation de types de données Qt.

Documentation des macros

QT_NO_CAST_FROM_ASCII

Désactive les conversions automatiques de chaînes 8 bits (char *) en QString Unicode.

Voir aussi QT_NO_CAST_TO_ASCII et QT_NO_CAST_FROM_BYTEARRAY.

QT_NO_CAST_TO_ASCII

Désactive la conversion automatique de QString en chaînes 8 bits (char *).

Voir aussi QT_NO_CAST_FROM_ASCII et QT_NO_CAST_FROM_BYTEARRAY.

Remerciements

Merci à Abdelhafid Hafidi, Thibaut Cuvelier, Jonathan Courtois et Ilya Diallo pour leur traduction et leur relecture ainsi qu'à Claude Leloup pour sa relecture !

Publicité

Best Of

Actualités les plus lues

Semaine
Mois
Année
  1. « Quelque chose ne va vraiment pas avec les développeurs "modernes" », un développeur à "l'ancienne" critique la multiplication des bibliothèques 54
  2. Les développeurs ignorent-ils trop les failles découvertes dans leur code ? Prenez-vous en compte les remarques des autres ? 17
  3. Apercevoir la troisième dimension ou l'utilisation multithreadée d'OpenGL dans Qt, un article des Qt Quarterly traduit par Guillaume Belz 0
  4. BlackBerry 10 : premières images du prochain OS de RIM qui devrait intégrer des widgets et des tuiles inspirées de Windows Phone 0
  5. Quelles nouveautés de C++11 Visual C++ doit-il rapidement intégrer ? Donnez-nous votre avis 10
  6. Adieu qmake, bienvenue qbs : Qt Building Suite, un outil déclaratif et extensible pour la compilation de projets Qt 17
  7. La rubrique Qt a besoin de vous ! 1
Page suivante

Le Qt Quarterly au hasard

Logo

FAQ sur l'internationalisation

Qt Quarterly est la revue trimestrielle proposée par Nokia et à destination des développeurs Qt. Ces articles d'une grande qualité technique sont rédigés par des experts Qt. Lire l'article.

Communauté

Ressources

Liens utiles

Contact

  • Vous souhaitez rejoindre la rédaction ou proposer un tutoriel, une traduction, une question... ? Postez dans le forum Contribuez ou contactez-nous par MP ou par email (voir en bas de page).

Qt dans le magazine

Cette page est une traduction d'une page de la documentation de Qt, écrite par Nokia Corporation and/or its subsidiary(-ies). Les éventuels problèmes résultant d'une mauvaise traduction ne sont pas imputables à Nokia. Qt 4.7
Copyright © 2012 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon, vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.
Vous avez déniché une erreur ? Un bug ? Une redirection cassée ? Ou tout autre problème, quel qu'il soit ? Ou bien vous désirez participer à ce projet de traduction ? N'hésitez pas à nous contacter ou par MP !
 
 
 
 
Partenaires

Hébergement Web

Responsable bénévole de la rubrique Qt : Thibaut Cuvelier -