Cin.Ignorer i C ++

For å se bort fra eller fjerne enkelt eller kanskje flere bokstaver fra inngangsbufferen ved hjelp av CIN.Ignorer () -metoden. Kanskje vi må fjerne den uønskede bufferen slik at de neste dataene blir lagret i den tiltenkte beholderen i stedet for den foregående variabelenes hurtigbuffer. For eksempel må vi oppgi en karaktermatrise eller streng etter å ha lagt inn CIN -kommandoen. Som et resultat må vi tømme inngangsbufferen; ellers ville bufferen til den foregående variabelen bli okkupert. Fordi hurtigbufferen til det foregående elementet mangler rom for å beholde ferske data, trykker du på "Enter" -knappen like etter at den første inngangen ignorerer beholderens neste inngang. La oss starte med eksemplene på CIN.Ignorer () -funksjonen med lanseringen av nye C ++ -filer gjennom terminalskallet. Filen må opprettes gjennom berøringsinstruksjonen og filens navn. Ubuntus “Nano” -redaktør har blitt brukt så langt for å åpne filen for å redigere.

Eksempel 01:

Når du bruker Nano -kommandoen, ignorerer du.CC -filen vil bli åpnet i redigereren. Det er på tide å starte vårt første eksempel. For det første vil vi se på C ++ -koden uten å bruke CIN.Ignorer () -funksjonen. Så vi har startet det med to headerbiblioteker, jeg.e., vektor og iostream. Navneområdet brukes etter det. Main () -funksjonen startes med erklæringen om en heltallvariabel “Num” og karaktertype -array “Str” av størrelse 100 som brukes til å lagre noen strengverdi. COUT -setningen ber en bruker om å legge til ett heltall og en strengtypeverdi. CIN -uttalelsen brukes til å sette heltallverdien til variabel "num," og cin.getLine () brukes til å få strengtypeverdiene som er lagt inn av en bruker for å lagre den i “Str” -variabelen opptil 100 tegn. Den neste cout -setningen brukes til å skrive ut heltallet og strengverdien som er lagt inn av brukeren på skallet.

#inkludere
#inkludere
ved hjelp av navneområdet STD;
main ()
int num;
char str [100];
cout << "Please add one Integer and one String value:\n";
cin >> num;
cin.getline (str, 100); // ta en streng
cout << "Number :" << num << ", String: " << Str << endl;

Nå er koden samlet og utført. Brukeren har lagt inn to verdier atskilt med et rom, i.e., heltall og streng. Begge verdiene er skrevet ut som spesifisert.

Ved utførelse av igjen har brukeren lagt 1 verdi og trykket Enter. Utgangen viser en verdi i retur, og strengverdien er tom.

På den tredje utførelsen har en bruker lagt til en strengverdi uten å legge til en heltallverdi. Til gjengjeld viser utgangen 0 -verdien for tall og null for streng.

La oss oppdatere koden ved å legge til “CIN.Ignorer () ”-funksjonen etter CIN -uttalelsen. Det tar to argumenter. Den ene er numeric_limits Stream Size Header for å tømme bufferbufferen etter 1. verdi og en overbevisende ny linje I.e. “\ N”. Så neste variable “STR” vil få verdien etter at brukeren kommer til neste linje.

#inkludere
#inkludere
ved hjelp av navneområdet STD;
main ()
int num;
char str [100];
cout << "Please add one Integer and one String value:\n";
cin >> num; // Fjern buffer før du tar ny linje
cin.Ignorer (numeric_limits:: max (), '\ n');
cin.getline (str, 100); // ta en streng
cout << "Number :" << num << ", String: " << Str << endl;

En bruker har lagt til to verdier med et rom. Etter å ha trykket på Enter har en bruker lagt til en annen verdi. Som et resultat viser utgangen den første heltallverdien og strengverdien til neste linje. Cin.Ignorer () vil ta den første verdien før plassen og den andre verdien fra neste linje etter å ha tømt bufferbufferen. Du kan se, den har ignorert strengverdien "Ignorer" -verdien fra den første inngangslinjen.

Eksempel 02:

Nå har vi sett på et annet eksempel. Noen overskriftsfiler er lagt til før hoved () -funksjonen. Innenfor en funksjon fortsetter mens Loop fortsetter å utføre noen uttalelser. Tre heltallvariabler er erklært, og COUT -uttalelsen ber om å legge til innspill i disse variablene. CIN -setningen lagrer inngangsverdiene til variabler, og "if" -uttalelsen brukes til å sjekke om den første verdien er lik 0 eller ikke. Hvis ja, vil det forlate programmet umiddelbart. Ellers fortsetter programmet. Cin.Ignorer () uttalelse er her for å fjerne hurtigbufferen før neste linje, og COUT -setningen vil vise de innlastede verdiene.

#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()
mens (sant)
int n1, n2, n3;
cout << "Please Type Space-separated 3 Numbers: " << endl;
cin >> n1 >> n2 >> n3;
if (n1 == 0) exit (exit_success);
cin.Ignorer (numeric_limits:: max (), '\ n');
cout <<"1st: "<
return exit_success;

Etter å ha utført dette kodeeksemplet, har brukeren lagt til tre verdier. Den første verdien er ikke 0; Den vil vise 1., 2. og 3. "Mens" -løkken fortsetter igjen, og brukeren legger til 0 som 1. heltallverdi. Til gjengjeld gikk programmet ut uten ytterligere utførelse.

Eksempel 03:

Det siste eksemplet er å ta variabler med to tegn som er input fra brukeren fra brukeren. Mellom begge Cin.Få () Linjer for å ta verdier, vi har brukt CIN.Ignorer () -funksjonen for å fjerne bufferbuffer når du møter plassen. Hvis brukeren legger til noen streng, CIN.get () vil bare ta sin første og cout vil vise den i henhold til koden nedenfor.

#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()
char v1, v2;
cout << "Type Two words: " << endl;
v1 = cin.få();
cin.Ignorer (numeric_limits:: max (), ");
v2 = cin.få();
cout << "Initials of both words are: "<return exit_success;

Etter utførelsen la brukeren til to ord mens COUT -setningen bare viser initialer.

Konklusjon:

Så dette handlet om bruken av CIN.Ignorer () -funksjonen i C ++ for å tømme hurtigbuffere. Vi har brukt plassen og neste linjekarakterer som avgrensere. De implementerte eksemplene er ganske enkle å lære og forstå. Derfor er vi sikre på at du vil ta hjelp fra alle eksempler.