Comprendre les séquences d'échappement
Les séquences d'échappement en C++ permettent aux caractères qui exécutent les fonctions de contrôle dans les chaînes de faire partie du texte sans être confondus avec du code. Un piège courant pour les débutants est la confusion liée à l'inclusion de guillemets dans une chaîne littérale. Par exemple, la ligne de code suivante entraînera une erreur de compilation car les guillemets autour de « \t séquence d'échappement » terminent prématurément la chaîne :
chaîne txt = 'Cet article vise à explorer le ' \t séquence d'échappement' à l'aide d'exemples.' ;Pour corriger cela dans un programme C++, nous utiliserons la barre oblique inverse « \ » comme caractère d'échappement pour signaler au compilateur que le caractère suivant a une interprétation particulière. Voici comment procéder :
chaîne txt = 'Cet article vise à explorer le\ » \\ t séquence d'échappement\' à l'aide d'exemples.' ;
Plonger dans le caractère spécial (\t) en C++
La séquence « \t » est plus qu'un simple outil d'espacement. Il représente un caractère de tabulation qui amène le curseur à passer au taquet de tabulation suivant. Ceci est particulièrement pratique pour créer des affichages de texte soigneusement formatés dans les applications de terminal. Au-delà de « \t », C++ prend en charge diverses séquences d'échappement à des fins différentes : par exemple, « \n » crée une nouvelle ligne. Cependant, dans cet article, nous nous concentrerons uniquement sur la séquence d'échappement « \t » en C++ en fournissant des exemples pour démontrer son objectif et son utilisation. Cela vous donnera les connaissances nécessaires pour utiliser efficacement l'onglet horizontal dans vos tâches de programmation. Passons aux exemples pour comprendre le fonctionnement de la séquence d'échappement « \t » dans un programme C++.
Exemple 1:
L'exemple de code C++ suivant inclut un programme simple utilisé pour imprimer le texte sur la console. Référez-vous au code suivant et nous l'expliquerons par la suite :
#include
en utilisant l'espace de noms std ;
int principal ( ) {
cout << 'C'est une première ligne de texte.' << fin ;
cout << 'C'est la deuxième ligne du texte. \t ' ;
cout << 'Cette ligne est suivie d'un \\ t séquence d’échappement. ' ;
retour 0 ;
}
Voici un détail de chaque partie du code :
#include
en utilisant l'espace de noms std ; – Ce code vous permet d'utiliser les noms inclus dans la bibliothèque standard sans les préfixer de « std :: ». Par exemple, vous pouvez écrire « cout » au lieu de « std::cout ».
int main() { - C'est la déclaration et le point d'entrée de la fonction principale pour chaque programme C++. Le « int » avant « main » indique généralement que la fonction renvoie une valeur entière.
cout << « Ceci est la première ligne de texte. »<
cout << 'Ceci est la deuxième ligne de texte.\t'; – Ici, le programme génère une autre chaîne qui est « Ceci est la deuxième ligne de texte.\t ». Notez le « \t » à la fin. Lorsqu'il est imprimé sur la console, il ajoute un espace de tabulation horizontal juste après le texte.
cout << 'Cette ligne est suivie d'une séquence d'échappement \\t.'; – Dans cette ligne, le programme imprime « Cette ligne est suivie d'une séquence d'échappement \t. ». La séquence d'échappement '\\t' est utilisée pour inclure littéralement '\t' dans la sortie puisque la barre oblique inverse '\' est elle-même échappée par une autre barre oblique inverse afin que '\t' lui-même soit imprimé au lieu d'une tabulation horizontale.
renvoie 0 ; – Cela marque la fin de la fonction principale et renvoie zéro, ce qui signifie l'exécution réussie du programme. Lorsque ce programme s'exécute, le résultat ressemble à ceci :
Exemple 2 :
Maintenant, regardons un autre exemple et voyons la magie du caractère d'échappement « \t ». L'exemple est un programme C++ simple qui inclut une bibliothèque de flux d'entrée-sortie standard et utilise l'espace de noms standard. Le programme est conçu pour imprimer un tableau formaté de noms ainsi que la ville et le pays associés sur la console.
#includeen utilisant l'espace de noms std ;
int principal ( ) {
cout << 'Nom \t | \t Ville \t | \t Pays' << fin ;
cout << '-----------------------------------------------' << fin ;
cout << 'Alice \t | \t Pékin \t | \t Chine' << fin ;
cout << 'Bob \t | \t Austin \t | \t Amérique' << fin ;
cout << 'Cathé \t | \t Paris \t | \t France' << fin ;
cout << 'David \t | \t Durban \t | \t Afrique du Sud' << fin ;
cout << '-----------------------------------------------' << fin ;
retour 0 ;
}
Voici une ventilation du code :
Encore, #include
en utilisant l'espace de noms std ; – Il permet d'utiliser les entités de l'espace de noms « std » sans avoir besoin de les préfixer avec « std :: ».
Le int main() { est le point d'entrée de tout programme C++. Lorsque vous exécutez le programme, l'exécution commence à partir d'ici.
Au sein de la fonction principale, nous avons les éléments suivants :
cout << 'Nom\t|\tVille\t|\tPays'<
cout << « ——————————————-«<
Les quatre lignes de cout suivantes impriment chacune une ligne du tableau. Ces lignes suivent le même format avec des tabulations et font partie de la création de la sortie du tableau. Après chaque ligne de données, « endl » est utilisé pour passer à la ligne suivante. La dernière ligne de cout imprime à nouveau la ligne de séparation pour indiquer la fin des données du tableau.
renvoyer 0 ; : – Cette ligne indique l'exécution réussie du programme. Une valeur de retour de 0 indique le succès.
Lorsque ce programme est compilé et exécuté, le résultat apparaîtra sous forme de tableau sur la console avec les noms, villes et pays des individus, soigneusement alignés dans des colonnes séparées par des barres verticales (|) et des onglets. Consultez le résultat suivant :
Note: N'oubliez pas que l'alignement réel du texte dans la console dépend de la largeur des paramètres des onglets dans votre console ou terminal, ce qui peut entraîner des apparences variables des tableaux sur différents systèmes.
Exemple 3 :
Ce programme C++ simple mais intéressant utilise les séquences d'échappement de l'onglet « \t » pour imprimer une forme de losange sur l'écran. Ce code met à l'échelle la taille du diamant en fonction de la variable « diamant » qui spécifie la taille et représente le nombre de lignes depuis le centre du diamant vers son haut ou son bas. Vérifiez le code donné suivant :
#includeen utilisant l'espace de noms std ;
int principal ( ) {
int diamant = 3 ;
pour ( int je = 1 ; je <= diamant ; ++ je ) {
pour ( int j = 0 ; j < diamant - je ; ++ j ) {
cout << ' \t ' ;
}
pour ( int j = 0 ; j < 2 * je - 1 ; ++ j ) {
cout << '* \t ' ; }
cout << fin ;
}
pour ( int je = diamant - 1 ; je >= 1 ; -- je ) {
pour ( int j = 0 ; j < diamant - je ; ++ j ) {
cout << ' \t ' ;
}
pour ( int j = 0 ; j < 2 * je - 1 ; ++ j ) {
cout << '* \t ' ; }
cout << fin ;
}
retour 0 ;
}
Comme vous pouvez le voir, ce programme se compose de deux parties : l'une imprime la moitié supérieure du diamant et l'autre imprime la moitié inférieure. La moitié supérieure du losange est imprimée en produisant d'abord un nombre décroissant de tabulations pour créer le retrait, suivi d'un nombre croissant d'astérisques « * », séparés par des tabulations. Ceci est géré dans la première boucle « for ».
La moitié inférieure est imprimée de la même manière, mais avec les boucles itérant en sens inverse pour diminuer le nombre d'astérisques et augmenter à nouveau le retrait, créant ainsi la moitié inférieure du losange. Ceci est géré dans la deuxième boucle « for ».
Lors de l'exécution du programme avec « diamant = 3 », la sortie ressemble à un diamant centré sur l'écran en raison des caractères de tabulation. Voir le résultat de ce programme particulier :
Veuillez noter que l'apparence réelle peut différer selon la console ou le terminal que vous utilisez, car la largeur des onglets peut varier.
Conclusion
Les séquences d'échappement en C++ sont un outil puissant pour représenter les caractères qui ne sont pas facilement affichables dans une fenêtre de sortie standard. Parmi ces séquences, la tabulation horizontale, notée « \t », est particulièrement utile pour ajouter les espaces horizontaux contrôlés dans le texte. En utilisant « \t », les programmeurs peuvent aligner leur sortie de texte, améliorer la lisibilité et structurer les données de manière systématique. Ce caractère imite l'appui sur la touche « tabulation » d'un clavier, faisant avancer le curseur vers la position de tabulation suivante. Dans cet article, nous avons exploré la fonctionnalité de la séquence d'échappement « \t » dans le langage C++, en mettant en évidence son application avec des exemples simples et pratiques pour illustrer son comportement.