Gérer la console avec les classes ioStream en C ++

En informatique, la console est le clavier de l'ordinateur et le moniteur d'ordinateur. Dans le passé, la sortie a été 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 n'utilisent pas le moniteur explicitement. Ces applications utilisent des fenêtres affichées sur le moniteur. Cependant, le programmeur informatique doit encore utiliser l'écran du moniteur. Bien que le programmeur doit encore 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 est appelée l'invite de commande. Dans le système d'exploitation Linux et ses variantes, cette fenêtre est appelée le terminal.

Il est prévu que le lecteur sait déjà utiliser l'invite de commande ou le terminal. Cet article explique comment lire les caractères et les chaînes du clavier et envoyer des caractères et des chaînes au terminal (ou invite de commande). Chaque programmeur C ++ doit savoir dans cet article.

Afin d'avoir une entrée du clavier et de la sortie au terminal, le programme doit commencer:

#inclure
Utilisation de Namespace Std;

Contenu de l'article

• Objets de flux étroit de l'iOStream standard
• Obtenir des caractères et des chaînes du clavier
• Affichage et supprimer des 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 de 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 instanier à nouveau.

couter

L'instruction suivante dans la fonction principale () envoie le texte: «Ceci est la sortie."Au terminal:

couter << "This is output.";

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 redéfinie apparaît à droite de la phrase de sortie. Il ne va pas à la ligne suivante. «Endl» à la fin de l'instruction suivante forcera tout ce qui est imprimé par l'écran à la ligne suivante:

couter << "This is output." << endl;

«Endl» est une variable prédéfinie. Le contenu de l'écran peut également être forcé à la ligne suivante avec:

couter << "This is output." << '\n';

Avec l'utilisation de '\ n', toutes les lignes de texte peuvent ne pas apparaître immédiatement à l'écran. «Endl» rinçait la ligne de texte complète à l'écran.

Remarque: une chaîne envoyée à Cout est en double citation, tandis qu'un personnage envoyé est en citations simples. Une série de chaînes et de caractères peuvent être envoyés dans une déclaration, chacune précédée par << . All that will appear in one line at the output if '\n' is not in the series.

cin

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 principale ():

char txt [50];
couter << "Enter a word and press Enter:" txt;
couter << txt << endl;

La première déclaration 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 à entrer du texte dans la ligne suivante de l'écran. Comme le texte des types d'utilisateurs, le texte entré est repris à 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 entré à la variable, txt. Le texte entré 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 entré à l'écran.

CIN peut prendre plus d'un mot du clavier, séparé par des espaces. Ces mots devront être extraits dans différentes variables. Le segment de code suivant l'illustre:

char txt [20];
int it;
float ft;
couter << "Enter 3 values and press Enter:" txt >> il >> ft;
couter << txt << " << it << " << ft << endl;

Remarque la déclaration:

cin >> txt >> it >> ft;

Le premier mot est extrait sur txt, le côté et le dernier à ft. Si l'entrée était,

un 25 3.6

alors la sortie par le segment de code serait,

un 25 3.6

cerr

Le programme suivant a une erreur:

#inclure
Utilisation de Namespace Std;
int main()

dans Myint;
retour 0;

La première instruction dans main () n'est pas correcte. Si le nom du fichier ayant le code est «Temp.CC "et le fichier exécutable résultant doit être appelé" Temp ", alors la commande G ++ suivante enverra le message d'erreur du compilateur au fichier," Erreur.SMS":

g ++ -o tempor.CC 2> Erreur.SMS

Si le fichier «Erreur.txt »n'existe pas, il serait créé. Notez la partie «2> Erreur.txt ”de la commande g ++.

L'écran est la destination de sortie standard, et c'est aussi la destination d'erreur standard. Si «2> Erreur.txt ”est omis de la commande g ++, puis le message d'erreur du compilateur serait envoyé à la destination d'erreur standard, qui est toujours l'écran (moniteur).

L'objet Stream qui représente la destination de sortie standard est cout. L'objet Stream 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 << "The error message!" << '\n';

sabot

Une application prend différentes entrées à différents moments. Toutes les entrées peuvent être rediffurées à l'écran. Toutes les entrées peuvent être enregistrées dans un fichier. C'est une journalisation. La destination de journalisation standard est l'écran. L'objet de flux de journalisation standard est un sabot. Le code suivant redirera le texte d'entrée à l'écran:

char txt [50];
couter<<"Enter text and press Enter:"txt;
sabot<

Si le texte d'entrée est "Input_text", alors Clog redéfinirait "Input_text" à l'écran.

En pratique, l'exploitation forestière est généralement redirigée vers un fichier. Le programme suivant illustre ceci:

#inclure
Utilisation de Namespace Std;
int main()

freopen ("journal.txt "," w ", stdout);
couter << "input_text" << endl;

Notez l'utilisation de la fonction, Freopen () et ses arguments. Son premier argument est le nom du fichier journal. Si le fichier n'existe pas, il serait créé. Son deuxième argument est "w" pour "écrire". Son troisième argument est stdout pour standard-sorti. La deuxième instruction de la fonction Main () utilise COUT pour envoyer le texte de l'exploitation de journalisation dans le fichier. Remarque: le code d'entrée réel n'a pas été affiché dans ce programme.

Obtenir des caractères et des chaînes du clavier

Pendant que l'utilisateur tape d'entrée, les caractères sont envoyés au tampon de 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; De plus, le curseur va au début de la ligne suivante ci-dessous, à l'écran. Le programme continue ensuite vers la prochaine déclaration du programme, après la déclaration de lecture des entrées.

L'objet Cin a des méthodes, ce qui concerne cette section.

Lire le premier personnage

get (char_type & c):
Le segment de code suivant montre comment lire le premier caractère, à partir du tampon de flux d'entrée:

Char Ch;
couter << "Input text:" << endl;
cin.obtenir (ch);
couter << ch << endl;

La première déclaration déclare un personnage sans affectation. La deuxième instruction indique à l'utilisateur de saisir un caractère. Lorsque l'utilisateur tape dans le caractère et appuie sur la touche Entrée, la troisième instruction copie le caractère du tampon de 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.

obtenir():
get () sans argument, renvoie le code ASCII décimal. Considérez le segment de code suivant:

couter << "Input text:" << endl;
couter << cin.get() << endl;

Si l'entrée est "Asdfg", alors 97 serait 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 à partir de la première, peuvent être extraits du tampon CIN Stream. Le code suivant peut être utilisé:

Char Str [10];
couter << "Input text:" << endl;
cin.get (str, 10);
couter << str << endl;

Si l'entrée est "des gens formidables", alors la sortie sera "Great PEO", de 9 caractères et non 10. Le caractère Nul Nul (\ 0) prend la dixième position dans l'argument Get. Donc, 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, le numéro de stockage de la chaîne doit être au moins le nombre de caractères typés, plus 1. Ainsi, si 12 caractères sont tapés pour toute la ligne, 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 seul personnage.

get (char_type * s, streamSize n, char_type délire)
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 le streamsize du sous-string, qui vient jamais. Si le texte d'entrée au code suivant est «des gens formidables», alors «Grand» serait extrait:

Char Str [30];
couter << "Input text:" << endl;
cin.get (str, 6, 'o');
couter << str << endl;

La sixième position depuis le début est le caractère de l'espace, et il délimite exclusivement la sous-chaîne extraite. La sixième position vient en premier avant le seul personnage, 'O'. Notez que la taille de stockage pour STR peut être aussi élevée que possible.

Si le texte d'entrée au code suivant est «des gens formidables», alors «GR» serait extrait:

Char Str [30];
couter << "Input text:" << endl;
cin.get (str, 10, 'e');
couter << str << endl;

La première occurrence de «E», vient avant la dixième position.

Obtenir tous les personnages d'une ligne

Après avoir appuyé sur la touche Entrée, tous les caractères tapés dans la ligne peuvent être obtenus comme indiqué dans le code suivant:

couter << "Input text:" << endl;
tandis que (1)
char ch = (char) cin.obtenir();
couter << ch;
if (ch == '\ n')
casser;

La coulée avec (char), convertit chaque nombre décimal en caractère ASCII correspondant.

peek ()

Les fonctions des membres get () ne lisent pas seulement le caractère suivant; ils le retirent du tampon de flux. Cependant, la fonction de membre peek () simple lit le caractère suivant (à partir de la première) sans le retirer du tampon. Dans le code suivant, chaque personnage est d'abord lu avec la fonction peek () avant d'être supprimé, par la fonction get (). Tout cela se passe après que l'utilisateur appuye sur la touche Entrée:

couter << "Input text:" << endl;
tandis que (1)
char ch = (char) cin.peek ();
couter << ch;
cin.obtenir();
if (ch == '\ n')
casser;

Si les caractères suivants n'étaient pas supprimés par get (), peek () ne lirait que le premier caractère, et la boucle itérera indéfiniment.

Affichage et supprimer des 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 les caractères soient affichés tout en étant dactylographiées et effacées avant d'appuyer sur la touche Entrée. Cependant, cela signifie l'interfaçage 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. Donc ce sujet mérite un tutoriel entièrement différent - voir plus tard.

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 '\n' or endl is encountered.

Les expressions qui se traduisent par 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 le texte est envoyé à l'objet COUT, il apparaît normalement à l'écran (moniteur). Cependant, parfois, il peut ne pas apparaître immédiatement. Au texte forcé sur l'écran, insérez la valeur spéciale, «endl», juste après avoir inséré le texte. Cela entraînera un jet de texte à l'écran, et une nouvelle ligne sera ajoutée. Remarque: '\ n' ajoute simplement une nouvelle ligne mais ne rince pas de texte à l'écran.

Le programme suivant montre comment imprimer les valeurs d'int, de flotteur et de texte ordinaire, sur l'écran:

#inclure
Utilisation de Namespace Std;
int main()

int it = 5;
ft ft = 63.5;
couter << "The " << it << " items cost $" << ft << " US." << endl;
retour 0;

La sortie est:

Les 5 articles coûtent 63 $.5 États-Unis.

Le programme suivant montre comment la chaîne d'un objet instanciée à partir d'une classe est imprimée:

#inclure
Utilisation de Namespace Std;
struct st
char str [11] = "quelques mots";
obj;
int main()

couter << obj.str << '\n';
retour 0;

La sortie est "quelques mots".

Arguments pour un programme C ++

L'exécution du programme commence à partir de la fonction principale (). La fonction principale () a en fait deux paramètres facultatifs. La syntaxe de la fonction principale () avec les paramètres facultatifs, est:

int main (int argc, char * argv [argc])

retour 0;

Supposons que le nom du fichier C ++ exécutable est «temp». Supposons que les arguments dont le programme a besoin depuis son environnement (système d'exploitation), tapé par l'utilisateur, est,

Articles 3 Livre stylo "Big House"

Il y a 5 arguments ici: «Articles», «3», «Book», «Pen» et «Big House»

Chacun est du texte. Un argument numéroté à un programme est le texte. En d'autres termes, chaque argument est une chaîne. «Big House» est en citations car c'est une phrase. La commande du terminal pour exécuter ce programme serait:

./ Temp Articles 3 Livre stylo "Big House"

En supposant que la température du fichier est dans le répertoire domestique. Notez que les espaces et non les virgules séparent les arguments.

Maintenant, dans la syntaxe de fonction principale (), Argc est le nombre d'arguments pour le programme, plus 1. Dans ce cas, il y a 5 arguments pour le programme. Donc, Argc a 6. Dans la syntaxe, Argv [Argc] est un éventail de pointeurs vers des cordes. La première valeur de ce tableau à Argv [0] est donnée par le compilateur. C'est un pointeur vers le nom du fichier du programme. Les autres valeurs sont des indications sur les arguments du programme dans l'ordre de l'utilisateur tapé. La taille de ce tableau est Argc. Dans ce cas, la taille est 1 + 5 = 6.

Supposons qu'à la compilation, le programme suivant est nommé Temp:

#inclure
Utilisation de Namespace Std;
int main (int argc, char ** argv)

couter << argv[0] << ", " << argv[1] <<
"," << argv[2] << ", " << argv[3] <<
"," << argv[4] << ", " << argv[5] << endl;
retour 0;

Notez ici que le tableau "char * argv [argc]", a été déclaré "char ** argv".

Si ce programme est exécuté avec la commande Terminal,

./ Temp Articles 3 Livre stylo "Big House"

alors la sortie serait:

./ temp, articles, 3, livre, stylo, grande maison

Notez que le chemin du répertoire a été inclus dans le nom du fichier exécutable.

Notez également que lors de l'exécution du programme (appel du programme), la valeur de l'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. Pendant un programme en cours d'exécution, la contribution du programme est différente du moment où le programme doit commencer à fonctionner. Lorsqu'un programme commence à s'exécuter, l'entrée du programme est jointe à la commande pour exécuter le programme, séparée par des espaces.