Exempel 1:
Den första koden är här där vi får ett heltalsvärde från användaren. På den första raden inkluderar vi 'iostream'-huvudfilen eftersom vi behöver få ingången och visa utdata här. Deklarationen av funktionerna 'cin' och 'cout' görs i denna rubrikfil. Sedan läggs namnutrymmet 'std' till eftersom det definierar funktioner som 'cin' och 'cout'. Därför, om vi infogar 'namespace std' i början av vår kod, behöver vi inte skriva 'std' med varje funktion.
Sedan anropar vi funktionen 'main()' och deklarerar därefter en variabel av heltalsdatatyp. 'int_value' är variabelns namn som vi deklarerade här. Efter detta använder vi 'cout' som hjälper till att skriva ut givna data på skärmen. Här visar vi ett meddelande till användaren där vi säger 'Ange ett heltal'. Under detta placerar vi 'cin' tillsammans med extraktionssymbolerna '>>' och placerar variabeln 'int_num'.
Nu tar vi användarens input och sparar den här. Vi vill också visa heltalstalet som användaren anger här på skärmen. Så vi använder 'cout' under detta och placerar 'int_value' där.
Kod 1:
#omfatta
använder sig av namnutrymme std ;
int huvud ( ) {
int int_värde ;
cout <> int_värde ;
cout << 'Heltalet är:' << int_värde ;
lämna tillbaka 0 ;
}
Produktion:
När den givna koden exekveras anger vi '89' och den tar '89' som användarens indata. Sedan trycker vi på 'Enter', så att nästa rad visas.
Exempel 2:
Vi måste hämta indata och visa utdata här. Därför inkluderar vi 'iostream'-huvudfilen på den första raden. Denna rubrikfil innehåller deklarationer för funktionerna 'cin' och 'cout'. Därefter läggs namnutrymmet 'std' till. Vi behöver inte skriva 'std' med varje funktion om vi lägger till 'namespace std' i början av vår kod.
Efter anropet till 'main()'-funktionen deklareras en 'float' datatypvariabel. Variabeln som vi deklarerar här kallas 'float_value.' Därefter använder vi 'cout'-funktionen för att rendera den tillhandahållna informationen på terminalen. Här ber vi användaren att ange ett flytnummer genom att visa ett meddelande. Variabeln 'float_num' och extraktionssymbolerna '>>' är placerade under denna tillsammans med 'cin.'
Användarens input samlas och sparas i 'float_num'. Vi använder 'cout'-funktionen en gång till under denna och sätter in 'float_value' eftersom vi också vill se floatnumret som användaren anger på skärmen.
Kod 2:
#includeanvänder sig av namnutrymme std ;
int huvud ( ) {
flyta float_value ;
cout <> float_value ;
cout << 'Flytningsnumret är:' << float_value ;
lämna tillbaka 0 ;
}
Produktion :
När den tidigare nämnda koden körs skriver vi '87.5' från tangentbordet som användarens indata. Nästa rad visar flytvärdet när vi klickar på 'Enter'.
Exempel 3:
Låt oss nu få det 'dubbla' datatypvärdet från användaren. Här initierar vi 'double_value' för 'double' datatypen och placerar sedan meddelandet som vi vill visa användaren. Efter detta använder vi 'cin>>' och placerar variabeln 'double_value' här. Användarens indata sparas i denna 'double_value'-variabel. Vi använder 'cout' igen där vi infogar variabeln 'double_value' för att visa indata som användaren anger som utdata.
Kod 3:
#omfattaanvänder sig av namnutrymme std ;
int huvud ( ) {
dubbel dubbelt_värde ;
cout <> dubbelt_värde ;
cout << 'Det dubbla numret är:' << dubbelt_värde ;
lämna tillbaka 0 ;
}
Produktion :
Här anger vi det dubbla datatypnumret och trycker på 'Enter'. Men här noterar vi att det inte visar hela numret. För att visa det fullständiga 'dubbla' datatypnumret behöver vi bara några tekniker i C++.
Exempel 4:
Här inkluderar vi ytterligare en rubrikfil som är 'bits/stdc++.h' eftersom den innehåller alla önskade funktionsdeklarationer. Här ställer vi in det önskade meddelandet för användaren att se efter att ha initialiserat 'double_d' för 'double' datatypen. Därefter använder vi funktionen 'cin>>' och tilldelar variabeln 'double_d' här. Inmatningen sparas i 'double_d'. För att visa indata som användaren anger här som utdata, anger vi variabeln 'double_d' igen i 'cout'-fältet. Vi inkluderar också funktionen 'setprecision()' där vi lägger till '10' så att den justerar precisionen för det dubbla datatypvärdet och skriver ut det därefter. Precisionen som vi anger här är '10'.
Kod 4:
#omfatta#omfatta
använder sig av namnutrymme std ;
int huvud ( ) {
dubbel d_värde2 ;
cout <> d_värde2 ;
cout << inställningsprecision ( 10 ) << 'Det dubbla numret är:' << d_värde2 ;
lämna tillbaka 0 ;
}
Produktion :
Här samlar den in inmatningen och visar sedan det 'dubbla' värdet enligt samma precision som vi justerade i den givna koden.
Exempel 5:
I den här koden får vi karaktärens input från användaren. Vi initierar en 'char'-variabel 'char1' här och använder sedan 'cout' för att visa meddelandet. Sedan placerar vi 'cin>>' och lägger denna 'char1' där. Så, tecknet som skrivs in av användaren lagras här. Sedan använder vi 'cout' igen för att visa tecknet som är lagrat i variabeln 'char1'.
Kod 5:
#includeanvänder sig av namnutrymme std ;
int huvud ( ) {
röding char1 ;
cout <> char1 ;
cout << 'Tecken är:' << char1 ;
lämna tillbaka 0 ;
}
Produktion :
Efter körning visas detta meddelande. Vi skriver 'z' som teckeninmatning. Sedan, på nästa rad, visas det inmatade tecknet.
Exempel 6:
Vi tar emot stränginmatningen från användaren i denna kod. Här initierar vi 'sträng'-variabeln 'myName' och använder 'cout' för att mata ut meddelandet. Därefter infogar vi 'myName' och 'cin>>' på den platsen. Således sparas strängen som användaren skrev in här. Därefter använder vi kommandot 'cout' igen för att visa strängen som är sparad i variabeln 'myName'.
Kod 6:
#includeanvänder sig av namnutrymme std ;
int huvud ( ) {
sträng mitt Namn ;
cout <> mitt namn ;
cout << 'Mitt namn är: ' << mitt namn ;
lämna tillbaka 0 ;
}
Produktion:
Följande meddelande visas. Vi anger 'Peter'-strängen i inmatningsfältet. Den angivna strängen visas sedan på följande rad:
Exempel 7:
När vi vill ta flera strängar eller en rad som indata måste vi använda funktionen 'getline()'. Vi deklarerar 'strängens namn' här. Sedan skrivs meddelandet som vi anger ut med 'cout'. Vi lägger sedan 'Name' och 'cin' i 'getline()'-funktionen som får flera stränginmatningar från användaren och lagrar dem i 'Name'-variabeln. Detta sparar strängarna som användaren angett. Därefter visar vi strängarna som sparas i variabeln 'Namn' med hjälp av kommandot 'cout'.
Kod 7:
#includeanvänder sig av namnutrymme std ;
int huvud ( ) {
sträng Namn ;
cout << 'Vänligen ange ditt fullständiga namn här: ' ;
getline ( äter , Namn ) ;
cout << 'Ditt fullständiga namn är:' << namn ;
lämna tillbaka 0 ;
}
Produktion:
Här, i det här resultatet, anger vi 'James Samuel' som strängdata. När vi trycker på 'Enter', visar det hela namnet här eftersom vi använde funktionen 'getline()'.
Slutsats
Vi diskuterade om 'C++ användarinmatning' i den här guiden. Vi utforskade detta koncept och lärde oss att kommandot 'cin', tillsammans med extraktionssymbolerna '>>', används för att få användarens input. Vi tog indata för heltals-, float-, double-, char- och strängdatatypvärdena från användaren med hjälp av kommandot 'cin>>' och visade C++-exemplen där konceptet 'användarinmatning' förklaras i detalj .