דוגמה 1:
הקוד הראשון נמצא כאן בו אנו מקבלים ערך מספר שלם מהמשתמש. בשורה הראשונה, אנו כוללים את קובץ הכותרת 'iostream' מכיוון שאנו צריכים לקבל את הקלט ולהציג את הפלט כאן. ההכרזה על הפונקציות 'cin' ו-'cout' מתבצעת בקובץ הכותרות הזה. לאחר מכן, מרחב השמות 'std' נוסף מכיוון שהוא מגדיר את הפונקציות כמו 'cin' ו-'cout'. לכן, אם נכניס את 'מרחב השמות std' בתחילת הקוד שלנו, לא נצטרך להקליד 'std' עם כל פונקציה.
לאחר מכן, אנו קוראים לפונקציה 'main()' ובהמשך מכריזים על משתנה מסוג נתונים שלם. ה-'int_value' הוא שם המשתנה שהכרזנו כאן. לאחר מכן, אנו משתמשים ב-'cout' המסייע בהדפסת הנתונים הנתונים על המסך. כאן, אנו מציגים הודעה למשתמש בה אנו אומרים, 'הזן מספר שלם'. מתחת לזה, אנו מניחים את 'cin' יחד עם סמלי החילוץ '>>' וממקמים את המשתנה 'int_num'.
כעת, אנו לוקחים את הקלט של המשתמש ונשמור אותו כאן. אנחנו רוצים גם להציג את המספר השלם שהמשתמש מזין כאן על המסך. אז, אנו משתמשים ב-'cout' מתחת לזה וממקמים שם 'int_value'.
קוד 1:
#לִכלוֹל
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
int int_value ;
cout <> int_value ;
cout << 'המספר השלם הוא:' << int_value ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאשר הקוד הנתון מבוצע, אנו מזינים '89' והוא לוקח את '89' כקלט של המשתמש. לאחר מכן, נלחץ על 'Enter', כך שהוא מציג את השורה הבאה.
דוגמה 2:
אנחנו צריכים להשיג את הקלט ולהציג את הפלט כאן. לפיכך, אנו כוללים את קובץ הכותרת 'iostream' בשורה הראשונה. קובץ כותרת זה מכיל הצהרות עבור הפונקציות 'cin' ו-'cout'. לאחר מכן, מתווסף מרחב השמות 'std'. אנחנו לא צריכים להקליד 'std' עם כל פונקציה אם נוסיף 'שם מרחב std' בתחילת הקוד שלנו.
בעקבות הקריאה לפונקציה 'main()', מוצהר משתנה מסוג נתונים 'צף'. המשתנה שאנו מכריזים כאן נקרא 'float_value'. לאחר מכן, אנו משתמשים בפונקציה 'cout' כדי לסייע בעיבוד הנתונים שסופקו על הטרמינל. כאן, אנו אומרים למשתמש להזין מספר צף על ידי הצגת הודעה. המשתנה 'float_num' וסמלי החילוץ '>>' ממוקמים מתחת לזה יחד עם 'cin.'
הקלט של המשתמש נאסף ונשמר ב-'float_num'. אנו משתמשים בפונקציה 'cout' פעם נוספת מתחת לזה ומכניסים את ה- 'float_value' מכיוון שאנו רוצים לראות גם את מספר הצף שהמשתמש מזין על המסך.
קוד 2:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
לָצוּף ערך_צף ;
cout <> ערך_צף ;
cout << 'המספר הצף הוא:' << ערך_צף ;
לַחֲזוֹר 0 ;
}
תְפוּקָה :
כאשר הקוד שהוזכר לעיל פועל, אנו מקלידים '87.5' מהמקלדת כקלט של המשתמש. השורה הבאה מציגה את ערך הצף כאשר אנו לוחצים על 'Enter'.
דוגמה 3:
כעת, בואו נקבל מהמשתמש את ערך סוג הנתונים 'כפול'. כאן, אנו מאתחלים את ה-'double_value' של סוג הנתונים 'double' ואז שמים את ההודעה שברצוננו להציג למשתמש. לאחר מכן, אנו משתמשים ב-'cin>>' וממקמים כאן את המשתנה 'double_value'. הקלט של המשתמש נשמר במשתנה 'double_value' זה. אנו משתמשים שוב ב-'cout' שבו אנו מכניסים את המשתנה 'double_value' כדי להציג את הקלט שהמשתמש מזין כפלט.
קוד 3:
#לִכלוֹלבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
לְהַכפִּיל ערך כפול ;
cout <> ערך כפול ;
cout << 'המספר הכפול הוא:' << ערך כפול ;
לַחֲזוֹר 0 ;
}
תְפוּקָה :
כאן, נזין את מספר סוג הנתונים הכפול ונלחץ על 'Enter'. אבל כאן, נציין שהוא אינו מציג את המספר המלא. כדי להציג את מספר סוג הנתונים ה'כפול' המלא, אנחנו רק צריכים כמה טכניקות ב-C++.
דוגמה 4:
כאן, אנו כוללים עוד קובץ כותרת אחד שהוא 'bits/stdc++.h' מכיוון שהוא מכיל את כל הצהרות הפונקציות הרצויות. כאן, אנו מגדירים את ההודעה הרצויה שהמשתמש יראה לאחר אתחול ה-'double_d' של סוג הנתונים 'כפול'. לאחר מכן, אנו משתמשים בפונקציה 'cin>>' ומקצים כאן את המשתנה 'double_d'. הקלט נשמר ב-'double_d'. כדי להציג את הקלט שהמשתמש מזין כאן בתור הפלט, נזין שוב את המשתנה 'double_d' בשדה 'cout'. אנו כוללים גם את הפונקציה 'setprecision()' בה אנו מוסיפים '10' כך שהיא תתאים את הדיוק של ערך סוג הנתונים הכפול ותדפיס אותו בהתאם. הדיוק שקבענו כאן הוא '10'.
קוד 4:
#לִכלוֹל#לִכלוֹל
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
לְהַכפִּיל d_value2 ;
cout <> d_value2 ;
cout << קבע דיוק ( 10 ) << 'המספר הכפול הוא:' << d_value2 ;
לַחֲזוֹר 0 ;
}
תְפוּקָה :
כאן, הוא אוסף את הקלט ולאחר מכן מציג את הערך 'כפול' לפי אותו דיוק שהתאמנו בקוד הנתון.
דוגמה 5:
בקוד זה, אנו מקבלים את הקלט של הדמות מהמשתמש. אנו מאתחלים משתנה 'char' 'char1' כאן ולאחר מכן משתמשים ב-'cout' כדי להציג את ההודעה. לאחר מכן, אנו מניחים את 'cin>>' ושם את ה-'char1' הזה. אז, התו שהוזן על ידי המשתמש מאוחסן כאן. לאחר מכן, אנו משתמשים שוב ב-'cout' כדי להציג את התו המאוחסן במשתנה 'char1'.
קוד 5:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
לְהַשְׁחִיר char1 ;
cout <> char1 ;
cout << 'הדמות היא:' << char1 ;
לַחֲזוֹר 0 ;
}
תְפוּקָה :
לאחר הביצוע, הודעה זו מוצגת. אנו מקלידים 'z' כקלט התו. לאחר מכן, בשורה הבאה, התו שהוזן מוצג.
דוגמה 6:
אנו מקבלים את קלט המחרוזת מהמשתמש בקוד זה. כאן, אנו מאתחלים את המשתנה 'מחרוזת' 'myName' ומשתמשים ב-'cout' כדי להוציא את ההודעה. לאחר מכן, נכניס את 'myName' ו-'cin>>' במיקום זה. לפיכך, המחרוזת שהמשתמש הזין נשמרת כאן. לאחר מכן, אנו משתמשים שוב בפקודה 'cout' כדי להציג את המחרוזת שנשמרה במשתנה 'myName'.
קוד 6:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
מחרוזת myName ;
cout <> השם שלי ;
cout << 'שמי: ' << השם שלי ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
ההודעה הבאה מופיעה. אנו מכניסים את המחרוזת 'פיטר' בשדה הקלט. המחרוזת שהוזנה מוצגת בשורה הבאה:
דוגמה 7:
כאשר אנו רוצים לקחת מחרוזות מרובות או קו כקלט, עלינו להשתמש בפונקציה 'getline()'. אנו מכריזים על 'שם המחרוזת' כאן. לאחר מכן, ההודעה שנזין מודפסת באמצעות 'cout'. לאחר מכן שמנו 'שם' ו-'cin' בפונקציה 'getline()' שמקבלת מספר כניסות מחרוזות מהמשתמש ומאחסנת אותן במשתנה 'שם'. זה שומר את המחרוזות שהמשתמש הזין. לאחר מכן, אנו מציגים את המחרוזות שנשמרו במשתנה 'שם' באמצעות הפקודה 'cout'.
קוד 7:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
שם מחרוזת ;
cout << 'אנא הזן את שמך המלא כאן:' ;
getline ( אֲכִילָה , שם ) ;
cout << 'השם המלא שלך הוא:' << שֵׁם ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן, בתוצאה זו, אנו מכניסים את 'ג'יימס סמואל' כנתוני המחרוזת. כאשר אנו לוחצים על 'Enter', הוא מציג את השם המלא כאן מכיוון שהשתמשנו בפונקציה 'getline()'.
סיכום
דנו על 'קלט משתמש C++' במדריך זה. חקרנו את המושג הזה ולמדנו שהפקודה 'cin', יחד עם סמלי החילוץ '>>', מנוצלת כדי לקבל את הקלט של המשתמש. לקחנו מהמשתמש את הקלט של הערכים השלם, float, double, char ו-string data מהמשתמש בעזרת הפקודה 'cin>>' והדגמנו את הדוגמאות C++ שבהן המושג 'קלט משתמש' מוסבר בפירוט .