Vous êtes sur la page 1sur 9

Centre Informatique pour les Lettres

et les Sciences Humaines


Apprendre C++ avec Qt : Leon 6
Manipuler du texte






1 - Instancier et initialiser ........................................................................................................ 2
2 - Modifier le contenu ............................................................................................................. 2
Insrer ............................................................................................................................2
Effacer.............................................................................................................................3
Remplacer .......................................................................................................................3
3 - Concatner ......................................................................................................................... 3
4 - Copier le contenu................................................................................................................ 4
Copies forant la casse ....................................................................................................4
Copies partielles..............................................................................................................4
Copies "nettoyes" ...........................................................................................................5
5 - Texte et valeurs numriques ............................................................................................... 5
Valeur numrique d'une chane.......................................................................................5
Construire la chane reprsentant une valeur numrique ................................................5
Construire une chane mlant texte ordinaire et reprsentation de valeurs numriques ..6
6 - Obtenir des informations sur le contenu ............................................................................. 6
Longueur de la chane .....................................................................................................7
Comparer deux chanes...................................................................................................7
Recherche de la position d'une sous-chane.....................................................................7
Limiter la recherche................................................................................................7
Ignorer la casse ......................................................................................................7
Compter le nombre d'occurrences d'une sous-chane ......................................................8
Expressions rgulires.....................................................................................................8
Utilisation ..............................................................................................................8
Ignorer la casse ......................................................................................................9
Copier le texte trouv..............................................................................................9
7 - Bon, c'est gentil tout a, mais a fait dj 8 pages. Qu'est-ce que je dois vraiment en
retenir ?............................................................................................................................... 9
Document du 08/01/07 - Retrouvez la version la plus rcente sur http://www.up.univ-mrs.fr/wcpp
C++ - Leon 6 Manipuler du texte 2/9
Nous avons vu que le type entier nomm char est trait d'une faon particulire lorsqu'une
valeur doit tre reprsente l'cran : au lieu de construire la squence de caractres qui
reprsente la valeur dans le systme positionnel dcimal utilisant les chiffres arabes, les
fonctions d'affichage utilisent simplement le caractre correspondant la valeur dans une
table arbitraire (en gnral la table ASCII ou un de ses drivs).

S'il est effectivement possible de reprsenter du texte (c'est dire des squences de
caractres) l'aide de sries d'objets de type char , ce n'est pas trs pratique. La manipulation
de texte tant un besoin trs rpandu, de nombreuses quipes de programmeurs se sont
attaches crer des classes adaptes cet objectif et qui offrent tout la fois scurit,
efficacit et simplicit aux programmeurs qui les utilisent. La librairie Qt propose, sous le
nom de QSt r i ng, une classe de ce genre.
1 - Instancier et initialiser
La classe QSt r i ng n'tant qu'une extension du langage fournie par la librairie Qt, la cration
d'un objet de ce type exige la prsence d'une directive

#i ncl ude " QSt r i ng. h"

La dfinition d'une QSt r i ng peut alors s'accompagner d'une initialisation. La valeur stocker
peut tre fournie soit sous la forme d'un texte littral, soit par une autre QString :

const QSt r i ng codeModul e = " I NF Z13" ; 1
QSt r i ng message = codeModul e; 2

En l'absence d'initialisation explicite, la QSt r i ng cre sera vide.

A la diffrence des types prdfinis, les classes "bien conues" pratiquent, dans la mesure du
possible, une initialisation implicite qui place les instances dans un tat correspondant ce
qu'on peut attendre d'un "nouveau-n" du type concern. Dans le cas de QSt r i ng, c'est une
chane de 0 caractre qui a t choisie comme valeur initiale par dfaut.
2 - Modifier le contenu
Une fois dfinies, les QSt r i ng non constantes se prtent l'affectation de valeurs partir
d'objets de l'un des types utilisables pour l'initialisation ou de valeurs de type char :

message = " Vous avez r ussi ! " ; / / t ext e l i t t r al 3
message = codeModul e; / / aut r e QSt r i ng 4
message = ' W' ; / / char 5

Outre l'oprateur d'affectation, un certain nombre de fonctions membre de la classe QSt r i ng
ont pour effet de modifier le contenu de l'instance au titre de laquelle elles sont invoques.
Insrer
La fonction f i l l ( ) permet de donner une QSt r i ng un contenu compos d'un unique
caractre (indiqu par son premier argument), rpt un certain nombre de fois (indiqu par
son second argument).

QSt r i ng l i gnePoi nt i l l ee; 1
l i gnePoi nt i l l ee. f i l l ( ' - ' , 23) ; 2
/ / l i gnePoi nt i l l ee cont i ent donc " - - - - - - - - - - - - - - - - - - - - - - - "
/ / posi t i ons dans l a cha ne : 0. . . . ' . . . . 1. . . . ' . . . . 2. . . . ' . . . . 3

La fonction i nser t ( ) permet d'injecter du texte dans une QSt r i ng, une position dtermine
par son premier argument, le second indiquant quel est le texte injecter :

QSt r i ng phr ase = " I l t ai t une f oi s une j ol i e pr i ncesse" ; 1
/ / 0. . . . ' . . . . 1. . . . ' . . . . 2. . . . ' . . . . 3. . . . ' . . . . 4
phr ase. i nser t ( 20, " t r s" ) ; 2
/ / phr ase cont i ent donc " I l t ai t une f oi s une t r s j ol i e pr i ncesse"
/ / 0. . . . ' . . . . 1. . . . ' . . . . 2. . . . ' . . . . 3. . . . ' . . . . 4.

En C++, toutes les numrotations commencent zro (et non un).

J-L Pris - 08/01/07
C++ - Leon 6 Manipuler du texte avec Qt 3/9
Effacer
La fonction r emove( ) permet d'liminer certains caractres d'une QSt r i ng. Son premier
paramtre indique la position du premier caractre qui doit disparatre, alors que le second
indique le nombre de caractres qui seront supprims :

QSt r i ng phr ase = " I l t ai t une f oi s une t r s j ol i e pr i ncesse" ; 1
/ / 0. . . . ' . . . . 1. . . . ' . . . . 2. . . . ' . . . . 3. . . . ' . . . . 4.
phr ase. r emove( 21, 5) ; 2
/ / On r evi ent donc " I l t ai t une f oi s une j ol i e pr i ncesse"
/ / 0. . . . ' . . . . 1. . . . ' . . . . 2. . . . ' . . . . 3. . . . ' . . . . 4

La fonction t r uncat e( ) limine de la QSt r i ng au titre de laquelle elle est appele tout
caractre figurant aprs la position indique par son argument.

phr ase. t r uncat e( 16) ; 3
/ / phr ase cont i ent mai nt enant " I l t ai t une f oi s" 4
Remplacer
La fonction r epl ace( ) combine les effets des fonctions r emove( ) et i nser t ( ) : ses deux
premiers arguments indiquent la position et la longueur du segment supprim, alors que le
troisime indique le texte injecter cette mme position :

QSt r i ng phr ase = " I l t ai t une f oi s une j ol i e pr i ncesse" ; 1
/ / 0. . . . ' . . . . 1. . . . ' . . . . 2. . . . ' . . . . 3. . . . ' . . . . 4
phr ase. r epl ace( 21, 5, " af f r euse" ) ; 2
/ / phr ase cont i ent mai nt enant " I l t ai t une f oi s une af f r euse pr i ncesse"
/ / 0. . . . ' . . . . 1. . . . ' . . . . 2. . . . ' . . . . 3. . . . ' . . . . 4

La fonction f i l l ( ) , utilise avec un seul argument, permet de remplacer chacun des
caractres prsents d'une QSt r i ng par un mme caractre (indiqu par son argument).

phr ase. f i l l ( ' x' ) ; 3
/ / phr ase cont i ent mai nt enant " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
/ / 0. . . . ' . . . . 1. . . . ' . . . . 2. . . . ' . . . . 3. . . . ' . . . . 4
3 - Concatner
Le verbe "concatner" est utilis en informatique pour dsigner l'action consistant joindre
bout bout deux fragments de texte pour crer un texte unique
1
. La classe QSt r i ng respecte
la tradition qui veut que cette opration soit symbolise de la mme faon que l'addition :

const QSt r i ng codeModul e = " I NF Z13" ; 1
QSt r i ng message = " Vous avez r ussi " + codeModul e; 2
/ / message cont i ent " Vous avez r ussi I NF Z13" 3

En dpit de sa simplicit, l'oprateur de concatnation appelle deux remarques :

La concatnation n'est possible que si l'un des arguments est de type QSt r i ng.

Les expressions suivantes ne permettent donc pas d'obtenir l'effet escompt :

" I l t ai t " + " une f oi s" ; / / deux cha nes l i t t r al es ne se l ai ssent pas concat ner
" l a l et t r e " + ' x' ; / / une cha ne l i t t r al e et un char non pl us

A la diffrence de l'addition, la concatnation n'est pas commutative.

La squence d'instructions suivante donne donc des contenus diffrents t Un et t Deux :

QSt r i ng depar t = " t ext e" ; 4
QSt r i ng t Un = depar t + ' X' ; / / un cont i ent mai nt enant " t ext eX" 5
QSt r i ng t Deux = ' X' + depar t ; / / deux cont i ent mai nt enant " Xt ext e" 6

1
On pourrait utiliser le verbe "abouter", mais "to concatenate" existe en anglais, et l'emploi de "concatner" diminue
donc l'effort de traduction ncessaire.
J-L Pris - 08/01/07
C++ - Leon 6 Manipuler du texte avec Qt 4/9
4 - Copier le contenu
Lorsqu'un programme dispose d'un texte, il peut avoir besoin d'en recopier des portions
dfinies de diverses faons. La classe QSt r i ng propose un certain nombre de fonctions membre
qui permettent ce genre d'oprations.

Toutes ces fonctions sont sans effet et renvoient la copie demande.

En d'autres termes, les QSt r i ng au titre desquelles elles sont appeles ne sont pas modifies
par leur excution. Pour obtenir un effet sur l'instance utilise pour appeler la fonction, il
faut donc lui affecter la valeur renvoye par cette dernire.
Copies forant la casse
La fonction upper ( ) produit une QSt r i ng qui est une version CAPITALISE de la QSt r i ng au
titre de laquelle elle est appele :

QSt r i ng phr ase = " I l t ai t une f oi s une j ol i e pr i ncesse" ; 1
/ / 0. . . . ' . . . . 1. . . . ' . . . . 2. . . . ' . . . . 3. . . . ' . . . . 4
QSt r i ng capi t al es = phr ase. upper ( ) ; 2
/ / capi t al es cont i ent " I L TAI T UNE FOI S UNE J OLI E PRI NCESSE"

La fonction l ower ( ) produit une QSt r i ng qui est une version d-capitalise de la QSt r i ng au
titre de laquelle elle est appele :

QSt r i ng mi nuscul es = capi t al es. l ower ( ) ; 3
/ / mi nuscul es cont i ent " i l t ai t une f oi s une j ol i e pr i ncesse"

Remarquez que les fonctions upper ( ) et l ower ( ) conservent les accents, ce qui ne produit pas
forcment la capitalisation souhaite par les francophones.
Copies partielles
La fonction l ef t ( ) renvoie une QSt r i ng dont le contenu est identique au dbut de celle au
titre de laquelle elle est invoque. Cette fonction exige un argument, qui lui indique la longueur
de la chane qu'elle doit renvoyer :

QSt r i ng debut = phr ase. l ef t ( 5) ; / / debut cont i ent " I l t " 4

La fonction r i ght ( ) renvoie une QSt r i ng dont le contenu est identique la fin de celle au titre
de laquelle elle est invoque. Cette fonction exige un argument, qui lui indique la longueur de
la chane qu'elle doit renvoyer :

QSt r i ng f i n = phr ase. r i ght ( 6) ; / / f i n cont i ent " ncesse" 5

La fonction mi d( ) renvoie une QSt r i ng dont le contenu est une copie partielle de celle au titre
de laquelle elle est invoque. Cette fonction exige deux arguments, qui lui indiquent quelle
position doit commencer la copie et quelle est la longueur de la chane qu'elle doit renvoyer :

QSt r i ng ext r ai t = phr ase. mi d( 3, 5) ; / / ext r ai t cont i ent " t ai t " 6

Lorsque la copie souhaite ne concerne qu'un unique caractre, il n'est pas ncessaire
d'utiliser la fonction mi d( ) : il suffit d'indiquer entre crochets la position du caractre vis. Il
faut cependant savoir que l'objet ainsi dsign n'est pas de type char , mais de type QChar .

QSt r i ng phr ase = " I l t ai t une f oi s une j ol i e pr i ncesse" ; 7
/ / 0. . . . ' . . . . 1. . . . ' . . . . 2. . . . ' . . . . 3. . . . ' . . . . 4
QChar uneLet t r e = phr ase[ 10] ; / / uneLet t r e cont i ent ' n' 8

Le type char n'offre que 256 valeurs diffrentes, ce qui pose des problmes insurmontables
pour reprsenter, par exemple, un texte comportant des passages en russe (alphabet
cyrillique), d'autres en arabe, et d'autres encore en chinois, en sanscrit et en hiroglyphes
gyptiens, le tout tant accompagn de transcriptions phontiques. Les QSt r i ng n'utilisent
donc pas les char et le code ASCII, mais des QChar et Unicode. En change de cette
puissance, une opration de conversion explicite est exige pour retrouver un char partir
d'une QSt r i ng contenant du texte "ordinaire" (ie. utilisant l'alphabet latin) :

char unChar = phr ase[ 3] . l at i n1( ) ;
J-L Pris - 08/01/07
C++ - Leon 6 Manipuler du texte avec Qt 5/9
Copies "nettoyes"
La fonction st r i pWhi t eSpace( ) limine tous les caractres de type tabulation, espace ou saut
de ligne qui figurent en dbut ou en fin de la QSt r i ng au titre de laquelle elle est appele :

QSt r i ng t ext e = " \ t Osez, osez, J osphi ne. \ n" ; 1
t ext e = t ext e. st r i pWhi t eSpace( ) ; 2
/ / t ext e cont i ent mai nt enant " Osez, osez, J osphi ne. "

La fonction si mpl i f yWhi t eSpace( ) effectue le mme traitement que st r i pWhi t eSpace( ) ,
mais le complte en remplaant par un unique espace toute squence de caractres de type
tabulation, espace ou saut de ligne conscutifs.

QSt r i ng sui t e = " Pl us\ t r i en n' s' oppose\ n l a nui t " ; 1
sui t e = sui t e. si mpl i f yWhi t eSpace( ) ; 2
/ / sui t e cont i ent mai nt enant " Pl us r i en n' s' oppose l a nui t "
5 - Texte et valeurs numriques
Les quantits numriques manipules par l'ordinateur n'tant pas reprsentes par des suites
de caractres, il est frquemment ncessaire de procder des changements de reprsentation
pour assurer la communication entre le programme et les tres humains qui l'utilisent.

Mme s'il "savent" que les ordinateurs ont leur propre faon de reprsenter l'information, les
programmeurs dbutants ont souvent du mal tenir effectivement compte de cette
connaissance lorsqu'ils crivent du code. Les erreurs suivantes sont donc frquentes :

/ / t ext e et val eur s numr i ques : l e bt i si er
i nt val eur = 12;
QSt r i ng t ext e = 12; / / NON : C++ ne gnr e pas spont anment l a cha ne " 12" !
t ext e = " 247" ;
val eur = t ext e; / / NON : C++ ne gnr e pas spont anment l a val eur 247 !
quel queChose = t ext e + val eur ; / / NON : a ne veut r i en di r e

Cette dernire erreur est d'autant plus frquente que le signe +dsigne la fois un oprateur
applicable aux quantits numriques (addition) et un oprateur applicable aux QSt r i ng
(concatnation). Il n'existe cependant aucun oprateur +acceptant que l'un de ses oprandes
soit une valeur numrique et l'autre une chane de caractre ("concadition" ?).
Valeur numrique d'une chane
Lorsqu'une QSt r i ng contient une srie de chiffres, il est facile de dterminer quelle est la
quantit conventionnellement reprsente par cette srie : les fonctions t oShor t ( ) , t oI nt ( ) ,
t oLong( ) , t oFl oat ( ) et t oDoubl e( ) renvoient cette valeur, reprsente dans le type suggr
par leur nom.

QSt r i ng chi f f r es = " 123" ; 1
i nt n = chi f f r es. t oI nt ( ) ; / / n cont i ent mai nt enant 123 2
chi f f r es. r epl ace( 1, 1, " . " ) ; / / chi f f r es cont i ent mai nt enant " 1. 3" 3
doubl e k = chi f f r es. t oDoubl e( ) ; / / k cont i ent mai nt enant 1. 3 4
n = chi f f r es. t oI nt ( ) ; / / n cont i ent mai nt enant 0 5

Remarquez (ligne 5) que, si la squence de caractres n'est pas interprtable dans le type que
doit renvoyer la fonction, celle-ci renvoie 0.
Construire la chane reprsentant une valeur numrique
Pour obtenir la reprsentation d'une quantit numrique sous la forme d'une squence de
caractres (des chiffres), deux mthodes sont disponibles :

- Lorsque la QSt r i ng devant recevoir la reprsentation du nombre existe dj, on peut l'utiliser
pour appeler la fonction set Num( ) . Le contenu antrieur de la QSt r i ng sera alors remplac
par la reprsentation de la valeur transmise set Num( ) , dans le systme de notation
habituel (systme positionnel en base 10 utilisant les chiffres arabes) :

QSt r i ng aAf f i cher ; 1
aAf f i cher . set Num( 8612. 32) ; / / aAf f i cher cont i ent mai nt enant " 8612. 32" 2

J-L Pris - 08/01/07
C++ - Leon 6 Manipuler du texte avec Qt 6/9
- Lorsque aucune variable n'est disponible pour accueillir la chane de chiffres reprsentant le
nombre, la classe QSt r i ng permet d'en gnrer une " la vole", ce qui permet en particulier
d'viter de crer des variables pour de simples lments intermdiaires d'un calcul :

aAf f i cher = aAf f i cher + " pl us " + QSt r i ng: : number ( 27. 19) ; 3
/ / aAf f i cher cont i ent mai nt enant " 8612. 32 pl us 27. 19"

Remarquez que la fonction number ( ) n'est pas appele au titre d'une instance de la classe
QSt r i ng, mais au titre de cette classe elle-mme. Nous tudierons ce type de fonctions dans
une prochaine Leon. Si la classe QSt r i ng n'offrait pas cette possibilit, l'effet de la ligne 3
n'aurait pu tre obtenu qu'au prix de :

QSt r i ng t empor ai r e;
t empor ai r e. set Num( 27. 19) ;
aAf f i cher = aAf f i cher + " pl us " + t empor ai r e;

Que la QSt r i ng vise existe dj ou qu'elle doive tre cre pour l'occasion, un second
argument permet, si la valeur reprsenter est entire, d'utiliser une base autre que 10 :

aAf f i cher . set Num( 1789, 16) ; / / aAf f i cher cont i ent mai nt enant " 6f d" 4
aAf f i cher = aAf f i cher + " et " + QSt r i ng: : number ( 1789, 7) ; 5
/ / aAf f i cher cont i ent mai nt enant " 6f d et 5134"
Construire une chane mlant texte ordinaire et reprsentation de valeurs numriques
Il est, bien entendu, possible de crer ce genre de chanes "composites" en gnrant les chanes
reprsentant les quantits numriques concernes, puis en concatnant les diffrents
fragments. Cette faon de procder doit toutefois tre vite, car elle conduit crire du code
dont la logique dpend troitement de la syntaxe de la langue utilise pour communiquer avec
les utilisateurs du programme. Traduire un tel programme dans une langue diffrente de celle
pour laquelle il a t initialement conu exige donc de modifier le code, ce qui ne peut tre fait
que par un programmeur C++ connaissant la langue en question

La classe QSt r i ng propose une fonction ar g( ) qui produit une copie de l'instance au titre de
laquelle elle est invoque dans laquelle est injecte la reprsentation de la valeur qu'on lui
passe comme argument. Les positions d'insertion doivent tre matrialises dans la chane
cible par des marqueurs composs d'un signe %suivi d'un chiffre. Ces chiffres indiquent dans
quel ordre les positions seront occupes par les valeurs successivement injectes :

QSt r i ng message = " Vous avez gagn %1 bi l l es et %2 bons poi nt s" ; 1
i nt nb = 7; 2
message = message. ar g( nb) ; 3
/ / message cont i ent mai nt enant " Vous avez gagn 7 bi l l es et %2 bons poi nt s"
message = message. ar g( 5) ; 4
/ / message cont i ent mai nt enant " Vous avez gagn 17 bi l l es et 5 bons poi nt s"

L'intrt de cette faon de procder apparat lorsqu'on imagine une modification du message
qui implique une remise en cause de l'ordre des lments. Il suffit, par exemple, de modifier
ainsi le contenu initial de la QSt r i ng :

QSt r i ng message = " %2 bons poi nt s et %1 bi l l es vous avez gagns" ; 5

pour que le code prcdent produise un message semblant venir de matre Yoda : "5 bons
poi nt s et 17 bi l l es vous avez gagns".

Dans un programme rel, les messages ne seront pas spcifis littralement dans le code
source, mais regroups dans un fichier texte lu par le programme. L'utilisation de la fonction
ar g( ) permet donc de changer la langue utilise par le programme en traduisant ce fichier
texte, sans avoir modifier le code source et recompiler. Mieux encore, le programme peut
laisser le choix de la langue en permettant simplement de choisir le fichier utilis.
6 - Obtenir des informations sur le contenu
Un programme est souvent conduit s'interroger sur le contenu d'une QSt r i ng. Cette classe
propose un grand nombre de fonctions membre permettant d'obtenir diverses informations sur
le contenu courant d'une instance.
J-L Pris - 08/01/07
C++ - Leon 6 Manipuler du texte avec Qt 7/9
Longueur de la chane
La fonction i sEmpt y( ) renvoie un boolen indiquant si la chane au titre de laquelle elle est
appele est vide :

i f ( message. i sEmpt y( ) ) 6
message = " message t ai t vi de" ; 7

La fonction l engt h( ) renvoie un entier non-sign qui correspond au nombre de caractres
contenus dans la chane au titre de laquelle elle est appele :

unsi gned i nt nbLet t r es = message. l engt h( ) ; 8

La fonction i sEmpt y( ) n'est donc qu'une faon de vrifier directement si la chane est de
longueur nulle.
Comparer deux chanes
Deux QSt r i ng, ou une QSt r i ng et un texte littral, peuvent tre compars l'aide des
oprateurs habituels. Les comparaisons sont bases sur l'ordre alphabtique, les majuscules
prcdant 'a' et les minuscules accentues venant aprs 'z'.

i f ( message >= " A" && message <= " Z" ) 9
message = " message commence par une maj uscul e non accent ue" ) ; 10
Recherche de la position d'une sous-chane
La fonction f i nd( ) renvoie la position, dans la chane au titre de laquelle elle est appele, de la
premire occurrence du texte qui lui est transmis comme argument :

QSt r i ng phr ase = " I l t ai t une f oi s une j ol i e pr i ncesse" ; 1
/ / 0. . . . ' . . . . 1. . . . ' . . . . 2. . . . ' . . . . 3. . . . ' . . . . 4
i nt posi t i on = phr ase. f i nd( " une" ) ; / / posi t i on cont i ent 9 2

La fonction f i ndRev( ) renvoie la position, dans la chane au titre de laquelle elle est appele,
de la dernire occurrence du texte qui lui est transmis comme argument :

i nt posi t i onR = phr ase. f i ndRev( " une" ) ; / / posi t i onR cont i ent 18 3

Lorsque la sous-chane recherche n'existe pas f i nd( ) et f i ndRev( ) renvoient - 1
Limiter la recherche
La fonction f i nd( ) peut recevoir un deuxime argument, qui lui indique quelle position doit
commencer la recherche :

i nt posi t i on2 = phr ase. f i nd( " une" , 10) ; / / posi t i on2 cont i ent 18 4

Si la recherche commence en position 10, le premier "une" rencontr est celui de "une jolie".

Dans le cas de la fonction f i ndRev( ) , le deuxime argument indique o la recherche doit
s'arrter. La valeur qui doit tre transmise n'est pas une position absolue dans la chane, mais
une position relative, par rapport la fin de la chane :

i nt posi t i onR2 = phr ase. f i ndRev( " une" , - 20) ; / / posi t i onR2 cont i ent 9 5

Si la recherche s'arrte 20 caractres avant la fin de la chane, le dernier "une" trouv est
celui de "une fois".
Ignorer la casse
Les fonctions f i nd( ) et f i ndRev( ) peuvent aussi recevoir f al se comme troisime argument,
pour leur indiquer qu'elles doivent considrer les versions majuscule et minuscule d'un mme
caractre comme tant identiques :

i nt posi t i on3 = phr ase. f i nd( " UNE" , 0, f al se) ; / / posi t i on3 cont i ent 9 6

Du fait des rgles d'utilisation des valeurs par dfaut des paramtres (Leon 5), l'utilisation
du troisime paramtre exige qu'une valeur soit fournie pour le deuxime.

J-L Pris - 08/01/07
C++ - Leon 6 Manipuler du texte avec Qt 8/9
Notez que, comme la capitalisation des QSt r i ng conserve les accents, ignorer la casse ne rend
pas l'accentuation indiffrente
Compter le nombre d'occurrences d'une sous-chane
La fonction cont ai ns( ) renvoie le nombre d'apparitions, dans la chane au titre de laquelle elle
est appele, du texte qui lui est transmis comme argument :

i nt nbOccur r ences = phr ase. cont ai ns( " i " ) ; / / nbOccur r ences cont i ent 4 7

Il tait une fois une jolie princesse

La fonction cont ai ns( ) peut recevoir f al se comme second argument, ce qui lui indique
qu'elle doit procder au dnombrement en ignorant la distinction majuscules/minuscules :

i nt nbOccur r ences2 = phr ase. cont ai ns( " i " , f al se) ; / / nbOccur r ences2 cont i ent 5 8

Il tait une fois une jolie princesse
Expressions rgulires
Les fonctions f i nd( ) , f i ndRev( ) , cont ai ns( ) et r epl ace( ) acceptent galement de recevoir
comme premier argument une instance de la classe QRegExp. Cette classe fonctionne comme
une sorte de classe QSt r i ng pour laquelle certains caractres ou squences de caractres ont
une signification particulire lors des comparaisons avec d'autres chanes :

Signification
exemple
d'expression
exemples de texte
"gaux" l'expression
exemples de texte
"diffrents" de
l'expression
. un caractre quelconque a. b axb axxb
^ dbut de chane ^ab abc xab
$ fin de chane ab$ ab abc
[ ]
tout caractre de l'ensemble dcrit
entre les crochets
[ abc]
a
b
d
- indication d'une plage [ a- z] b A
^ inversion de l'ensemble [ ^def ] k e
*
0 ou plus rptitions du caractre
prcdent
a*b
b
aab
a
+
1 ou plus rptitions du caractre
prcdent
a+b
ab
aaab
a
b
?
0 ou 1 rptition du caractre
prcdent
a?b
b
ab
aab
\ s
sparateur (tabulation, espace,
paragraphe)
a\ sb a b
ab
axb

Utilisation
L'utilisation d'expressions rgulires exige la prsence d'une directive

#i ncl ude " QRegExp. h"

Le passage d'une expression rgulire une fonction membre de la classe QSt r i ng ncessite
une instanciation explicite de la classe QRegEx, car le simple passage d'un texte littral
donnerait lieu la transmission d'une valeur de type QSt r i ng. On crira donc :

QRegExp expr essi on = " e\ \ s" ; / / r echer che l es mot s f i ni ssant par ' e' 9
i nt nbe = phr ase. cont ai ns( expr essi on) ; / / nbe cont i ent 3 10

Il tait une fois une jolie princesse

Remarquez que le symbole '\' possde une signification spciale deux niveaux : dans la
spcification de texte littral en C++, et en tant que caractre d'une expression rgulire. Pour
obtenir sa prsence dans l'expr essi on, il faut le redoubler, faute de quoi la squence \ s
dclenche un message d'erreur de la part du compilateur, qui essaie sans succs de
l'interprter dans le contexte "texte littral".
J-L Pris - 08/01/07
C++ - Leon 6 Manipuler du texte avec Qt 9/9
Ignorer la casse
Si la distinction entre majuscules et minuscules doit tre ignore, c'est l'expression rgulire
qu'il faut le dire, et non la fonction membre de QSt r i ng utilise pour la recherche :

QRegExp expr essi on2( " e\ \ s" , f al se) ; / / l es mot s f i ni ssant par ' e' ou ' E' 11
i nt nbEe = phr ase. cont ai ns( expr essi on2) ; / / nbEe cont i ent 3 12

Si une instance de QRegExp existe dj, on lui ordonnera de ngliger la casse en appelant une
fonction membre de cette classe :

expr essi on. set CaseSensi t i ve( f al se) ;

Avec Qt 2.3, l'option "ignorer la casse" n'est pas applique aux ensembles de caractres, de
sorte que :

QRegExp expr essi on3 ( " [ i y] " , f al se) ;
i nt nbI Y = phr ase. cont ai ns( expr essi on3) ; / / nbI Y cont i ent 4
/ / I l t ai t une f oi s une t r s j ol i e pr i ncesse
Copier le texte trouv
Lorsqu'on utilise les fonctions f i nd( ) et f i ndRev( ) , on obtient la position laquelle elles ont
dcouvert un fragment de texte considr comme "quivalent" l'expression rgulire qu'on
leur a transmise. Si l'on souhaite disposer de ce fragment, il manque cependant une
information capitale : quelle est sa longueur ?

Par nature, les expressions rgulires sont "quivalentes" des fragments de texte qui
peuvent avoir une longueur diffrente de la leur.

Pour obtenir cette information, il ne faut pas effectuer la recherche avec une fonction membre
de QSt r i ng, mais avec une fonction membre de QRegExp nomme mat ch( ) . Outre la QSt r i ng
sur laquelle doit tre effectue la recherche et la position o la recherche doit commencer, cette
fonction peut recevoir comme troisime argument l'adresse d'un i nt , dans lequel elle placera la
longueur du fragment "quivalent" dcouvert :

QSt r i ng phr ase = " I l t ai t une f oi s une j ol i e pr i ncesse" ; 1
/ / 0. . . . ' . . . . 1. . . . ' . . . . 2. . . . ' . . . . 3. . . . ' . . . . 4
QRegExp eReg( " \ \ sj [ ^\ \ s] *e\ \ s" ) ; / / un mot commenant par j et f i ni ssant par e 2
i nt l ongueur ; 3
i nt debut = eReg. mat ch( phr ase, 0, &l ongueur ) ; 4
/ / debut cont i ent mai nt enant 21, et l ongueur 7
QSt r i ng f r agment = phr ase. mi d( debut , l ongueur ) ; 5
/ / f r agment cont i ent mai nt enant " j ol i e "
7 - Bon, c'est gentil tout a, mais a fait dj 8 pages. Qu'est-ce que
je dois vraiment en retenir ?
1) Pour manipuler du texte, on le stocke dans une QSt r i ng.

2) Tout fichier .h ou .cpp qui contient le mot QSt r i ng doit comporter une directive
#i ncl ude " QSt r i ng. h"

3) La classe QSt r i ng a de nombreuses fonctions membre et offre beaucoup de possibilits.

4) Le programme "TesteQString" permet de jouer avec plusieurs de ces fonctions, pour mieux
comprendre comment on les utilise et quel rsultat ou effet elles produisent
2
.

5) A part a, la seule chose ne pas oublier, c'est l'endroit o on peut retrouver le texte de la
Leon 6.

2
Si vous recopiez, dans la zone d'dition prvue cet effet, des expressions rgulires cites dans la Leon 6, veillez
en liminer les redoublements de barres obliques exigs par les rgles C++ concernant le texte littral (le contenu d'une
zone d'dition n'est pas du code C++)
J-L Pris - 08/01/07