En informatique, la console est le clavier de l'ordinateur et l'écran de l'ordinateur. Dans le passé, la sortie était envoyée directement à l'écran du moniteur et non à une fenêtre affichée sur le moniteur. Pour l'utilisateur d'ordinateur ordinaire, les applications d'aujourd'hui n'utilisent pas explicitement le moniteur. Ces applications utilisent des fenêtres affichées sur le moniteur. Cependant, le programmeur informatique doit toujours utiliser l'écran du moniteur. Bien que le programmeur ait encore besoin d'utiliser l'écran du moniteur, le système d'exploitation ne lui permet pas de le faire. Le système d'exploitation fournit une fenêtre qui simule l'écran du moniteur. Dans le système d'exploitation Windows, cette fenêtre s'appelle l'invite de commande. Dans le système d'exploitation Linux et ses variantes, cette fenêtre s'appelle le terminal.
Il est prévu que le lecteur sache déjà utiliser l'invite de commande ou le terminal. Cet article explique comment lire des caractères et des chaînes à partir du clavier et envoyer des caractères et des chaînes au terminal (ou à l'invite de commande). Chaque programmeur C++ doit savoir dans cet article.
Afin d'avoir une entrée depuis le clavier et une sortie vers le terminal, le programme doit commencer par :
#comprendre
à l'aide de espace de nomsles heures;
Contenu de l'article
- Objets à flux étroit de l'iostream standard
- Obtention de caractères et de chaînes à partir du clavier
- Affichage et suppression de caractères avant d'appuyer sur Entrée
- Envoi de caractères et de chaînes au moniteur
- Arguments pour un programme C++
- Conclusion
Objets à flux étroit de l'iostream standard
La classe iostream, les objets standard, cout, cin, cerr et clog, ont été instanciés et déjà dans la bibliothèque standard. Le programmeur les utilise simplement sans les instancier à nouveau.
cout
L'instruction suivante dans la fonction main() envoie le texte, Ceci est généré. au terminal :
cout << 'C'est la sortie.';
cout est un objet iostream de sortie dans la bibliothèque standard, déjà instancié.<< is the insertion operator, which sent the bytes, This is output. to the output stream object, cout. When the statement is executed, the text appears on the screen.
Avec l'instruction ci-dessus, l'invite de commande réaffichée apparaît à droite de la phrase de sortie. Il ne passe pas à la ligne suivante. endl à la fin de l'instruction suivante forcera tout ce qui est imprimé par l'écran à la ligne suivante :
cout << 'C'est la sortie.' <<fin;
endl est une variable prédéfinie. Le contenu de l'écran peut également être forcé à la ligne suivante avec :
cout << 'C'est la sortie.' << ' ';Avec l'utilisation de ' ', toutes les lignes de texte peuvent ne pas apparaître immédiatement à l'écran. endl vide toute la ligne de texte à l'écran.
Remarque : une chaîne envoyée à cout est entre guillemets doubles, tandis qu'un caractère envoyé est entre guillemets simples. Une série de chaînes et de caractères peut être envoyée dans une instruction, chacune précédée de<< . All that will appear in one line at the output if ‘ ’ is not in the series.
Gin
cin est l'objet d'entrée iostream standard, déjà instancié et disponible dans la bibliothèque standard. Considérez le segment de code suivant dans la fonction main() :
carboniserSMS[cinquante];cout << « Entrez un mot et appuyez sur Entrée : » SMS;
cout <<SMS<<fin;
La première instruction déclare un tableau vide de 50 caractères. La deuxième instruction demande à l'utilisateur de saisir un mot sur la ligne d'écran suivante et d'appuyer sur la touche Entrée. Notez l'utilisation de 'endl' qui oblige l'utilisateur à saisir du texte dans la ligne suivante de l'écran. Lorsque l'utilisateur tape du texte, le texte saisi est renvoyé à l'écran pendant qu'il entre dans l'objet cin. Après avoir appuyé sur Entrée, la troisième instruction du segment de code est exécutée. Cette troisième instruction envoie le texte saisi à la variable, txt. Le texte saisi ne doit pas dépasser 50 caractères dans ce cas. Notez l'utilisation de l'opérateur d'extraction, >>. La dernière instruction affiche le texte saisi à l'écran.
cin peut prendre plusieurs mots du clavier, séparés par des espaces. Ces mots devront être extraits dans différentes variables. Le segment de code suivant illustre cela :
carboniserSMS[vingt];entierce;
flotterpi;
cout << 'Entrez 3 valeurs et appuyez sur Entrée :' SMS>>ce>>pi;
cout <<SMS<< '' <<ce<< '' <<pi<<fin;
Notez la déclaration :
Gin >>SMS>>ce>>pi;Le premier mot est extrait dans txt, le suivant et le dernier dans ft. Si l'entrée était,
une25 3.6alors la sortie par le segment de code serait,
une25 3.6cerr
Le programme suivant a une erreur :
#comprendreà l'aide de espace de nomsles heures;
entierprincipale()
{
dans monInt;
revenir 0;
}
La première instruction dans main() n'est pas correcte. Si le nom du fichier contenant le code est temp.cc et que le fichier exécutable résultant doit être appelé temp, la commande g++ suivante enverra le message d'erreur du compilateur au fichier error.txt :
g++ -o temp temp.CC 2>Erreur.SMSSi le fichier error.txt n'existe pas, il sera créé. Notez la partie 2>error.txt de la commande g++.
L'écran est la destination de sortie standard, et c'est également la destination d'erreur standard. Si 2>error.txt est omis de la commande g++, alors le message d'erreur du compilateur sera envoyé à la destination d'erreur standard, qui est toujours l'écran (moniteur).
L'objet de flux qui représente la destination de sortie standard est cout. L'objet de flux qui représente la destination d'erreur standard est cerr. Une erreur d'exécution du programme peut être envoyée à l'écran comme suit :
cerr << « Le message d'erreur ! » << ' ';sabot
Une application prend différentes entrées à différents moments. Toutes les entrées peuvent être réaffichées à l'écran. Toutes les entrées peuvent être enregistrées dans un fichier. C'est la journalisation. La destination de journalisation standard est l'écran. L'objet de flux de journalisation standard est un sabot. Le code suivant réaffichera le texte saisi à l'écran :
carboniserSMS[cinquante];cout<<'Entrez du texte et appuyez sur Entrée :'SMS;
sabot<<SMS<<fin;
Si le texte d'entrée est 'input_text', alors clog réaffichera 'input_text' à l'écran.
En pratique, la journalisation est généralement redirigée vers un fichier. Le programme suivant illustre cela :
#comprendreà l'aide de espace de nomsles heures;
entierprincipale()
{
libre( 'log.txt','dans',sortie standard);
cout << 'Texte de saisie' <<fin;
}
Notez l'utilisation de la fonction freopen() et de ses arguments. Son premier argument est le nom du fichier journal. Si le fichier n'existe pas, il sera créé. Son deuxième argument est « w » pour « écrire ». Son troisième argument est stdout pour la sortie standard. La deuxième instruction de la fonction main() utilise cout pour envoyer le texte de journalisation dans le fichier. Remarque : Le code d'entrée réel n'a pas été affiché dans ce programme.
Obtention de caractères et de chaînes à partir du clavier
Pendant que l'utilisateur tape une entrée, les caractères sont envoyés au tampon du flux d'entrée et affichés à l'écran. Lorsque l'utilisateur appuie sur la touche Entrée, tous les caractères sont dans le tampon ; aussi, le curseur va au début de la ligne suivante ci-dessous, à l'écran. Le programme passe ensuite à l'instruction de programme suivante, après l'instruction de lecture d'entrée.
L'objet cin a des méthodes dont cette section s'occupe.
Lecture du premier caractère
get(char_type& c):
Le segment de code suivant montre comment lire le premier caractère, à partir du tampon du flux d'entrée :
cout << 'Texte de saisie:' <<fin;
Gin.avoir(ch);
cout <<ch<<fin;
La première instruction déclare un caractère sans affectation. La deuxième instruction indique à l'utilisateur de saisir un caractère. Lorsque l'utilisateur tape un caractère et appuie sur la touche Entrée, la troisième instruction copie le caractère du tampon du flux d'entrée dans la variable ch.
Même si l'utilisateur tapait plus d'un caractère, le premier caractère serait pris par le segment de code.
avoir():
get() sans argument, renvoie le code ASCII décimal. Considérez le segment de code suivant :
cout << Gin.avoir() <<fin;
Si l'entrée est 'asdfg', alors 97 sera renvoyé, qui est le code ASCII décimal pour 'a'.
get(char_type* s, streamsize n)
Une fois que l'utilisateur a saisi une phrase et appuyé sur la touche Entrée, un certain nombre de caractères commençant par le premier peuvent être extraits du tampon de flux cin. Le code suivant peut être utilisé :
carboniserp[dix];cout << 'Texte de saisie:' <<fin;
Gin.avoir(str,dix);
cout <<p<<fin;
Si l'entrée est « des gens formidables », alors la sortie sera « des gens formidables », de 9 caractères et non de 10. Le caractère NUL de la chaîne ( ) prend la dixième position dans l'argument get. Ainsi, pour avoir 9 caractères dans str, sa taille de stockage doit être d'au moins 10 et l'argument get() doit être 11. Si la ligne d'entrée entière est souhaitée, alors le numéro de stockage de la chaîne doit être au moins le nombre de caractères tapés, plus 1. Donc, si 12 caractères sont tapés pour toute la ligne, alors le nombre doit être 13 pour la taille de stockage de la chaîne (str) et 13 pour l'argument get(). Notez qu'un espace est compté comme un caractère.
get(char_type* s, streamsize n, char_type delim)
Il est possible d'extraire une sous-chaîne, délimitée à droite, par la première occurrence d'un caractère particulier, ou par la taille du flux de la sous-chaîne, selon la première occurrence. Si le texte d'entrée dans le code suivant est une personne formidable, alors la valeur sera extraite :
cout << 'Texte de saisie:' <<fin;
Gin.avoir(str,6,'ou');
cout <<p<<fin;
La sixième position depuis le début est le caractère espace, et il délimite exclusivement la sous-chaîne extraite. La sixième position vient en premier avant le seul caractère, 'o'. Notez que la taille de stockage de str peut être aussi élevée que possible.
Si le texte d'entrée du code suivant est de bonnes personnes, alors gr serait extrait :
carboniserp[30];cout << 'Texte de saisie:' <<fin;
Gin.avoir(str,dix,'Et');
cout <<p<<fin;
La première occurrence de 'e' vient en premier avant la dixième position.
Obtenir tous les caractères d'une ligne
Après avoir appuyé sur la touche Entrée, tous les caractères saisis dans la ligne peuvent être obtenus comme indiqué dans le code suivant :
cout << 'Texte de saisie:' <<fin;tandis que (1) {
carboniserch= (carboniser)Gin.avoir();
cout <<ch;
si (ch== ' ')
Pause;
}
Le casting avec (char), convertit chaque nombre décimal en le caractère ASCII correspondant.
coup d'oeil ()
Les fonctions membres get() ne lisent pas seulement le caractère suivant ; ils le retirent du tampon de flux. Cependant, la fonction membre peek() lit simplement le caractère suivant (en commençant par le premier) sans le supprimer du tampon. Dans le code suivant, chaque caractère est d'abord lu avec la fonction peek() avant d'être supprimé, par la fonction get(). Tout ce qui se passe après que l'utilisateur appuie sur la touche Entrée :
cout << 'Texte de saisie:' <<fin;tandis que (1) {
carboniserch= (carboniser)Gin.coup d'oeil();
cout <<ch;
Gin.avoir();
si (ch== ' ')
Pause;
}
Si les caractères suivants n'étaient pas supprimés par get(), peek() ne lirait que le premier caractère et la boucle serait itérée indéfiniment.
Affichage et suppression de caractères avant d'appuyer sur Entrée
Notez qu'avec l'objet cin, la touche Entrée doit être enfoncée avant qu'il y ait une action. Eh bien, il est possible que des caractères soient affichés pendant la saisie et l'effacement avant d'appuyer sur la touche Entrée. Cependant, cela signifie s'interfacer avec le système d'exploitation. Les systèmes d'exploitation diffèrent. Cela signifie donc un codage différent pour différents systèmes d'exploitation. Ce sujet mérite donc un tout autre tutoriel – voir plus loin.
Envoi de caractères et de chaînes au moniteur
L'objet cout est un objet de flux de sortie, déjà instancié et présent dans la bibliothèque standard C++. cout est l'objet principal utilisé pour envoyer des caractères et des chaînes au moniteur. Cela se fait avec l'opérateur d'insertion,<< . With the cin object, the text is obtained line-by-line. With the cout object, the text is added onto the same line until ‘ ’ or endl is encountered.
Les expressions qui génèrent des scalaires peuvent être des arguments pour l'opérateur d'insertion. L'opérateur convertit le scalaire en texte et place le texte dans le flux d'objet cout. Lorsque du texte est envoyé à l'objet cout, il apparaît normalement à l'écran (moniteur). Cependant, parfois, il peut ne pas apparaître immédiatement. Pour forcer le texte à l'écran, insérez la valeur spéciale, endl, juste après avoir inséré le texte. Cela entraînera le vidage du texte à l'écran et une nouvelle ligne sera ajoutée. Remarque : « » ajoute simplement une nouvelle ligne mais ne vide pas le texte à l'écran.
Le programme suivant montre comment imprimer les valeurs d'int, de float et de texte ordinaire à l'écran :
#comprendreà l'aide de espace de nomsles heures;
entierprincipale()
{
entierce= 5;
flotterpi= 63,5;
cout << 'Les ' <<ce<< ' les articles coûtent $' <<pi<< ' NOUS.' <<fin;
revenir 0;
}
La sortie est :
Les5les articles coûtent $63,5NOUS.Le programme suivant montre comment la chaîne d'un objet instancié à partir d'une classe est imprimée :
#comprendreà l'aide de espace de nomsles heures;
structureSt{
carboniserp[Onze] = 'quelques mots';
}obj;
entierprincipale()
{
cout <<obj.p << ' ';
revenir 0;
}
La sortie est 'quelques mots'.
Arguments pour un programme C++
L'exécution du programme commence à partir de la fonction main(). La fonction main() a en fait deux paramètres facultatifs. La syntaxe de la fonction main() avec les paramètres optionnels, est :
entierprincipale(entierargc,carboniser *argv[argc]){
revenir 0;
}
Supposons que le nom du fichier exécutable C++ est temp. Supposons que les arguments que le programme a besoin de son environnement (système d'exploitation), tapés par l'utilisateur, sont,
des articles3stylo de livre'grande maison'Il y a 5 arguments ici : articles, 3, livre, stylo et grande maison
Chacun est du texte. Un argument numéroté d'un programme est du texte. En d'autres termes, chaque argument est une chaîne. grande maison est entre guillemets parce que c'est une phrase. La commande de terminal pour exécuter ce programme serait :
./articles temporaires3stylo de livre'grande maison'En supposant que le fichier temp se trouve dans le répertoire personnel. Notez que des espaces et non des virgules séparent les arguments.
Maintenant, dans la syntaxe de la fonction main(), argc est le nombre d'arguments du programme, plus 1. Dans ce cas, il y a 5 arguments pour le programme. Ainsi, argc vaut 6. Dans la syntaxe, argv[argc] est un tableau de pointeurs vers des chaînes. La première valeur de ce tableau à argv[0] est donnée par le compilateur. C'est un pointeur sur le nom du fichier programme. Le reste des valeurs sont des pointeurs vers les arguments du programme dans l'ordre saisi par l'utilisateur. La taille de ce tableau est argc. Dans ce cas, la taille est 1 + 5 = 6.
Supposons qu'à la compilation, le programme suivant s'appelle temp :
#comprendreà l'aide de espace de nomsles heures;
entierprincipale(entierargc,carboniser**argv)
{
cout <<argv[0] << ',' <<argv[1] << ',' <<argv[2] << ',' <<argv[3] << ',' <<argv[4] << ',' <<argv[5] <<fin;
revenir 0;
}
Notez ici que le tableau 'char *argv[argc]' a été déclaré comme 'char** argv'.
Si ce programme est exécuté avec la commande terminal,
./articles temporaires3stylo de livre'grande maison'alors la sortie serait :
./temp, articles,3, livre, stylo, grande maisonNotez que le chemin du répertoire a été inclus avec le nom du fichier exécutable.
Notez également qu'au cours de l'exécution du programme (appel du programme), la valeur de argc n'a pas été envoyée.
Conclusion
La classe iostream a quatre objets importants qui sont cout, cin, cerr et clog. cin est un objet d'entrée, tandis que les autres sont des objets de sortie. Lorsqu'un programme est en cours d'exécution, l'entrée dans le programme est différente du moment où le programme doit commencer à s'exécuter. Lorsqu'un programme démarre, l'entrée du programme est jointe à la commande d'exécution du programme, séparée par des espaces.