משפט ה-switch ב-C הוא משפט חלופי להצהרת if-else-if ladder המאפשרת לנו לבצע מספר פעולות עבור ערכי האפשרויות השונים של משתנה בודד הנקרא משתנה switch. כאן, אנו יכולים להגדיר הצהרות שונות במקרים המרובים עבור הערכים השונים של משתנה בודד.

התחביר של הצהרת switch in שפה ג מובא להלן:

 switch(expression){ case value1: //code to be executed; break; //optional case value2: //code to be executed; break; //optional ...... default: code to be executed if all cases are not matched; } 

כללים להצהרת switch בשפת C

1. ה להחליף ביטוי חייב להיות מסוג מספר שלם או תו.
2. ה ערך מקרה חייב להיות מספר שלם או קבוע תו.
3. ה ערך מקרה ניתן להשתמש רק בתוך הצהרת switch.
4. ה הצהרת הפסקה במקרה מתג הוא לא חובה. זה אופציונלי. אם לא נמצאה הצהרת הפסקה בתיק, כל התיקים יבוצעו לאחר התיק המותאם. זה ידוע כ ליפול דרך המצב של משפט מתג C.

בואו ננסה להבין את זה לפי הדוגמאות. אנו מניחים שישנם משתנים הבאים.

 int x,y,z; char a,b; float f; 

תרשים זרימה של הצהרת מתג ב-C

תפקוד הצהרת מקרה מתג

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

כיצד פועלת הצהרת C switch?

בואו נעבור את התהליך שלב אחר שלב של אופן הפעולה של הצהרת ה-switch ב-C:

שקול את הדברים הבאים הצהרת switch :

תוכנית C:

 #include int main() { int num = 2; switch (num) { case 1: printf('Value is 1
'); break; case 2: printf('Value is 2
'); break; case 3: printf('Value is 3
'); break; default: printf('Value is not 1, 2, or 3
'); break; } return 0; } 

תְפוּקָה

 Value is 2 

תהליך שלב אחר שלב:

1. ה החלף משתנה num מוערך. במקרה הזה, על אחד מאותחל עם ערך 2 .
2. ה ערך מספר (2) מוערך מושווה עם הקבועים שצוינו בכל תווית מקרה בתוך בלוק מתג .
3. ה הצהרת switch תואם את ערך מוערך (2) עם הקבוע המצוין ב- מקרה שני (מקרה 2) . מכיוון שיש התאמה, התוכנית קופצת לגוש הקוד המשויך ל- מקרה תואם (מקרה 2) .
4. בלוק הקוד המשויך ל מקרה 2 מבוצע, אשר מדפיס 'הערך הוא 2' לקונסולה.
5. ה 'לשבור' מילת המפתח קיימת בגוש הקוד של מקרה 2 . כתוצאה מכך, התוכנית פורצת מהצהרת switch מיד לאחר ביצוע בלוק הקוד.
6. בקרת התוכנית נמשכת לאחר ה הצהרת switch , וכל הצהרות בעקבות ה הצהרת switch מוצאים להורג. במקרה זה, אין הצהרות לאחר המעבר, ולכן התוכנית מסתיימת.
7. ה הצהרת switch העריך את הערך של מספר משתנה , מצא התאמה למקרה 2, ביצע את בלוק הקוד המתאים, ולאחר מכן עזב את בלוק מתג בשל נוכחות ה הצהרת 'שבירה' .

דוגמה להצהרת switch ב-C

הבה נראה דוגמה פשוטה להצהרת החלפת שפת C.

 #include int main(){ int number=0; printf('enter a number:'); scanf('%d',&number); switch(number){ case 10: printf('number is equals to 10'); break; case 50: printf('number is equal to 50'); break; case 100: printf('number is equal to 100'); break; default: printf('number is not equal to 10, 50 or 100'); } return 0; } 

תְפוּקָה

מחרוזת לתווים ג'אווה

 enter a number:4 number is not equal to 10, 50 or 100 enter a number:50 number is equal to 50 

דוגמה 2 להחלפה

 #include int main() { int x = 10, y = 5; switch(x>y && x+y>0) { case 1: printf('hi'); break; case 0: printf('bye'); break; default: printf(' Hello bye '); } } 

תְפוּקָה

 hi 

Break ומילת מפתח ברירת מחדל בהצהרת Switch

תן לנו להסביר ולהגדיר את 'לשבור' ו מילות מפתח 'ברירת מחדל' בהקשר של הצהרת switch, יחד עם קוד ופלט לדוגמה.

1. מילת מפתח הפסקה:

ה מילת מפתח 'שבירה' משמש בתוך בלוק הקוד של כל מקרה כדי לסיים את הצהרת ה-switch בטרם עת. כאשר התוכנית נתקלת בא הצהרת 'שבירה' בתוך בלוק מארז, הוא יוצא מיד מה- הצהרת switch , מניעת ביצוע של בלוקים של תיקים הבאים. ה הצהרת 'שבירה' הוא חיוני כדי להימנע מהצהרות מתג' 'ליפול דרך' התנהגות.

דוגמא:

בואו ניקח תוכנית כדי להבין את השימוש ב- לשבור מילת מפתח ב-C.

 #include int main() { int num = 3; switch (num) { case 1: printf('Value is 1
'); break; // Exit the switch statement after executing this case block case 2: printf('Value is 2
'); break; // Exit the switch statement after executing this case block case 3: printf('Value is 3
'); break; // Exit the switch statement after executing this case block default: printf('Value is not 1, 2, or 3
'); break; // Exit the switch statement after executing the default case block } return 0; } 

תְפוּקָה

 Value is 3 

הֶסבֵּר:

בדוגמה זו, ה הצהרת switch מעריך את הערך של מספר משתנה (שזה 3 ) ומתאים אותו עם מקרה 3 . בלוק הקוד המשויך ל מקרה 3 מבוצע, הדפסה 'הערך הוא 3' לקונסולה. ה הצהרת 'שבירה' בְּתוֹך מקרה 3 מבטיחה שהתוכנית יוצאת מהצהרת ה-switch מיד לאחר ביצוע בלוק מקרה זה, ומונעת ביצוע של כל מקרים אחרים.

2. מילת מפתח ברירת מחדל:

כאשר אף אחד מה קבועי מקרה להתאים את ביטוי מוערך , הוא פועל כ תיק הכל . אם לא קיים מקרה תואם וא מקרה 'ברירת מחדל' קיים , בלוק הקוד המשויך ל- 'בְּרִירַת מֶחדָל' התיק מתנהל. הוא משמש לעתים קרובות לטיפול בנסיבות שבהן אף אחד מהמצבים המוצהרים אינו חל על הקלט שסופק.

דוגמא:

בואו ניקח תוכנית כדי להבין את השימוש ב- מילת מפתח ברירת מחדל ב-C.

 #include int main() { int num = 5; switch (num) { case 1: printf('Value is 1
'); break; case 2: printf('Value is 2
'); break; case 3: printf('Value is 3
'); break; default: printf('Value is not 1, 2, or 3
'); break; // Exit the switch statement after executing the default case block } return 0; } 

תְפוּקָה

 Value is not 1, 2, or 3 

הֶסבֵּר:

בדוגמה זו, ה הצהרת switch בוחן את ערכו של מספר משתנה (שזה 5 ). מכיוון שאף מקרה לא תואם את ה-num, התוכנית מבצעת את בלוק הקוד המשויך ל- מקרה 'ברירת מחדל' . ה הצהרת 'שבירה' בתוך ה מקרה 'ברירת מחדל' מבטיח שהתוכנית יוצאת מה- הצהרת switch לאחר ביצוע ה 'בְּרִירַת מֶחדָל' בלוק מקרה.

גם ה 'לשבור' ו מילות מפתח 'ברירת מחדל' לשחק תפקידים חיוניים בשליטה על זרימת הביצוע בתוך הצהרת switch. ה הצהרת 'שבירה' עוזר למנוע את התנהגות הנפילה, בעוד ה מקרה 'ברירת מחדל' מספק דרך לטפל במקרים שאין להם תחרות.

הצהרת C Switch היא נופלת

בשפת C, הצהרת המתג היא fall through; זה אומר שאם לא תשתמש בהצהרת break במקרה של ה-switch, כל המקרים לאחר מקרה ההתאמה יבוצעו.

הבה ננסה להבין את מצב הנפילה של הצהרת הבורר על ידי הדוגמה המובאת להלן.

 #include int main(){ int number=0; printf('enter a number:'); scanf('%d',&number); switch(number){ case 10: printf('number is equal to 10
'); case 50: printf('number is equal to 50
'); case 100: printf('number is equal to 100
'); default: printf('number is not equal to 10, 50 or 100'); } return 0; } 

תְפוּקָה

 enter a number:10 number is equal to 10 number is equal to 50 number is equal to 100 number is not equal to 10, 50 or 100 

תְפוּקָה

 enter a number:50 number is equal to 50 number is equal to 100 number is not equal to 10, 50 or 100 

הצהרת מקרה של מתג מקונן

אנחנו יכולים להשתמש בכמה משפט switch שנרצה בתוך הצהרת switch. סוג כזה של הצהרות נקרא הצהרות מקרה מקוננות של מתג. שקול את הדוגמה הבאה.

 #include int main () { int i = 10; int j = 20; switch(i) { case 10: printf('the value of i evaluated in outer switch: %d
',i); case 20: switch(j) { case 20: printf('The value of j evaluated in nested switch: %d
',j); } } printf('Exact value of i is : %d
', i ); printf('Exact value of j is : %d
', j ); return 0; } 

תְפוּקָה

 the value of i evaluated in outer switch: 10 The value of j evaluated in nested switch: 20 Exact value of i is : 10 Exact value of j is : 20 

יתרונות הצהרת המתג:

ישנם מספר יתרונות של הצהרת switch ב-C. כמה מהיתרונות העיקריים של הצהרת ה-switch הם כדלקמן:

קריאה ובהירות:ה הצהרת switch מספק דרך תמציתית וישירה לבטא הסתעפות רב כיוונית בקוד. טיפול במספר מקרים יכול להפוך את הקוד למאורגן יותר וקל יותר לקריאה מאשר מרובה הצהרות אם-אחרות מקוננות .יְעִילוּת:ה הצהרת switch הוא בדרך כלל יעיל יותר מסדרה של אם-אחר הצהרות כאשר מתמודדים עם מספר תנאים. זה עובד כמו ד שולחן קפיצה ישיר , מה שהופך אותו למהיר יותר ומוטב יותר מבחינת זמן הביצוע.לוגיקה מבוססת מקרה:ה הצהרת switch מתאים באופן טבעי לתרחישים שבהם התוכנית צריכה לקבל החלטות על סמך ערכים ספציפיים של משתנה בודד. זוהי דרך אינטואיטיבית וישירה ליישם לוגיקה מבוססת מקרה.

ה הצהרת switch תומך בשימוש במקרה ברירת מחדל המשמש כ- אפשרות לתפוס הכל עבור ערכים שאינם תואמים לאף מקרה מסופק. זֶה מקרה ברירת מחדל מטפל בתשומות או נסיבות חריגות שלא צוינו במפורש.

החסרונות של הצהרת הבורר:

ישנם מספר חסרונות של הצהרת switch ב-C. כמה חסרונות עיקריים של הצהרת ה-switch הם כדלקמן:

ביטויים מוגבלים:הביטוי המשמש ב- הצהרת switch חייב לגרום ל- ערך אינטגרלי (char, int, enum) או סוג נתונים תואם. זה לא יכול להתמודד עם יותר ביטויים מורכבים או לא קבועים , מגביל את זה גְמִישׁוּת בתרחישים מסוימים.חוסר יכולת להשוות טווחים:בניגוד הצהרות if-else , ה הצהרת switch לא יכול להתמודד ישירות עם טווחי ערכים. כל מקרה בהצהרת ה-switch מייצג ערך קבוע ספציפי, מה שהופך אותו למאתגר לטפל במגוון ערכים ביעילות.אין תמיכה במספרי נקודה צפה:ה הצהרת switch רק מקבל טיפוסים אינטגרלים (מספרים שלמים) וערכים מ מינונים ; הוא אינו מקבל מספרי נקודה צפה. זה לא מטפל סוגי נתונים לא אינטגרליים כמו מספרים שלמים של נקודה צפה , דבר שעשוי להיות בעייתי בנסיבות מסוימות.התנהגות נפילה: החלף הצהרות יש 'ליפול דרך' התנהגות כברירת מחדל, מה שמרמז שאם מקרה אינו כולל א הצהרת 'שבירה' , צוואה בביצוע 'ליפול דרך' לבלוק התיקים הבא. אם לא מנוהל כראוי, הדבר עלול לגרום להתנהגות לא רצויה.קוד כפול:באמצעות א הצהרת switch עלול לגרום לשכפול קוד בנסיבות מסוימות, במיוחד כאשר מקרים רבים דורשים את אותן פעולות. אם לא מנוהל כראוי, הדבר עלול לגרום לשכפול קוד.מתגים מקוננים יכולים להפוך למורכבים:כאשר מתמודדים עם מקונן להחליף הצהרות , הקוד יכול להיות מורכב ופחות קריא. זה עשוי לדרוש מאמץ נוסף כדי להבין ולתחזק מבנים מקוננים כאלה.