Méthodes de garniture de chaîne C ++

Trandre une chaîne signifie enlever les espaces blancs devant et derrière la chaîne. La question suivante est, quels sont les espaces blancs? Ce qui suit est une liste d'espaces blancs dans une chaîne:

• "ou '\ 040': espace en appuyant sur la touche de la barre d'espace
• '\ n': flux de ligne
• '\ r': retour du chariot
• 'F': Formulaire
• '\ t': onglet horizontal
• '\ v': onglet vertical

C ++ n'a pas de fonction pour couper une chaîne. Il y a un sujet dans la programmation informatique appelée expressions régulières, abrégé regex. Ce sujet a des schémas, qui permettent au programmeur de rechercher une sous-chaîne dans une chaîne cible et de remplacer la sous-chaîne trouvée. La sous-chaîne trouvée peut être remplacée par rien, et donc l'effacer.

La recherche et la reprise avec rien ne peut être utilisée pour couper une chaîne. Alors recherchez tous les caractères d'espace blanc devant la chaîne et tous les caractères d'espace blanc derrière la chaîne et remplacez-les par rien. Heureusement, C ++ a une bibliothèque regex, qui doit être incluse dans le programme pour le faire.

Contenu de l'article

• Introduction - Voir ci-dessus
• Résumé des expressions régulières
• Rechercher et remplacer
• Coutume proprement dite
• Conclusion

Résumé des expressions régulières

Expirat
Considérez la chaîne:

"C'est tout pour le spectacle"

Les quatre premiers caractères de cette chaîne forment la sous-chaîne, «ceci». Les quatre derniers caractères de la chaîne forment la dernière sous-chaîne, "Show".

Maintenant, la chaîne entière est appelée chaîne cible ou simplement cible. La sous-chaîne «this» ou «show» est appelée l'expression régulière ou simplement, regex.

Correspondant à
Si «ceci» est recherché et situé dans la cible, la correspondance se serait produite. Si «Show» est recherché et situé, la correspondance se serait toujours produite. La correspondance se produit pour toute chaîne cible lorsqu'une sous-chaîne est trouvée. La sous-chaîne peut être remplacée. Par exemple, «This» peut être remplacé par «ici» et «show» peut être remplacé par «jeu» pour avoir la nouvelle cible,

"Voici pour le jeu"

Si les premiers et derniers mots n'étaient pas du tout recherchés, alors ils pourraient être remplacés par rien, pour avoir,

"Est-ce pour le"

Ce dernier résultat se trouve être une coupe non conventionnelle, qui se termine malheureusement avec un espace au début, et un autre espace à la fin.

Modèle
Un sous-string émoussé («this» ou «show»), comme illustré ci-dessus, est un modèle simple. Considérez la cible suivante:

"Hé, c'est une batte au milieu de la route."

Le programmeur peut vouloir savoir s'il s'agit d'un rat, de chat ou de chauve-souris car ces trois mots sont similaires dans le son. Il a besoin d'un modèle pour identifier le mot «chat» ou «rat» ou «bat». Notez que chacun de ces mots se termine par «AT» mais commence par «B» ou «C» ou «R». Le modèle, pour correspondre à l'un de ces trois mots, est

[bcr] à

Cela signifie, faire correspondre «b» ou «c» ou «r», suivi de «at».

Répétition
x *: signifie faire correspondre 'x' 0 ou plus, je.e., un certain nombre de fois.

Exemples correspondants
Le programme suivant produit une correspondance pour «bat» dans la chaîne cible, en utilisant l'objet regex, reg («[bcr] à»), dont le modèle est [BCR] à.

#inclure
#inclure
Utilisation de Namespace Std;
int main()

regex reg ("[bcr] at");
if (regex_search ("Hé, c'est une batte au milieu de la route.", reg))
couter << "matched" << endl;
autre
couter << "not matched" << endl;
retour 0;

La sortie est: correspondante.

La bibliothèque Regex est incluse avec «#include». L'objet regex est instancié avec l'instruction,

regex reg ("[bcr] at");

[/ cc]

La fonction regex_search () de la bibliothèque prend deux arguments ici. Le premier est la chaîne cible. Le second est l'objet regex. Le modèle, [BCR] à la "bat" correspondant et donc la fonction regex_search () est retourné vrai. Sinon, il serait revenu, faux.

Le programme suivant illustre une correspondance du modèle, bo * k pour «livre»:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

regex reg ("bo * k");
if (regex_search ("le livre est bon.", reg))
couter << "matched" << endl;
autre
couter << "not matched" << endl;
retour 0;

La sortie est: correspondante. o * signifie, assortir «o», zéro ou plus de fois. Il correspondait en fait à «O», deux fois dans «livre».

Début correspondant de la chaîne cible
Pour correspondre au début d'une chaîne cible, le motif a, pour commencer, ^ . Le programme suivant correspond à «This» au début de la chaîne cible, «c'est tout pour le spectacle».

#inclure
#inclure
Utilisation de Namespace Std;
int main()

regex reg ("^ this");
if (regex_search ("Ceci est pour le spectacle", reg))
couter << "matched" << endl;
autre
couter << "not matched" << endl;
retour 0;

La sortie est: correspondante. Remarquez le littéral regex, "^ ceci" .

Fin correspondant de la chaîne cible
Pour correspondre à la fin d'une chaîne cible, le modèle doit se terminer avec $. Le programme suivant correspond à "Show" à la fin de la chaîne cible, "C'est pour le spectacle".

#inclure
#inclure
Utilisation de Namespace Std;
int main()

regex reg ("show $");
if (regex_search ("Ceci est pour le spectacle", reg))
couter << "matched" << endl;
autre
couter << "not matched" << endl;
retour 0;

La sortie est: correspondante. Remarquez le regex littéral, "Show $" .

Alternatives assorties
Pour correspondre à la sous-chaîne débutante ou à la sous-chaîne finale, le | Meta-Character doit séparer les modèles de début et de fin dans le modèle global. Le programme suivant illustre ceci:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

regex reg ("^ this | show $");
if (regex_search ("Ceci est pour le spectacle", reg))
couter << "matched" << endl;
autre
couter << "not matched" << endl;
retour 0;

La sortie est: correspondante. Remarquez le littéral regex, "^ this | show $" .

Maintenant, la fonction regex_search () correspond généralement à l'option du premier modèle et s'arrête. Ce cas correspond à «ceci» au début de la cible et s'arrête sans continuer à correspondre à «Show» à la fin de la cible.

Heureusement, la fonction regex_replace () de la bibliothèque regex C ++ remplace toutes les alternatives n'importe où dans la chaîne cible dans son mode par défaut. Et donc, cette fonction regex_replace () est adaptée aux chaînes de coupe. Autrement dit, recherchez l'espace blanc total devant la chaîne et recherchez l'espace blanc total derrière la chaîne et remplacez les deux par rien.

Rechercher et remplacer

Le programme suivant remplace les premier et dernier mots de la chaîne cible, par le mot, «chien»:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

char str [] = "Ceci est pour le spectacle";
String newstr = regex_replace (str, regex ("^ this | show $"), "dog");
couter << newStr << endl;
retour 0;

La sortie est:

Le chien est pour le chien

Le programme utilise la fonction regex_replace (). Le premier argument est la chaîne cible. Le deuxième argument est l'objet regex. Le troisième argument est le remplacement de la chaîne littérale. La chaîne de retour est l'objet de chaîne modifié. Donc la classe de chaîne a dû être incluse.

Coutume proprement dite

Considérez la chaîne:

"\ t Je veux la démocratie! \ n "

Deux caractères de l'espace blanc, '\ t' et ", sont devant le texte utile. Deux autres caractères de l'espace blanc, "et '\ t', sont derrière le texte utile. La coupe signifie retirer tous les caractères de l'espace blanc devant le texte et retirer tous les caractères de l'espace blanc derrière le texte.

Pour correspondre aux deux premiers caractères ici, le modèle est «\ t | «, C'est-à-dire '\ t' ou un espace. Pour correspondre aux deux derniers caractères ici, le motif est «| \ t», c'est-à-dire un espace ou «\ t». Cependant, le programmeur ne sait généralement pas en quoi consiste un espace blanc particulier. La meilleure chose à faire est donc de rendre compte de toutes les combinaisons possibles pour tous les caractères de l'espace blanc, avec le motif, »| \ t | \ n | \ r | \ v | \ f». Remarque l'utilisation du regex ou de l'opérateur, | .

Il y a encore un problème. Le motif, ”| \ t | \ n | \ r | \ v | \ f” ne correspondrait qu'un seul caractère blanc au début de la chaîne et ne correspondait qu'un seul caractère à espace blanc à la fin de la chaîne. C'est à cause du | les opérateurs. Ainsi, ce modèle doit être modifié pour correspondre à tous les caractères d'espace blanc au début de la chaîne ou à la fin de la chaîne. Donc, tout caractère possible doit être adapté à zéro ou plus de fois de la syntaxe, x * . Et le modèle ultime pour correspondre aux personnages d'espace blanc consécutif est

"[| \ t | \ n | \ r | \ v | \ f] *"

Pour correspondre aux caractères d'espace blanc consécutif au début de la chaîne, utilisez,

"^ [| \ t | \ n | \ r | \ v | \ f] *"

Notez la présence et la position de ^ .

Pour correspondre aux caractères d'espace blanc consécutif à la fin de la chaîne, utilisez,

"[| \ t | \ n | \ r | \ v | \ f] * $"

Notez la présence et la position de $ . Et pour correspondre aux caractères d'espace blanc consécutif au début ou à la fin de la chaîne, utilisez,

"^ [| \ t | \ n | \ r | \ v | \ f] * | [| \ t | \ n | \ r | \ v | \ f] * $"

Notez l'utilisation de | au milieu du modèle global.

Après correspondance, tous les caractères de l'espace blanc sont remplacés par rien, c'est-à-dire «», la chaîne vide. N'oubliez pas que la fonction regex_replace () remplace toutes les occurrences de sous-chaînes correspondantes au modèle partout dans la chaîne cible.

Le programme suivant, coupe la chaîne cible, «\ t Je veux la démocratie! \ n ”à« Je veux la démocratie!»:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

char str [] = "\ t je veux la démocratie! \ n ";
String retstr = regex_replace (str, regex ("^ [| \ t | \ n | \ r | \ v | \ f] * | [| \ t | \ n | \ r | \ v | \ f] * $" ), "");
couter << retStr << endl;
retour 0;

La sortie est:

Je veux la démocratie!

Conclusion

Trandre une chaîne signifie enlever les espaces blancs à l'avant et derrière la chaîne. Un espace blanc se compose de personnages de l'espace blanc. Les caractères d'espace blanc sont ", '\ n', '\ r', 'f', '\ t" \ v'. Pour couper une chaîne en C ++, y compris la bibliothèque regex, et utiliser la fonction regex_replace () pour rechercher et remplacer. Remplacez tout espace blanc au début et / ou à la fin de la chaîne avec la chaîne vide.