ב-C++, כאשר אנו עובדים עם האופרטורים, יש רצף בו מתבצעות כל הפעולות. קדימות האופרטורים מנוצלת כאשר עובדים עם אופרטורים מרובים בביטוי הקוד שלנו. לדוגמה, תוך כדי עבודה עם אופרטורים של חיבור, חיסור, כפל וחילוק, פעולות הכפל והחילוק מבוצעות תחילה משמאל לימין מכיוון שיש להן קדימות גבוהה, ופעולות החיבור והחיסור מבוצעות לאחר מכן משמאל לימין כפי שבוצעו. עדיפות נמוכה מהכפל והחילוק. אבל אם הביטוי מכיל רק את אופרטורי החיבור והחיסור, הפעולה מתבצעת פשוט משמאל לימין. כאן, נציג את הטבלה של עדיפות האופרטור ואת הדוגמאות של עדיפות האופרטור.
עדיפות מפעיל של פעולות אריתמטיות
| מבצע | מפעילים | עֲדִיפוּת |
|---|---|---|
| סוגריים | () | סוגריים אלו מופעלים. |
| כפל, חילוק, מודולוס | *, /, % | פעולות אלו מבוצעות והסדר שלהן הוא משמאל לימין. |
| חיבור, חיסור | +, – | פעולות אלו מבוצעות בסוף והרצף שלהן הוא משמאל לימין. |
דוגמה 1:
בואו נתחיל את הקוד שלנו על ידי הכללת קובץ הכותרת בשם 'iostrem'. פונקציות רבות מוצהרות בקובץ הכותרת 'iostream' הזה שבו נשתמש בקוד שלנו. מתחתיו, אנו מקלידים את ה-'namespace std' ומפעילים את ה-'main()' קדימה. כאן ב-'main()', אנו מצהירים על המשתנים בשם 'i', 'j' ו-'k' עם 'int' והערכים שאנו מעבירים כאן הם '10', '37' ו-'29', בהתאמה. אנו מכריזים גם על המשתנה 'r' שבו נשמרת התוצאה.
לאחר מכן, נקליד ביטוי באמצעות האופרטורים '+, '/' ו-'-'. כפי שהסברנו בעבר, פעולות אלו מבוצעות ברצף. הביטוי שהצבנו כאן הוא 'i + j / k – j' בו מתבצעת החלוקה תחילה, ולאחר מכן מתבצעות פעולות החיבור והחיסור. הוא מציג את התוצאה בערכי מספר שלם כאשר אנו מכריזים על המשתנה 'r' כמספר השלם. בהמשך, אנו מציגים את התוצאה המחושבת באמצעות 'cout'.
קוד 1:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
int אני = 10 , י = 37 , ק = 29 ,ר ;
ר = אני + י / ק - י ;
cout << 'התוצאה של הביטוי הנתון היא = ' << ר ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הפלט הוא '-26' לאחר ביצוע כל הפעולות. תוצאה זו מחושבת לפי קדימות האופרטורים שמספקת שפת C++.
דוגמה 2:
בקוד זה, לאחר הכללת קובץ ה-header והפעלת 'main()', אנו מאתחלים משתנה 'int' עם השם 'val1' וממקמים את הביטוי בו אנו מקלידים '9 + 18 * 7'. כאן, הוא מבצע תחילה את הכפל ולאחר מכן מוסיף '9' לערך המוכפל. בהמשך, אנו מאתחלים את 'int val2' עם '9 + (18 * 7)'.
כאן, הסוגריים נפתרים תחילה. לאחר מכן, התוספת מתבצעת. לאחר מכן, אנו מאתחלים גם את 'int val3' עם הביטוי '(9 + 18) * 7'. בביטוי זה שוב מפעילים את הסוגריים תחילה ולאחר מכן מבצעים את הכפל. ערכי הביטוי זהים אך הם מספקים תוצאות ייחודיות בגלל קדימות האופרטור. כעת, אנו מתקדמים ומדפיסים את כל התוצאות המאוחסנות במשתנים 'val1', 'val2' ו-'val3' בעזרת 'cout'.
קוד 2:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
int בחירה 1 = 9 + 18 * 7 ;
int val2 = 9 + ( 18 * 7 ) ;
int val3 = ( 9 + 18 ) * 7 ;
cout << 'התוצאה הראשונה מציגה = ' << בחירה 1 << endl ;
cout << 'התוצאה השנייה מציגה = ' << val2 << endl ;
cout << 'תוצאה שלישית מראה = ' << val3 << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
התוצאה שאנו מקבלים לאחר חישוב הביטוי הנתון היא כדלקמן. אנו יכולים לראות שהתוצאה השלישית אינה זהה לשתי האחרות, למרות שהערכים זהים. זאת בשל עדיפות האופרטור המוחלת על האופרטור של הביטוי.
דוגמה 3:
כאן, אנו מאתחלים משתנים שונים עם ערכים שונים, וסוג הנתונים של כל המשתנים הללו הוא 'int'. יש לנו את המשתנים השלמים 'a', 'b', 'c' ו-'d' עם הערכים '14', '9', '15' ו-'29', בהתאמה. לאחר מכן, אנו מאתחלים את 'int R1' והביטוי שאנו מציבים כאן הוא 'a + b) * c / d'. תחילה נפתרים הסוגריים. לאחר מכן, מבוצעות פעולות הכפל והחילוק. אנו מציגים גם את התוצאה מתחת לזה. לאחר מכן, יש לנו 'int R2' עם הביטוי 'a – b * (d + a) + c'. כאן, זה גם פותר את הסוגריים ואז החיסור והחיבור מתבצעים לפי קדימות האופרטור. אנו גם מדפיסים את התוצאה שלו ומאתחלים את 'int R3' שבו מוקלד הביטוי 'b - d + c * a'. בביטוי זה מבצעים תחילה הכפל ולאחר מכן מבצעים חיסור וחיבור. התוצאה של ביטוי זה מוצגת גם בהמשך. כעת, יש לנו את הביטוי האחרון, 'd + (a * b) / a', שהתוצאה שלו מאוחסנת במשתנה 'R4'. בביטוי זה פותרים תחילה את הסוגריים ולאחר מכן מחלקים אותם. בסיום מתבצעת הוספה. התוצאה של ביטוי זה מוצגת כדלקמן:
קוד 3:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
int א = 14 ;
int ב = 9 ;
int ג = חֲמֵשׁ עֶשׂרֵה ;
int ד = 29 ;
int R1 = ( א + ב ) * ג / ד ;
cout << '(a + b) * c / d' << 'נותן =' << R1 << endl ;
int R2 = א - ב * ( ד + א ) + ג ;
cout << 'א - ב (ד + א) + ג' << 'נותן =' << R2 << endl ;
int R3 = ב - ד + ג * א ;
cout << 'b - d + c * a ' << 'נותן =' << R3 << endl ;
int R4 = ד + ( א * ב ) / א ;
cout << 'd + (a * b) / a ' << 'נותן =' << R4 << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
להלן התוצאה של חישוב הביטויים שהוזכרו קודם לכן. אנו מקבלים את התוצאה הזו מכיוון שלאופרטורים בביטוי חלה עליהם עדיפות האופרטור:
דוגמה 4:
אנו מאתחלים כאן את המשתנים 'a1', 'b1', 'c1', 'd1', 'e1', ו-'f1' עם הערכים השלמים של '64', '90', '11', '27', '34' ו-'98', בהתאמה. אנו מאתחלים את 'int result1' כאן עם הביטוי 'a1 + b1 – c1) *d1 / f1' והתוצאה מאוחסנת במשתנה 'result1'. כאן, הסוגריים נפתרים תחילה. לאחר מכן, שאר הפעולות מחושבות ברצף. לאחר מכן, אנו מדפיסים את ה'תוצאה1'. באותו אופן, אנו מחשבים את הביטויים ומאחסנים אותם במשתנים שונים. לאחר מכן, אנו מדפיסים את כל התוצאות בנפרד, ומציגים כיצד פועלת קדימות האופרטורים.
קוד 4:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
int a1 = 64 ;
int b1 = 90 ;
int ג1 = אחד עשר ;
int ד1 = 27 ;
int e1 = 3. 4 ;
int f1 = 98 ;
int תוצאה1 = ( a1 + b1 - ג1 ) * ד1 / f1 ;
cout << 'התוצאה 1 היא' << תוצאה1 << endl ;
int תוצאה2 = a1 + ( f1 * b1 ) / e1 ;
cout << 'התוצאה 2 היא' << תוצאה2 << endl ;
int תוצאה3 = e1 + ד1 + a1 - ג1 * b1 / a1 ;
cout << 'התוצאה 3 היא' << תוצאה3 << endl ;
int תוצאה4 = a1 - f1 + ( b1 - ד1 ) * ג1 ;
cout << 'התוצאה 4 היא' << תוצאה4 << endl ;
int תוצאה 5 = ( f1 + ( a1 * ( b1 + a1 ) - f1 ) * a1 + e1 ) ;
cout << 'התוצאה 5 היא' << תוצאה 5 << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הפלט של הקוד הנתון מוצג כאן ומראה את התוצאה של כל הביטויים שהזנו קודם. כל הביטויים מחושבים על ידי ביצוע כלל קדימות הסדר.
סיכום
הסתכלנו על 'קדימות C++' שבה למדנו לעומק את סדר האופרטורים שבהם הם מחושבים בתכנות C++. הצגנו גם את סדר האופרטורים בצורה של טבלה ולאחר מכן ביצענו דוגמאות רבות שבהן למדנו כיצד הביטויים נפתרו לפי עדיפות הסדר בתכנות C++.