תחביר של ה-Ternary Operator ב-C++
שלושת האופרנדים נדרשים עבור האופרטור השלישוני: המותנה, האמיתי והלא נכון. כאשר האופרטור השלישוני מנתח את מצב הבדיקה, ובהתאם לתוצאה, מבצע גוש קוד, התחביר הוא:
# (exp_1) ? exp_2 : exp_3כאן 'exp' מייצג את הביטוי. בהתאם לתוצאה של ביטוי, אופרטור זה מחזיר אחד משני ערכים. ביטויים 2 ו-3 מוערכים, והערכים שלהם מוחזרים כתוצאות סופיות אם 'exp_1' מוערך ל-true בוליאני; אחרת, ביטוי 1 מוערך ל-false בוליאני, וביטוי 2 מוערך, והערך שלו מוחזר כתוצאה סופית.
דוגמה 1
הנה תוכנית דוגמה פשוטה המראה כיצד להשתמש ב-Ternary Operator של C++.
#include
#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
לְהַכפִּיל CGPA ;
cout <> CGPA ;
מחרוזת student_result = ( CGPA >= 1.5 ) ? 'עבר' : 'נִכשָׁל' ;
cout << 'אתה ' << תוצאה_תלמיד << ' הסמסטר.' ;
לַחֲזוֹר 0 ;
}
בתוכנית, מילאנו את קטע הכותרת שלנו בספריות C++. לאחר מכן, הוספנו מרחב שמות std עם מילת המפתח 'שימוש'. לאחר מכן, המשתנה 'CGPA' עם סוג הנתונים 'כפול' הוכרז בתוכו. בשורה הבאה, ביקשנו מהמשתמש להזין את ה-CGPA על ידי הדפסת פקודת cout. עם הפקודה cin, משתמשים מוסיפים את ה-CGPA.
לאחר מכן, יצרנו משתנה נוסף, 'student_result', שיש לו אופרטור שליש. האופרטור השלישוני צריך כאן את שלושת הביטויים. ראשית הוא התנאי שבודק האם ה-CGPA שהזין המשתמש גדול או שווה ל-'1.5'. אם כן, ההצהרה 'עבר' תודפס, או שהביטוי השלישי יודפס. התוצאה תוצג כאשר תשתמש בפקודה cout.
נניח שהמשתמש מקליד את ה-CGPA '3.5'. לאחר מכן CGPA >= 1.5 מוערך לאמיתי, וממלא את הקריטריון. אז, התוצאה ניתנת למונח הראשון 'עבר'.
נניח שהמשתמש מקליד 1.00. כתוצאה מכך, המצב CGPA >= 1.5 מוערך באופן שגוי. לכן, לתוצאה ניתן הביטוי השני, 'נכשל'.
דוגמה 2
ניתן להחליף סוגים מסוימים של הצהרות if else ב-C++ עם האופרטור השלישוני. אנו יכולים לשנות את הקוד הזה כדוגמה. תוכנית הדוגמה הראשונה משתמשת בתנאי if-else, ותוכנית הדוגמה השנייה משתמשת באופרטור הטרינרי.
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
int על אחד = - 3 ;
cout << 'על אחד :' < 0 )
cout << ' \n מספר שלם חיובי' ;
אַחֵר
cout << ' \n מספר שלם שלילי!' ;
לַחֲזוֹר 0 ;
}
הכרזנו ואתחול את משתנה סוג הנתונים int 'num' עם הערך השלם השלילי. לאחר מכן, עם הפקודה cout, הערך 'num' מודפס. לאחר מכן, יש לנו את התנאי אם-אחר. בתוך התנאי 'אם', ציינו את התנאי שהמשתנה 'num' צריך להיות גדול מהערך אפס. אם התנאי יתממש, תודפס פקודת ה-cout מיד אחרי תנאי ה'אם'. אם התנאי הופך לא נכון, הצהרת else cout תודפס.
מכיוון שהמספר הוא ערך שלילי, התנאי אם הופך לשווא וה-
לאחר מכן, ביצענו את התוכנית לעיל עם האופרטור השלישוני. בוא נבדוק אם לתנאי if-else ולאופרטור הטרינרי יש את אותן השפעות.
#include#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
int המספר שלי = - 7 ;
cout << 'מספר שלם:' << המספר שלי < 0 ) ? 'מספר שלם חיובי!' : 'מספר שלם שלילי!' ;
cout << תוֹצָאָה << endl ;
לַחֲזוֹר 0 ;
}
הכרזנו על המשתנה 'MyNum' ואתחלנו אותו בערך שלילי. הדפסנו את הערך השלילי על ידי קריאה למשתנה 'MyNum' בתוך הפקודה cout. לאחר מכן, אנו מגדירים משתנה נוסף בתור 'תוצאה' עם סוג המחרוזת. משתנה התוצאה לוקח את פעולת האופרטור השלישוני. ראשית, יש לנו את התנאי ש-'MyNum' צריך להיות גדול מאפס. לאחר מכן, שמנו אופרטור טרינרי '?'. שני הביטויים האחרים יבוצעו עם תוצאת התנאי.
מכיוון שהערך השלם הוא '-7', הביטוי השלישי, 'מספר שלם שלילי!' מודפס בהנחיה. כאן, הפלט משני היישומים זהה. עם זאת, האופרטור השלישוני משפר את הקריאות והניקיון של הקוד שלנו.
דוגמה 3
בנוסף, ניתן להעסיק אופרטורים משולשים זה בתוך זה. השתמש באופרטור הטרינרי המקנן כדי לבדוק אם ערך חיובי, שלילי או אפס בתוכנית הבאה.
#include#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
int מספר שלם = 0 ;
תוצאת מחרוזת ;
תוֹצָאָה = ( מספר שלם == 0 ) ? 'אֶפֶס' : ( ( מספר שלם > 0 ) ? 'חִיוּבִי' : 'שלילי' ) ;
cout << 'מספר שלם הוא' << תוֹצָאָה ;
לַחֲזוֹר 0 ;
}
פשוט התחל עם השיטה העיקרית של התוכנית. ב-int main(), יצרנו את המשתנה עם השם 'מספר שלם' והגדרנו את ערכו כאפס. לאחר מכן, הגדרנו משתנה נוסף, 'תוצאה', עם מחרוזת סוג הנתונים. הגדרנו את המשתנה 'תוצאה', תוך עקיפת האופרטור השלישוני אליו. התנאי הוא שערך המשתנה 'מספר שלם' צריך להיות שווה לאפס 'מספר שלם == 0'. התנאי ההתחלתי, (מספר שלם == 0), קובע אם מספר שלם נתון הוא אפס או לא. אם כן, התוצאה מקבלת את ערך המחרוזת 'אפס'. אם התשובה נכונה. אחרת, אם התנאי הראשון שקרי, התנאי השני (מספר שלם > 0) נבדק.
כן, המספר השלם שסופק הוא אפס, כפי שמוצג בסקריפט. הפלט יוצר את 'המספר השלם הוא אפס'.
סיכום
אנו מודעים לכך שהאופרטור המותנה הוא האופרטור השלישוני. בעזרת מפעיל זה נוכל לבדוק תנאי ולפעול בהתאם לו. אנו עשויים להשיג את אותו הדבר באמצעות תנאי if-else במקום האופרטור השלישוני. מדריך זה של C++ לימד אותנו כיצד להשתמש ב-Ternary Operator באמצעות התחביר ותוכניות הדוגמאות שלו. זכור שיש להשתמש באופרטור השליש רק אם ההצהרה הסופית היא תמציתית.