‫סקירת חזרה על יסודות מדעי המחשב ‪ 1‬בשפת ‪#C‬‬

‫מבנה תוכנית‬
‫*‪/‬‬
‫הערה המציינת את מטרת התוכנית‬
‫את קלט התוכנית ופלט התוכנית‬
‫‪*/‬‬
‫הכרזה על שימוש במרחב השמות של מחלקות כלליות בשפת התכנות ‪using System; //‬‬
‫שם המחלקה של התוכנית ‪class ProgramName //‬‬
‫{‬
‫הפעולה הראשית של התוכנית‪public static void Main(string[ ] args) //‬‬
‫{‬
‫הוראות גוף התוכנית‬
‫}‬
‫}‬

‫בכתיבת תוכניות יש חשיבות לאותיות גדולות וקטנות‬ ‫‪‬‬

‫הבחינו בין הערת שורה המופיעה לאחר ‪ //‬לבין הערת מספר שורות המתוחמת בין ‪/* */‬‬ ‫‪‬‬

‫טיפוסי משתנים‬

‫מספרים שלמים )‪int - ( - 2,147,483,648 .. + 2,147,483,647‬‬

‫מספרים ממשיים (עם דיוק של עד ‪ 16‬ספרות אחרי הנקודה העשרונית) ‪double -‬‬
‫תו בודד (אות‪ ,‬ספרה או סימן) ‪ ,‬מסומן ע"י ' ' כך שגרש בודד מופיע משני צידי התו ‪char -‬‬
‫‪ , true / false‬משתנה בוליאני בעל ערך אמת או שקר ‪bool -‬‬

‫דוגמאות להצהרה על משתנים‪:‬‬

‫משתנה מטיפוס שלם ‪int num; //‬‬

‫ניתן להצהיר על מספר משתנים בשורה אחת ולהפריד ביניהם ע"י פסיק ‪ ,‬טיפוס ממשי ‪double d1,d2; //‬‬
‫משתנה מטיפוס תווי ‪char tav; //‬‬
‫משתנה מטיפוס בוליאני ‪bool b; //‬‬
‫הוראות קלט ‪ /‬פלט‬
‫קלט ‪-‬‬
‫;))(‪.Parse(Console.ReadLine‬שם משתנה= טיפוס המשתנה‬

‫‪:‬דוגמאות להוראות קלט של משתנים מטיפוס שלם‪ ,‬ממשי ותווי‬

‫קליטת ערך למשתנה מטיפוס שלם ‪num1 = int.Parse(Console.ReadLine()); //‬‬

‫קליטת ערך למשתנה מטיפוס ממשי ‪num2 = double.Parse(Console.ReadLine()); //‬‬
‫קליטת ערך למשתנה מטיפוס תווי ‪ch = char.Parse(Console.ReadLine()); //‬‬

‫הערה‪ :‬בכל הוראת קלט ניתן לקלוט ערך למשתנה אחד בלבד‪.‬‬
‫פלט ‪-‬‬
‫לאחר הפלט לא תתבצע ירידת שורה‪); //‬ביטוי ו‪/‬או מחרוזת תווים בין זוג גרשיים(‪Console.Write‬‬
‫לאחר הפלט תתבצע ירידת שורה‪); //‬ביטוי ו‪/‬או מחרוזת תווים בין זוג גרשיים(‪Console.WriteLine‬‬

‫ביטוי יכול להיות מספר קבוע‪ ,‬משתנה או ביטוי חשבוני המורכב ממספרים ו‪/‬או משתנים וארבע‬
‫פעולות חשבון אפשריות‪ :‬חיבור ‪ , +‬חיסור ‪ , -‬כפל * ‪ ,‬חילוק ‪/‬‬

‫‪.‬ביטוי יופיע ללא זוג גרשיים בניגוד למחרוזת תווים שתתוחם בין זוג גרשיים‬

‫‪1‬‬
 ‫‪:‬דוגמאות להוראות פלט‬

‫הדפסת ערך של משתנה ‪Console.Write(num); //‬‬

‫הדפסת שם וערך של משתנה ‪ ,‬סימן הפלוס מציין שרשור בין פלטים ‪Console.Write("num " + num); //‬‬
‫הדפסת תוצאת סכום של ערכי משתנים‪ ,‬סימן הפלוס הוא חשבוני ‪Console.Write(n1 + n2); //‬‬
‫;)‪Console.WriteLine("You are " + (2012 - year) + " years old, You were born in " + year‬‬
‫;)‪Console.WriteLine("You are {0} years old, You were born in {1}", 2012 - year , year‬‬

‫סימני הפלוס ‪ +‬והסוגריים המסולסלים וממוספרים {‪ }0{ , }1‬בשתי דוגמאות הפלט האחרונות‬
‫נועדו לשלב (לשרשר) ערכי משתנים ותוצאות של ביטויים מחושבים בהודעות הפלט המודפסות‪.‬‬
‫לפני הוראת קלט תופיע הוראת פלט המבקשת מהמשתמש להכניס ערך קלט למשתנה‪ ,‬לדוגמה‪:‬‬

‫)"‪;Console.WriteLine("Enter number‬‬
‫)) (‪;a = int.Parse(Console.ReadLine‬‬

‫הוראת השמה‬
‫;ביטוי = משתנה‬
‫כיוון ההשמה הוא מימין לשמאל‪ :‬ערך הביטוי בצד ימין של סימן ההשמה = מוצב במשתנה‬
‫‪.‬שבצד שמאל של סימן ההשמה‬
‫גם כאן בהוראת השמה‪ ,‬ביטוי יכול להיות מספר קבוע‪ ,‬משתנה או ביטוי חשבוני המורכב‬
‫ממספרים ו‪/‬או משתנים וארבע פעולות חשבון אפשריות‪ :‬חיבור ‪ , +‬חיסור ‪ , -‬כפל * ‪ ,‬חילוק ‪/‬‬

‫‪:‬דוגמאות להוראות השמה‬

‫השמת קבוע מספרי שלם במשתנה ‪num = 5; //‬‬
‫השמת קבוע מספרי ממשי לא שלם במשתנה ‪d = 3.5; //‬‬
‫השמת קבוע תווי במשתנה ‪ ,‬מתוחם בגרש בודד ' מכל צד ‪ch = '$'; //‬‬
‫השמת קבוע בוליאני במשתנה‪b = true; //‬‬
‫השמת ערך משתנה ימני בתוך משתנה שמאלי ‪num1 = num2; //‬‬
‫השמת תוצאת חישוב של ביטוי חשבוני במשתנה ‪num = 5 + mis; //‬‬

‫הערה‪ :‬יש להבחין בין השמה לבין השוואה מתמטית‪ ,‬לדוגמה ההוראה ‪ n = n + 1‬מבטאת‬
‫השמה ולא השוואה‪ ,‬כמו ‪ -‬כן משתנה יכול להופיע משני צידי סימן ההשמה = ‪ ,‬ואז ערכו החדש‬
‫של המשתנה תלוי בערכו הקודם‪ .‬במקרה זה ערכו של המשתנה ‪ n‬עולה ב‪.1-‬‬

‫‪;int num = 1‬‬ ‫ניתן להציב ערך התחלתי במשתנה בעת הצהרתו‪ ,‬לדוגמה‪:‬‬

‫קיצורים ‪ -‬סימני פעולה לקיצור הכתיבה של פעולות הגדלת ‪ /‬הקטנת ערך משתנה‪:‬‬
‫הגדלת ערך משתנה ב‪1-‬‬ ‫‪++‬‬
‫הקטנת ערך משתנה ב‪1-‬‬ ‫‪--‬‬
‫הגדלת ערך של משתנה‬ ‫=‪+‬‬
‫הקטנת ערך של משתנה‬ ‫=‪-‬‬
‫הכפלת ערך של משתנה‬ ‫=*‬
‫חלוקת ערך של משתנה‬ ‫=‪/‬‬

‫הגדלת ערכו של המשתנה ב‪num++; // 1-‬‬

‫הקטנת ערכו של המשתנה ב‪num - -; //1-‬‬
‫הוספה של ‪ 5‬לערכו של המשתנה‪num += 5; //‬‬
‫הפחתה של ‪ 5‬מערכו של המשתנה‪num - = 5; //‬‬
‫הכפלת ערך משתנה ב‪ 1.17-‬לצורך חישוב תוספת מע"מ של ‪ 17%‬למחיר מוצר ‪price *= 1.17; //‬‬

‫‪2‬‬
‫חלוקת ערכו של המשתנה ב‪sum /= 5; // 5-‬‬

‫פעולות מנה ושארית חלוקה‬

‫מנת חלוקה באמצעות סימן הפעולה ‪/‬‬

‫‪x/y‬‬

‫תוצאת מנת החלוקה של מספר שלם ‪ x‬במספר שלם ‪ y‬היא מספר הפעמים השלמות בהן הערך ‪y‬‬
‫נכנס בערך ‪.x‬‬

‫טיפוס תוצאת מנת החלוקה תלוי בטיפוסי המחולק ‪ x‬והמחלק ‪:y‬‬

‫כאשר המחולק והמחלק הם מספרים שלמים‪ ,‬תוצאת המנה תהווה מספר שלם‪ ,‬לדוגמה‪:‬‬

‫נכנס ב‪ 4 17-‬פעמים שלמות ‪17 / 4 = 4 , 4‬‬

‫נכנס ב‪ 3 12-‬פעמים שלמות ‪12 / 4 = 3, 4‬‬
‫נכנס ב‪ 0 3-‬פעמים שלמות ‪3 / 5 = 0 , 5‬‬

‫כאשר המחולק או המחלק (או שניהם) אינם מספר שלם‪ ,‬תבוצע חלוקה מתמטית רגילה‪ ,‬ותוצאת‬
‫‪:‬המנה תהווה מספר ממשי‪ ,‬לדוגמה‬

‫‪17 / 4.0 = 4.25‬‬

‫‪12.0 / 4 = 3.0‬‬
‫‪3 / 5.0 = 0.6‬‬

‫כאשר המחולק והמחלק הם מספרים שלמים‪ ,‬ובכל זאת נדרש לבצע עליהם פעולת חלוקה‬
‫ממשית‪ ,‬אז יש להמיר את אחד מגורמי החלוקה‪ ,‬המחולק או המחלק‪ ,‬לטיפוס ‪ ,double‬כדי‬
‫לקבל תוצאת חלוקה ממשית רגילה כמקובל במתמטיקה [נושא המרת טיפוסים ‪ -‬בעמוד הבא]‪:‬‬

‫‪(double) x / y‬‬

‫שארית חלוקה באמצעות סימן הפעולה ‪%‬‬

‫‪x%y‬‬

‫תוצאת שארית החלוקה של מספר שלם ‪ x‬במספר שלם ‪ y‬היא הערך הנותר לאחר שמפחיתים מ‪-‬‬
‫‪ x‬את כל הכפולות השלמות האפשריות של ‪.y‬‬

‫הפעולה משמשת לחישוב תוצאת השארית השלמה בחלוקת ‪ 2‬מספרים שלמים‪ ,‬לדוגמה‪:‬‬

‫לאחר שמכניסים ‪ 4‬פעמים שלמות את ‪ 4‬ב‪ 17-‬נותרת שארית ‪17 % 4 = 1 , 1‬‬

‫לאחר שמכניסים ‪ 3‬פעמים שלמות את ‪ 4‬ב‪ 12-‬נותרת שארית ‪12 % 4 = 0 , 0‬‬
‫לאחר שמכניסים ‪ 0‬פעמים שלמות את ‪ 5‬ב‪ 3-‬נותרת שארית ‪3 % 5 = 3 , 3‬‬

‫שימושי פעולות מנה ושארית חלוקה‬

‫(‪ )1‬פירוק מספר לספרותיו‬

‫פעולות המנה והשארית משמשות לחילוץ ספרות של מספר‪ ,‬לדוגמה עבור מספר תלת ‪ -‬ספרתי‪:‬‬

‫הספרה הימנית‪ ,‬ספרת האחדות ‪123 % 10 = 3 //‬‬

‫הספרה האמצעית‪ ,‬ספרת העשרות ‪(123 / 10) % 10 = 2 //‬‬

‫‪3‬‬
‫הספרה השמאלית‪ ,‬ספרת המאות ‪(123 / 10) / 10 = 1 //‬‬

‫‪4‬‬
 ‫כללים לפירוק מספר לספרותיו והמחשתם בדוגמה‬

‫הספרה הימנית של המספר מתקבלת ע"י הפעלת פעולת שארית חלוקה ב‪ 10-‬על המספר‪.‬‬ ‫‪‬‬
‫יתרת המספר‪ ,‬ללא הספרה הימנית של המספר‪ ,‬מתקבלת ע"י הפעלת פעולת מנת חלוקה ב‪-‬‬ ‫‪‬‬
‫‪ 10‬על המספר‪.‬‬

‫קבלת הספרה הימנית ע"י פעולת שארית חלוקה ב‪123 % 10 = 3 // 10-‬‬

‫קבלת יתרת המספר ללא הספרה הימנית ע"י פעולת מנת חלוקה ב‪123 / 10 = 12 // 10-‬‬

‫(‪ )2‬בדיקות חלוקה של ‪ 2‬מספרים ללא ועם שארית [נושא הוראת התנאי ‪ - if‬בהמשך המסמך]‬
‫כך נבדוק האם ערכי ‪ 2‬משתנים מתחלקים זה בזה ללא שארית‪:‬‬

‫בדיקה אם שארית החלוקה בין ערכי ‪ 2‬המשתנים היא ‪if (num1 % num2 = = 0) // 0‬‬

‫כך נבדוק האם ערך משתנה הוא זוגי ‪ ,‬כלומר מתחלק ב‪ 2-‬ללא שארית‪:‬‬

‫בדיקה אם שארית החלוקה של ערך המשתנה ב‪ 2-‬היא ‪if (num % 2 = = 0) // 0‬‬

‫המרת טיפסים (‪)casting‬‬

‫תבנית להמרה מטיפוס לטיפוס‪:‬‬

‫קבוע ‪ /‬משתנה ‪ /‬ביטוי שרוצים להמיר (טיפוס‬

‫ההמרה)‬

‫(‪num )double‬‬ ‫לדוגמה‪ ,‬כך נציין המרת טיפוס ערך המשתנה ‪ num‬לטיפוס ממשי‪:‬‬

‫שימושי המרה בין טיפוסים‬

‫(‪ )1‬מציאת ערך שלם של מספר ממשי לא שלם‬

‫לדוגמה‪ ,‬המרת ערך משתנה מטיפוס ממשי ‪ double‬לטיפוס שלם ‪:int‬‬

‫;‪double b‬‬
‫;‪int a = (int)b‬‬
‫הביטוי (‪ b)int‬מציין את הערך השלם של תוכן המשתנה הממשי ‪.b‬‬

‫לדוגמה‪ ,‬אם ‪ b‬מכיל ‪ 2.34‬אז הערך השלם (‪ 2.34)int‬הוא ‪ ,2‬גם הערך השלם (‪ 2.94)int‬הוא ‪ ,2‬אף‬
‫על פי ש‪ 2.94-‬יותר קרוב ל‪ ,3-‬כלומר פעולת הערך השלם אינה פעולת עיגול מתמטי רגיל‪.‬‬

‫(‪ )2‬חישוב חלוקה מתמטית ממשית בין מספרים שלמים‬

‫בחישוב חלוקה מתמטית ממשית רגילה בין מספרים שלמים נדרש להמיר את אחד מגורמי‬
‫החלוקה‪ ,‬המחולק או המחלק‪ ,‬לטיפוס ‪ double‬לצורך קבלת תוצאה ממשית‪ ,‬לדוגמה‪:‬‬

‫;‪int x, y‬‬
‫חישוב חלוקה מתמטית ממשית בין מספרים שלמים ‪double z = (double) x / y; //‬‬
‫חישוב ממוצע מתמטי בין מספרים שלמים ‪double avg = (double)(x + y) / 2; //‬‬

‫הערה‪ :‬ניתן להציב משתנה מטיפוס שלם ‪ int‬במשתנה מטיפוס ממשי ‪ double‬ללא ביצוע המרה‬
‫מפורשת‪ ,‬שכן משתנה מטיפוס ממשי יכול להכיל גם מספר שלם‪ ,‬לדוגמה‪:‬‬

‫‪5‬‬
int num1;
double num2 = num1;

6
 ‫פונקציות (פעולות) מתמטיות‬
‫מבנה הוראת זימון של פונקציה מתמטית‪:‬‬

‫(רשימת ערכים מופרדים בפסיקים) שם הפונקציה ‪Math .‬‬

‫פונקציות מתמטיות נפוצות במחלקה המתמטית ‪:Math‬‬

‫דוגמאות לזימון וערכים מוחזרים‬ ‫טיפוס ערך התוצאה‬ ‫טיפוס הפרמטר ‪ /‬ים‬ ‫תיאור פעולת הפונקציה‬ ‫הפונקציה‬
‫שלם או ממשי בהתאם‬
‫‪Math.Abs(63) ->63‬‬ ‫מחזירה את הערך המוחלט‬
‫לטיפוס ערך הפרמטר‬ ‫שלם או ממשי‬ ‫)‪Abs(x‬‬
‫‪Math.Abs(-12.7) -> 12.7‬‬ ‫של ‪ ; x‬בסימון מתמטי‪| x | :‬‬
‫המתקבל‬
‫‪Math.Sqrt(16) -> 4.0‬‬ ‫מחזירה את השורש הריבועי‬
‫ממשי‬ ‫שלם או ממשי‬ ‫)‪Sqrt(x‬‬
‫‪Math.Sqrt(6.25) ->2.5‬‬ ‫של ‪ ; x‬בסימון מתמטי‪:‬‬
‫‪Math.Pow(2, 3) -> 8.0‬‬ ‫מחזירה את ערך תוצאת‬
‫‪Math.Pow(-4, 2) -> 16.0‬‬ ‫החישוב של ‪ x‬בחזקת ‪y‬‬
‫ממשי‬ ‫שלמים או ממשיים‬ ‫)‪Pow(x, y‬‬
‫‪Math.Pow(2.5, 2) -> 6.25‬‬
‫בסימון מתמטי‪:‬‬
‫‪Math.Pow(2, 2.5) -> 5.66‬‬
‫‪Math.Round(15.2) -> 15.0‬‬ ‫מוחזר מספר שלם‬ ‫מעגלת את ‪ ; x‬מחזירה את‬
‫‪Math.Round(0.78) -> 1.0‬‬ ‫בייצוג ממשי‪ ,‬לכן‬ ‫השלם הקרוב ביותר ל‪x-‬‬
‫‪Math.Round(-8.9) -> -9.0‬‬ ‫בהשמת התוצאה‬ ‫ממשי‬ ‫אם חלק השבר גדול מ‪0.5-‬‬ ‫)‪Round(x‬‬
‫‪Math.Round(-8.2) -> -8.0‬‬ ‫למשתנה מטיפוס שלם‬ ‫השלם הבא יתקבל כתוצאה‬
‫נדרשת המרה ל‪int-‬‬
‫‪Math.Floor(15.2) -> 15.0‬‬ ‫מוחזר מספר שלם‬
‫‪Math.Floor(0.78) -> 0.0‬‬ ‫בייצוג ממשי‪ ,‬לכן‬
‫מחזירה את השלם הגדול‬
‫‪Math.Floor(-8.9) -> -9.0‬‬ ‫בהשמת התוצאה‬ ‫ממשי‬ ‫)‪Floor(x‬‬
‫ביותר שקטן מ‪x-‬‬
‫‪Math.Floor(-8.2) -> -9.0‬‬ ‫למשתנה מטיפוס שלם‬
‫נדרשת המרה ל‪int-‬‬
‫מחזירה את המספר‬
‫‪Math.Min(1, 3) -> 1‬‬ ‫שלם או ממשי‬
‫שלמים או ממשיים‬ ‫המינימלי מבין שני‬ ‫)‪Min(a, b‬‬
‫‪Math.Min(3.5, 2.8) -> 2.8‬‬ ‫בהתאם לטיפוסי הקלט‬
‫הפרמטרים‬
‫מחזירה את המספר‬
‫‪Math.Max(1, 3) -> 3‬‬ ‫שלם או ממשי‬
‫שלמים או ממשיים‬ ‫)‪ Max(a, b‬המקסימלי מבין שני‬
‫‪Math.Max(3.5, 2.8) -> 3.5‬‬ ‫בהתאם לטיפוסי הקלט‬
‫הפרמטרים‬

‫הערה‪ :‬פעולות העיגול ‪ Round , Floor‬מחזירות כתוצאה מספר שלם אך בייצוג ממשי ‪,double‬‬
‫לכן בהשמת התוצאה המתקבלת למשתנה מטיפוס שלם נדרשת המרה ל‪ ,int-‬לדוגמה‪:‬‬

‫עיגול כלפי השלם הקרוב ‪int res1 = (int)Math.Round(15.8); // 16‬‬

‫עיגול כלפי השלם הקרוב הנמוך ‪int res2 = (int)Math.Floor(15.8); // 15‬‬

‫‪7‬‬
 ‫דרכים לזימון פונקציות מתמטיות‬

‫בהוראת השמה ‪ ,‬לדוגמה‪:‬‬ ‫‪‬‬

‫השמת ערך מוחלט של תוכן משתנה במשתנה תוצאה ‪absolute = Math.Abs(num); //‬‬

‫בהוראת פלט ‪ ,‬לדוגמה‪:‬‬ ‫‪‬‬

‫הדפסת ערך מוחלט של תוכן משתנה ‪Console.Write(Math.Abs(num)); //‬‬

‫בתוך ביטוי חשבוני ‪ ,‬לדוגמה‪:‬‬ ‫‪‬‬

‫חישוב ממוצע בין ‪ 2‬ערכים מוחלטים ‪avg = (Math.Abs(num1) + Math.Abs(num2)) / 2.0; //‬‬

‫בתוך ביטוי בוליאני בתנאי לבדיקה ‪ ,‬לדוגמה‪:‬‬ ‫‪‬‬

‫בדיקה אם שורש ערך משתנה שווה ל‪if (Math.Sqrt(num) = = 10.0) // 10-‬‬

‫;)"‪Console.Write("num square root result is equal to 10.0‬‬

‫יצירת מספרים אקראיים באמצעות שימוש במחלקה ‪Random‬‬

‫הצהרה על עצם המחלקה ‪Random rnd = new Random( ); // Random‬‬

‫הגרלת מספר שלם בטווח המספרים (כולל קצוות) ‪int num = rnd.Next(n); // 0 .. n-1‬‬
‫הגרלת מספר שלם בטווח המספרים (כולל קצוות) ‪num = rnd.Next(m, n); // m .. n-1‬‬
‫הגרלת מספר אקראי שלם לא שלילי ‪num = rnd.Next( ); //‬‬

‫דוגמאות ליצירת מספרים אקראיים‪:‬‬

‫יצירת עצם מטיפוס המחלקה ‪Random rnd = new Random( ); // Random‬‬

‫תוצאות אפשריות ‪int n1 = rnd.Next(6); // 0..5‬‬
‫תוצאות אפשריות בהטלת קובייה ‪int n2 = rnd.Next(1, 7); // 1..6‬‬
‫תוצאות אפשריות ‪int n3 = rnd.Next(20, 41); // 20..40‬‬
‫תוצאות אפשריות ‪int n4 = rnd.Next(21) + 20; // 20..40‬‬

‫הוראת התנאי ‪if else‬‬

‫מבנה א'‪ if :‬ללא ‪else‬‬

‫מצויינות רק הוראות לביצוע במקרה שתנאי הבדיקה מתקיים‪ ,‬לא מצויינות הוראות לביצוע‬
‫במקרה שתנאי הבדיקה לא מתקיים‪:‬‬

‫אם התנאי מתקיים ‪) //‬ביטוי תנאי בוליאני לבדיקה( ‪if‬‬

‫{‬
‫;הוראות לביצוע אם ביטוי התנאי הבוליאני מתקיים והוא אמת‬
‫}‬

‫‪8‬‬
 ‫מבנה ב'‪ if :‬עם ‪else‬‬

‫מצויינות הוראות לביצוע הן במקרה שתנאי הבדיקה מתקיים והן במקרה שתנאי הבדיקה לא‬
‫מתקיים‪:‬‬

‫אם התנאי מתקיים ‪) //‬ביטוי תנאי בוליאני לבדיקה( ‪if‬‬

‫{‬
‫;הוראות לביצוע אם ביטוי התנאי הבוליאני מתקיים והוא אמת‬
‫}‬
‫אם התנאי לא מתקיים ‪else //‬‬
‫{‬
‫;הוראות לביצוע אם ביטוי התנאי הבוליאני אינו מתקיים והוא שקר‬
‫}‬

‫הערה‪ :‬אם סדרת ההוראות לביצוע לאחר חלקי ה‪ if-‬או ה‪ else-‬כוללת רק הוראה אחת לביצוע‪,‬‬
‫אז ניתן להשמיט את בלוק הסוגריים המסולסלים {} התוחם את ההוראה‪ .‬כאשר סדרת‬
‫ההוראות לביצוע כוללת יותר מהוראה אחת‪ ,‬חובה לתחום אותן בסוגריים מסולסלים‪.‬‬

‫סימני השוואה לניסוח ביטוי תנאי בוליאני‬

‫גדול‬ ‫<‬
‫קטן‬ ‫>‬
‫גדול או שווה‬ ‫=<‬
‫קטן או שווה‬ ‫=>‬
‫שווה‬ ‫==‬
‫שונה‬ ‫=!‬
‫קשרים לוגיים לבניית תנאים מורכבים‬
‫ניתן ליצור ביטוי בוליאני מורכב מביטויים בוליאניים פשוטים יותר ע"י שימוש בקשרים‬
‫הלוגיים‪:‬‬

‫קשר לוגי וגם &&‬ ‫‪‬‬

‫דוגמה‪:‬‬

‫האם ערך המשתנה גדול מ‪ 5-‬וגם קטן מ‪if (num1 > 5 && num1 < 15) // 15-‬‬

‫עבור שני ביטויי תנאי בוליאניים המשולבים בהוראת תנאי מורכב בקשר לוגי של וגם‪ ,‬אלה‬
‫תוצאות הביטוי הבוליאני של התנאי המורכב ב‪ 4-‬צירופים אפשריים לערכים הבוליאניים של‬
‫שני ביטויי התנאי הפשוטים יותר ‪ -‬ביטוי בוליאני ‪ , 1‬ביטוי בוליאני ‪:2‬‬

‫(ביטוי בוליאני ‪ && 2‬ביטוי בוליאני ‪if )1‬‬

‫ביטוי בוליאני ‪1‬‬ ‫ביטוי בוליאני ‪2‬‬ ‫(ביטוי בוליאני ‪ && 2‬ביטוי בוליאני ‪)1‬‬
‫‪true‬‬ ‫‪true‬‬ ‫‪true‬‬
‫‪true‬‬ ‫‪false‬‬ ‫‪false‬‬
‫‪false‬‬ ‫‪true‬‬ ‫‪false‬‬
‫‪false‬‬ ‫‪false‬‬ ‫‪false‬‬

‫וגם && ‪ :‬התנאי המורכב מתקיים רק אם שני התנאים הפשוטים יותר מתקיימים שניהם‬

‫‪9‬‬
10
 ‫דוגמה נוספת‪:‬‬

‫כאשר נדרש לנסח בדיקה מתמטית של יחסי גודל בין ‪ 3‬גורמים‪,num1 < num2 < num3 :‬‬
‫נגדיר ‪ 2‬ביטויים בוליאנים פשוטים לבדיקת יחסי הגודל בין הגורמים הראשון והשני ובין‬
‫הגורמים השני והשלישי‪ ,‬ונשלב ביניהם ע"י הקשר הלוגי וגם && ליצירת ביטוי תנאי בוליאני‬
‫מורכב‪:‬‬

‫)‪(num1 < num2) && (num2 < num3‬‬

‫קשר לוגי או | |‬ ‫‪‬‬

‫דוגמה‪:‬‬

‫האם ערך המשתנה קטן מ‪ 0-‬או גדול או שווה ‪if (num1 < 0 | | num1 >= 10) // 10‬‬

‫עבור שני ביטויי תנאי בוליאניים המשולבים בהוראת תנאי מורכב בקשר לוגי של או‪ ,‬אלה‬
‫תוצאות הביטוי הבוליאני של התנאי המורכב ב‪ 4-‬צירופים אפשריים לערכים הבוליאניים של‬
‫שני ביטויי התנאי הפשוטים יותר ‪ -‬ביטוי בוליאני ‪ , 1‬ביטוי בוליאני ‪:2‬‬

‫(ביטוי בוליאני ‪ | | 2‬ביטוי בוליאני ‪if )1‬‬

‫ביטוי בוליאני ‪1‬‬ ‫ביטוי בוליאני ‪2‬‬ ‫(ביטוי בוליאני ‪ | | 2‬ביטוי בוליאני ‪)1‬‬
‫‪true‬‬ ‫‪true‬‬ ‫‪true‬‬
‫‪true‬‬ ‫‪false‬‬ ‫‪true‬‬
‫‪false‬‬ ‫‪true‬‬ ‫‪true‬‬
‫‪false‬‬ ‫‪false‬‬ ‫‪false‬‬

‫או | | ‪ :‬התנאי המורכב מתקיים אם לפחות אחד משני התנאים הפשוטים יותר מתקיים‬

‫קשר לוגי לא ! (קשר ההיפוך ‪ /‬השלילה)‬ ‫‪‬‬

‫דוגמה‪:‬‬

‫האם ערך המשתנה לא שווה ל‪ ,0-‬כלומר האם שונה מ‪if (!(num1 = = 0)) // 0-‬‬

‫עבור ביטוי תנאי בוליאני אחד המשולב בהוראת תנאי מורכב בקשר לוגי של לא‪ ,‬אלה‬
‫תוצאות הביטוי הבוליאני של התנאי המורכב בהתאם ל‪ 2-‬ערכים אפשריים לביטוי התנאי‬
‫הבוליאני ‪:1‬‬

‫((ביטוי בוליאני ‪if )(!1‬‬

‫ביטוי בוליאני ‪1‬‬ ‫(ביטוי בוליאני ‪!)1‬‬

‫‪true‬‬ ‫‪false‬‬
‫‪false‬‬ ‫‪true‬‬

‫לא ! ‪ :‬התנאי המורכב מתקיים רק אם התנאי הפנימי הפשוט יותר לא מתקיים‬

‫‪11‬‬
 ‫המחשה לקשרים הלוגיים או ‪ ,‬וגם בתנאי מורכב ‪ -‬מחסומים במערכת כבישים‬

‫המחשת וגם‪ :‬ניתן להגיע מנקודה א' לנקודה ב' רק אם מחסום ‪ 1‬מורם וגם מחסום ‪ 2‬מורם‪ .‬אם‬
‫לפחות אחד משני המחסומים ‪ 2 , 1‬לא מורם‪ ,‬לא ניתן להגיע מנקודה א' לנקודה ב'‪.‬‬

‫המחשת או‪ :‬ניתן להגיע מנקודה ב' לנקודה ג' אם מחסום ‪ 3‬מורם או מחסום ‪ 4‬מורם‪ .‬כמובן‪,‬‬
‫שאם שני המחסומים ‪ 4 , 3‬מורמים‪ ,‬בוודאי שגם ניתן להגיע מנקודה ב' לנקודה ג'‪ .‬מספיק‬
‫שלפחות אחד משני המחסומים ‪ 4 , 3‬יהיה מורם‪ ,‬כדי שיהיה ניתן להגיע מנקודה ב' לנקודה ג'‪.‬‬
‫רק אם שני המחסומים ‪ 4 , 3‬לא מורמים‪ ,‬לא ניתן להגיע מנקודה ב' לנקודה ג'‪.‬‬
‫שילוב משתנה בוליאני בתנאי לבדיקה‬

‫ניתן לשלב משתנה מטיפוס בוליאני ‪ bool‬בתנאי לבדיקה ללא שימוש בסימני השוואה‪ ,‬לדוגמה‪:‬‬

‫מאתחלים משתנה בוליאני בערך אמת ‪ true‬או שקר ‪ false‬בהתאם למטרת השימוש במשתנה‪:‬‬

‫;‪bool b = true‬‬

‫או‬

‫;‪bool b = false‬‬

‫ומציבים את המשתנה הבוליאני כביטוי בוליאני בהוראת תנאי‪:‬‬

‫‪:‬כך נרשום ‪if (b) //‬‬

‫ביטוי שקול ‪if (b = = true) //‬‬

‫בהתאם לצורך‪ ,‬ניתן להפעיל על המשתנה הבוליאני את הקשר הלוגי לא !‪:‬‬

‫‪:‬כך נרשום ‪if (!b) //‬‬

‫ביטוי שקול ‪if (b = = false) //‬‬

‫ניתן להציב משתנה בוליאני גם בביטוי התנאי של לולאת ‪[ .while‬נושא לולאת ‪ - while‬בהמשך‬
‫המסמך]‪.‬‬

‫‪12‬‬
 ‫קינון של הוראות תנאי (הוראות תנאי מקוננות)‬

‫ניתן לכלול הוראת תנאי כאחת מהוראות בלוק ה‪ if-‬או בלוק ה‪ else-‬של הוראת תנאי אחרת‪.‬‬

‫דוגמאות למבנים אפשריים של הוראות תנאי מקוננות‪:‬‬

‫(‪ )1‬הוראת תנאי ‪ if‬ללא בלוק ‪ else‬מופיעה תחת בלוק ‪ else‬של הוראת תנאי אחרת‪:‬‬

‫)ביטוי בוליאני( ‪if‬‬

‫הוראות לביצוע‬
‫‪else‬‬
‫)ביטוי בוליאני( ‪if‬‬
‫הוראות לביצוע‬

‫(‪ )2‬הוראת תנאי ‪ if else‬מופיעה תחת בלוק ‪ if‬של הוראת תנאי אחרת‪ ,‬שלא כוללת בלוק ‪:else‬‬

‫)ביטוי בוליאני( ‪if‬‬

‫)ביטוי בוליאני( ‪if‬‬
‫הוראות לביצוע‬
‫‪else‬‬
‫הוראות לביצוע‬

‫(‪ )3‬הוראת תנאי ‪ if else‬מופיעה תחת בלוק ‪ if‬של הוראת תנאי אחרת‪ ,‬שכן כוללת בלוק ‪:else‬‬

‫)ביטוי בוליאני( ‪if‬‬

‫)ביטוי בוליאני( ‪if‬‬
‫הוראות לביצוע‬
‫‪else‬‬
‫הוראות לביצוע‬
‫‪else‬‬
‫הוראות לביצוע‬

‫הערה‪ :‬כלל השיוך של ‪ else‬ל‪ if-‬מתאים‪ else :‬תמיד משוייך ל‪ if-‬שנמצא לפניו וקרוב אליו ביותר‬
‫בתנאי של‪ if-‬זה לא משוייך ‪ else‬אחר קרוב יותר‪ ,‬וש‪ if-‬זה אינו כלול בתוך בלוק סוגריים‬
‫מסולסלים אחר שמסתיים עוד לפני ה‪.else-‬‬

‫‪13‬‬
 ‫לולאות ‪ /‬הוראות ביצוע חוזר‬

‫ביצוע חוזר באורך (מספר פעמים) מחושב מראש ‪ -‬לולאת ‪for‬‬

‫) משתנה בקרה אתחול; ביטוי תנאי בוליאני לקביעת המשך ביצוע הלולאה ;עדכון משתנה הבקרה( ‪for‬‬
‫{‬
‫גוף הלולאה המכיל הוראות לביצוע כל עוד ביטוי התנאי הבוליאני מתקיים והוא אמת‬
‫}‬

‫אתחול משתנה הבקרה מתבצע רק פעם אחת‪.‬‬ ‫‪‬‬

‫ביטוי התנאי הבוליאני נבדק לפני כל ביצוע של הוראות גוף הלולאה‪.‬‬ ‫‪‬‬
‫כל עוד ביטוי התנאי הבוליאני מתקיים‪ ,‬הוראות גוף הלולאה מתבצעות‪.‬‬ ‫‪‬‬
‫עדכון משתנה הבקרה מתבצע לאחר כל סיום ביצוע של הוראות גוף הלולאה‪.‬‬ ‫‪‬‬
‫לאחר עדכון משתנה הבקרה‪ ,‬נבדק שוב ביטוי התנאי הבוליאני‪ ,‬ואם הוא מתקיים ‪ -‬הוראות‬ ‫‪‬‬
‫גוף הלולאה מתבצעות‪ ,‬ואם הוא לא מתקיים ‪ -‬ביצוע הלולאה מסתיים‪.‬‬
‫אם גוף הלולאה כולל רק הוראה אחת לביצוע‪ ,‬אז ניתן להשמיט את בלוק הסוגריים‬ ‫‪‬‬
‫המסולסלים {} התוחם את ההוראה‪ .‬כאשר גוף הלולאה כולל יותר מהוראה אחת‪ ,‬חובה‬
‫לתחום אותן בסוגריים מסולסלים‪.‬‬
‫ניתן להצהיר על טיפוס משתנה הבקרה יחד עם אתחולו‪ ,‬כפי שניתן לראות בדוגמה‪.‬‬ ‫‪‬‬

‫דוגמה‪:‬‬

‫לולאה המתבצעת ‪ 5‬פעמים ומדפיסה את המספרים הזוגיים בין ‪for (int i = 1; i <= 5; i++) // 1-10‬‬
‫כולל‬
‫;)‪Console.WriteLine (i * 2‬‬

‫טבלת מעקב ביצוע ללולאת הדוגמה‪:‬‬

‫‪i‬‬ ‫‪i <= 5‬‬ ‫פלט‬

‫‪1‬‬ ‫‪true‬‬ ‫‪2‬‬
‫‪2‬‬ ‫‪true‬‬ ‫‪4‬‬
‫‪3‬‬ ‫‪true‬‬ ‫‪6‬‬
‫‪4‬‬ ‫‪true‬‬ ‫‪8‬‬
‫‪5‬‬ ‫‪true‬‬ ‫‪10‬‬
‫‪6‬‬ ‫‪false‬‬ ‫‪-‬‬

‫ביצוע חוזר בתנאי ‪ -‬לולאת ‪( while‬כל עוד)‬

‫כל עוד התנאי מתקיים ‪) //‬ביטוי תנאי בוליאני לבדיקה( ‪while‬‬

‫{‬
‫גוף הלולאה המכיל הוראות לביצוע כל עוד ביטוי התנאי הבוליאני מתקיים והוא אמת‬
‫}‬

‫כל עוד ביטוי התנאי הבוליאני מתקיים‪ ,‬הוראות גוף הלולאה מתבצעות‪.‬‬ ‫‪‬‬
‫כאשר ביטוי התנאי הבוליאני כבר לא מתקיים‪ ,‬ביצוע הלולאה מסתיים‪.‬‬ ‫‪‬‬
‫אם גוף הלולאה כולל רק הוראה אחת לביצוע‪ ,‬אז ניתן להשמיט את בלוק הסוגריים‬ ‫‪‬‬
‫המסולסלים {} התוחם את ההוראה‪ .‬כאשר גוף הלולאה כולל יותר מהוראה אחת‪,‬‬
‫חובה לתחום אותן בסוגריים מסולסלים‪.‬‬
‫יש לאתחל לפני הלולאה את המשתנים הנמצאים בביטוי התנאי הבוליאני המוצב‬ ‫‪‬‬
‫בכניסה ללולאה על מנת שבדיקת תנאי הלולאה בפעם הראשונה תיעשה על ערכים‬
‫רלוונטיים‪.‬‬
‫‪14‬‬
‫יש לעדכן במהלך גוף הלולאה את המשתנים הנמצאים בביטוי התנאי הבוליאני המוצב‬ ‫‪‬‬
‫בכניסה ללולאה על מנת להבטיח ביצוע תקין וסופי (מסתיים) של הלולאה‪.‬‬

‫‪15‬‬
 ‫דוגמה‪:‬‬

‫;‪int num = 16‬‬

‫)‪while (num > 0‬‬
‫;‪num = num - 3‬‬

‫טבלת מעקב ביצוע ללולאת הדוגמה‪:‬‬

‫‪num‬‬ ‫‪num > 0‬‬

‫‪16‬‬ ‫‪true‬‬
‫‪13‬‬ ‫‪true‬‬
‫‪10‬‬ ‫‪true‬‬
‫‪7‬‬ ‫‪true‬‬
‫‪4‬‬ ‫‪true‬‬
‫‪1‬‬ ‫‪true‬‬
‫‪-2‬‬ ‫‪false‬‬

‫שילוב משתנה בוליאני בתנאי לולאת ‪while‬‬

‫ניתן לשלב משתנה בוליאני בביטוי התנאי הבוליאני של לולאת ‪ ,while‬לדוגמה‪:‬‬

‫משתנה בוליאני ‪while (i < = 100 && !(found)) // found -‬‬

‫קינון של הוראות חזרה ‪ /‬לולאות מקוננות‬

‫לולאה מקוננת היא לולאה המכילה בתוכה לולאה‪.‬‬ ‫‪‬‬

‫לולאת ‪ for‬יכולה להכיל בתוכה לולאת ‪ for‬או לולאת ‪.while‬‬ ‫‪‬‬
‫לולאת ‪ while‬יכולה להכיל בתוכה לולאת ‪ for‬או לולאת ‪.while‬‬ ‫‪‬‬
‫בכל סבב של הלולאה החיצונית מתבצעת הלולאה הפנימית בשלמותה על כל סבביה !‬ ‫‪‬‬

‫דוגמה לקינון לולאות ‪:for‬‬

‫הדפסת תוצאות כל מכפלות הצירופים האפשריים בין המספרים ‪ 4-5‬לבין המספרים ‪// 1-3‬‬
‫)‪for (int i = 4 ; i < 6 ; i++‬‬
‫)‪for (int j = 1 ; j <= 3 ; j++‬‬
‫;)‪Console.WriteLine(i * j‬‬

‫טבלת מעקב ביצוע ללולאות הדוגמה‪:‬‬

‫‪i‬‬ ‫‪i<6‬‬ ‫‪j‬‬ ‫‪j <= 3‬‬ ‫פלט‬

‫‪4‬‬ ‫‪true‬‬ ‫‪1‬‬ ‫‪true‬‬ ‫‪4‬‬
‫‪2‬‬ ‫‪true‬‬ ‫‪8‬‬
‫‪3‬‬ ‫‪true‬‬ ‫‪12‬‬
‫‪4‬‬ ‫‪false‬‬ ‫‪-‬‬
‫‪5‬‬ ‫‪true‬‬ ‫‪1‬‬ ‫‪true‬‬ ‫‪5‬‬
‫‪2‬‬ ‫‪true‬‬ ‫‪10‬‬
‫‪3‬‬ ‫‪true‬‬ ‫‪15‬‬
‫‪4‬‬ ‫‪false‬‬ ‫‪-‬‬
‫‪6‬‬ ‫‪false‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫‪16‬‬
 ‫הוראת בחירה ‪switch case‬‬

‫הוראת הבחירה ‪ switch case‬שימושית כאשר נדרש לנתב את מהלך הביצוע של התוכנית‬
‫בהתאם לבחירה באחת מכמה אפשרויות של ערכים בדידים שונים‪.‬‬

‫מבנה כללי של ההוראה‪:‬‬

‫)ביטוי( ‪switch‬‬
‫{‬
‫;‪ ; break‬ערך‪ :‬קבוצת הוראות לביצוע ‪case‬‬
‫;‪ ; break‬ערך‪ :‬קבוצת הוראות לביצוע ‪case‬‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫;‪ ; break‬קבוצת הוראות לביצוע ‪default:‬‬
‫}‬

‫בביצוע ההוראה מחושב תחילה ערכו של הביטוי‪ ,‬ולאחר מכן הוא מושווה לערכים‬ ‫‪‬‬
‫המצויינים בחלופות ה‪ case-‬השונות‪ .‬מהשלב שבו מתקיים שיוויון בין ערך הביטוי המחושב‬
‫לבין ערך של ‪ case‬מסויים‪ ,‬מתבצעות כל ההוראות הנמצאות החל מקבוצת ההוראות‬
‫הצמודה לערך ‪ case‬זה ועד להוראת ה‪ break-‬הראשונה שאליה מגיעים ברצף ההוראות‪.‬‬
‫הוראת ה‪ break-‬גורמת לסיום הביצוע של הוראת ה‪.switch-‬‬

‫ערך הביטוי המחושב וערכי ה‪ case-‬יכולים להיות מטיפוס שלם ‪ ,int‬טיפוס תווי ‪ ,char‬טיפוס‬ ‫‪‬‬
‫בוליאני ‪ bool‬או טיפוס מחרוזתי (רצף תווים) ‪.string‬‬

‫קבוצת ההוראות הצמודה לחלופת ה‪ default-‬מתבצעת אם ערך הביטוי המחושב אינו שווה‬ ‫‪‬‬
‫לאף אחד מערכי ה‪ case-‬המצויינים‪ .‬אין חובה לכלול את חלופת ברירת המחדל ‪.default‬‬
‫במקרה שערך הביטוי המחושב אינו שווה לאף אחד מערכי ה‪ ,case-‬ואין חלופת ברירת מחדל‬
‫‪ ,default‬אז לא מבוצעת אף הוראה של ה‪.switch-‬‬

‫‪17‬‬
 :‫דוגמה‬

... if else if else ‫ כך שבמקום להשתמש בהוראות תנאי מקוננות‬,‫נייעל את כתיבת הקטע הבא‬
:switch case ‫נשתמש בהוראה‬

// day : 7-‫ ל‬1 ‫ מספר בין‬, ‫משתנה מטיפוס שלם המייצג את אחד מימות השבוע‬

if (day == 1)
Console.WriteLine("Sunday");
else
if (day == 2)
Console.WriteLine("Monday");
else
if (day == 3)
Console.WriteLine("Tuesday");
else
if (day == 4)
Console.WriteLine("Wednesday");
else
if (day == 5)
Console.WriteLine("Thursday");
else
if (day == 6)
Console.WriteLine("Friday");
else
if (day == 7)
Console.WriteLine("Saturday");
else
Console.WriteLine("Not Valid Day Number");

:switch case ‫קטע שקול ובו שימוש בהוראה‬

switch (day)
{
case 1: Console.WriteLine("Sunday");
break;
case 2: Console.WriteLine("Monday");
break;
case 3: Console.WriteLine("Tuesday");
break;
case 4: Console.WriteLine("Wednesday");
break;
case 5: Console.WriteLine("Thursday");
break;
case 6: Console.WriteLine("Friday");
break;
case 7: Console.WriteLine("Saturday");
break;
default: Console.WriteLine("Not Valid Day Number");
break;
}

18