Cin.Ignorer en C ++

Pour ignorer ou supprimer des lettres simples ou peut-être plus du tampon d'entrée à l'aide du CIN.Méthode ignore (). Peut-être que nous devons supprimer le tampon indésirable afin que les données suivantes soient stockées dans le conteneur prévu plutôt que le cache de la variable précédente. Par exemple, nous devons fournir un tableau ou une chaîne de caractères après avoir saisi la commande CIN. En conséquence, nous devons vider le tampon d'entrée; Sinon, le tampon de la variable précédente serait occupé. Parce que le cache de l'élément précédent n'a pas de place pour conserver de nouvelles données, appuyant sur le bouton "Entrer" juste après l'entrée initiale ignore la prochaine entrée du conteneur. Commençons par les exemples du CIN.Fonction ignore () avec le lancement de nouveaux fichiers C ++ via le shell terminal. Le fichier doit être créé via l'instruction tactile et le nom du fichier. L'éditeur «Nano» d'Ubuntu a été utilisé jusqu'à présent pour ouvrir le fichier pour modifier.

Exemple 01:

En appliquant la commande nano, ignorez.Le fichier CC serait ouvert dans l'éditeur. Il est temps de commencer notre premier exemple. Tout d'abord, nous examinerons le code C ++ sans utiliser le CIN.Fonction ignore (). Donc, nous l'avons commencé avec deux bibliothèques d'en-tête, je.e., vecteur et iostream. L'espace de noms est utilisé après cela. La fonction principale () est démarrée avec la déclaration d'une variable entière «num» et de type de caractère «str» de taille 100 utilisée pour stocker une valeur de chaîne. L'instruction COUT demande à un utilisateur d'ajouter un entier et une valeur de type de chaîne. L'instruction CIN est utilisée pour mettre la valeur entière à la variable «num» et CIN.getLine () est utilisé pour obtenir les valeurs de type de chaîne entrées par un utilisateur pour l'enregistrer dans la variable «Str» jusqu'à 100 caractères. L'instruction COUT suivante est utilisée pour imprimer la valeur entière et la chaîne entrée par l'utilisateur sur le shell.

#inclure
#inclure
Utilisation de Namespace Std;
principal()
int num;
Char Str [100];
couter << "Please add one Integer and one String value:\n";
cin >> num;
cin.getline (str, 100); // prenez une chaîne
couter << "Number :" << num << ", String: " << Str << endl;

Maintenant, le code a été compilé et exécuté. L'utilisateur a entré deux valeurs séparées par un espace, i.e., entier et chaîne. Les deux valeurs ont été imprimées comme spécifié.

Lors de l'exécution à nouveau, l'utilisateur a ajouté 1 valeur et appuyé sur Entrée. La sortie affiche une valeur en retour, et la valeur de la chaîne est vide.

Lors de la troisième exécution, un utilisateur a ajouté une valeur de chaîne sans ajouter de valeur entière. En retour, la sortie affiche la valeur 0 pour le nombre et null pour la chaîne.

Mettons à jour le code en ajoutant le «CIN.Fonction ignore () ”après l'instruction CIN. Il faut deux arguments. L'un est l'en-tête de la taille du flux Numeric_limits pour effacer le cache de tampon après la 1ère valeur et une nouvelle ligne convaincante I.e. "\ N". Ainsi, la variable suivante «Str» obtiendra la valeur après que l'utilisateur sera arrivé à la ligne suivante.

#inclure
#inclure
Utilisation de Namespace Std;
principal()
int num;
Char Str [100];
couter << "Please add one Integer and one String value:\n";
cin >> num; // Effacer le tampon avant de prendre une nouvelle ligne
cin.Ignore (Numeric_limits:: max (), '\ n');
cin.getline (str, 100); // prenez une chaîne
couter << "Number :" << num << ", String: " << Str << endl;

Un utilisateur a ajouté deux valeurs avec un espace. Après avoir appuyé sur Entrée, un utilisateur a ajouté une autre valeur. En conséquence, la sortie affiche la première valeur entière et la valeur ajoutée de la chaîne sur la ligne suivante. Le Cin.Ignore () prendra la première valeur avant l'espace et la deuxième valeur de la ligne suivante après avoir effacé le cache de tampon. Vous pouvez voir, il a ignoré la valeur «ignorer» de la valeur de la chaîne à partir de la première ligne d'entrée.

Exemple 02:

Maintenant, nous avons jeté un coup d'œil à un autre exemple. Certains fichiers d'en-tête ont été ajoutés avant la fonction principale (). Dans une fonction, la boucle while continue d'exécuter certaines instructions. Trois variables entières sont déclarées, et l'instruction COUT demande à ajouter une entrée dans ces variables. L'instruction CIN enregistre les valeurs d'entrée aux variables, et l'instruction «IF» est utilisée pour vérifier si la première valeur est égale à 0 ou non. Si oui, il quittera le programme immédiatement. Sinon, le programme continue. Le Cin.L'instruction ignore () est là pour effacer le cache avant la ligne suivante, et l'instruction COUT affichera les valeurs entrées.

#inclure
#inclure
#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()
while (true)
int n1, n2, n3;
couter << "Please Type Space-separated 3 Numbers: " << endl;
cin >> n1 >> n2 >> n3;
if (n1 == 0) exit (exit_success);
cin.Ignore (Numeric_limits:: max (), '\ n');
couter <<"1st: "<
return exit_success;

Après avoir exécuté cet exemple de code, l'utilisateur a ajouté trois valeurs. La première valeur n'est pas 0; il affichera le 1er, 2e et 3e. La boucle «while» continue à nouveau, et l'utilisateur ajoute 0 comme valeur entière 1er entier. En retour, le programme est sorti sans autre exécution.

Exemple 03:

Le dernier exemple est de prendre des variables de type à deux caractères comme entrée de l'utilisateur. Entre les deux CIN.get () lignes pour prendre des valeurs, nous avons utilisé le CIN.Fonction ignore () pour effacer le cache tampon lors de la rencontre de l'espace. Si l'utilisateur ajoute une chaîne, CIN.get () ne prendra que son initial et le cout l'affichera selon le code ci-dessous.

#inclure
#inclure
#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()
Char V1, v2;
couter << "Type Two words: " << endl;
v1 = cin.obtenir();
cin.Ignore (Numeric_limits:: max (), ");
v2 = cin.obtenir();
couter << "Initials of both words are: "<return exit_success;

Après l'exécution, l'utilisateur a ajouté deux mots tandis que l'instruction COUT affiche uniquement les initiales.

Conclusion:

Donc, il s'agissait de l'utilisation du CIN.Fonction ignore () en C ++ pour effacer les tampons de cache. Nous avons utilisé l'espace et les caractères de ligne suivants comme délimiteurs. Les exemples mis en œuvre sont assez faciles à apprendre et à comprendre. Par conséquent, nous sommes sûrs que vous prenez l'aide de tous les exemples.