מהי החלטה בתכנות C?
בתכנות C, קבלת החלטות היא מיומנות ליבה שמתכנתים צריכים לשלוט בה כדי לבנות תוכניות יעילות. קבלת החלטות היא תהליך של הערכת תנאים שונים ובחירת דרך הפעולה הטובה ביותר על סמך התוצאות. עם הצהרת אם-אחר, קבלת החלטות מיושם ב-C. החלטות מבוססות על תנאים ומתקבלות באמצעות הצהרת if-else. אם התנאי נכון, הקוד פועל; מצד שני, אם הוא שקר, הקוד הכלול במשפט else מופעל.
מה זה הסתעפות בתכנות C?
בתכנות C, מִסעָף היא הטכניקה המאפשרת לזרימת הביצוע להשתנות בהתאם לתוצאה של תנאי. מִסעָף מאפשר לתוכנית להפעיל בלוקים ספציפיים של קוד בהתאם לתוצאה של נסיבות ספציפיות.
ישנם סוגים שונים של הסתעפות בתכנות C, כולל אחרת , החלף , ו מפעילים מותנים . ב הצהרת switch , התוכנית מעריכה ערך ובוחרת את האפשרות הרלוונטית מרשימת המקרים הזמינים. אופרטורים מותנים הם קיצור אחרת הצהרות המאפשרות לך לכתוב קוד קצר יותר.
החלטות והסתעפות בתכנות C
ה קבלת החלטות תהליך בתכנות C כולל שימוש בהצהרות מותנות כדי לשלוט בזרימת ביצוע התוכנית. מִסעָף מאפשר לתוכנית להפעיל קבוצות שונות של קוד על סמך התוצאה של תנאים מסוימים.
בתכנות C, קבלת החלטות , ו מִסעָף מושגות באמצעות:
- אם הצהרה
- הצהרת if-else
- להחליף הצהרה
- מקונן אם
- אחרת-אם סולם
- הצהרת הפסקה
- להמשיך בהצהרה
1: אם הצהרה
השיטה הפשוטה ביותר של קבלת החלטות המוצע על ידי תכנות C הוא אם הצהרה . ה אם הצהרה בודק תנאי נתון ומבצע את הקוד בגוף ההצהרה אם התנאי נכון. אחרת, התוכנית מתעלמת מבלוק הקוד המשויך ל- אם הצהרה , והוא ממשיך עם הקוד הבא.
התחביר עבור אם-הצהרה הוא:
אם ( מַצָב )
{
בלוק הצהרות;
}
תסתכל על הקוד למטה:
#includeint main ( )
{
מספר int = עשרים ;
אם ( על אחד > 5 )
{
printf ( 'מספר גדול מ-5 \n ' ) ;
}
printf ( 'ערך המספר הוא: %d \n ' , על אחד ) ;
לַחֲזוֹר 0 ;
}
הקוד לעיל מגדיר משתנה ' על אחד ' עם ערך של 20 ומשתמש במשפט if כדי לבדוק אם הוא גדול מ-5. אם כן, התוכנית מדפיסה ' מספר גדול מ-5 '. לבסוף, הוא מדפיס את הערך של ' על אחד '.
תְפוּקָה
2: הצהרת if-else
הצהרת if-else היא שינוי של הצהרת if המאפשרת ביצוע של בלוקי קוד שונים בהתבסס על האם התנאי אמת או שקר.
אם ( מַצָב ) {// קוד לביצוע אם התנאי הוא נָכוֹן
} אַחֵר {
// קוד לביצוע אם התנאי הוא שֶׁקֶר
}
כתוצאה מכך, בלוק הקוד הראשון יבוצע אם התנאי הוא אמת, ובלוק הקוד השני יתבצע אם התנאי הוא שקר.
שקול את הקוד הבא כדוגמה:
#includeint main ( )
{
מספר int = 10 ;
אם ( על אחד > 5 )
{
printf ( 'מספר גדול מ-5 \n ' ) ;
} אַחֵר {
printf ( 'מספר הוא פחות מ-10' ) ;
}
לַחֲזוֹר 0 ;
}
התוכנית לעיל יוצרת את המשתנה num ונותנת לו את הערך 10. לאחר מכן, באמצעות an אם הצהרה , הוא קובע אם ' על אחד ' גדול מ-5. ה-' מספר גדול מ-5 ' מודפס אם ' על אחד ' עולה על 5. הוא מציג ' מספר קטן מ-10 ' אם המספר אינו גדול מ-5. התוכנית מחזירה 0, מסמן שהיא רצה בהצלחה.
תְפוּקָה
3: החלף הצהרת
עוד כלי חשוב עבור קבלת החלטות בתכנות C הוא ה החלף הַצהָרָה. ה החלף הצהרה בודקת תנאים ספציפיים בדיוק כמו אם-אחר הצהרות לעשות, אבל זה יכול לבדוק אפשרויות מרובות עבור המצב הזה. זה מועיל כאשר אנו מתמודדים עם הרבה תוצאות שונות.
התחביר לשימוש ב- הצהרת switch בתכנות C הוא:
החלף ( ביטוי ) {מקרה קבוע1:
// קוד לביצוע אם ביטוי שווה קבוע1
לשבור ;
מקרה קבוע2:
// קוד לביצוע אם ביטוי שווה קבוע2
לשבור ;
...
בְּרִירַת מֶחדָל:
// קוד לביצוע אם אף אחד מהמקרים לא תואם
לשבור ;
}
ביטוי האם המשתנה המוערך במקרה זה, וה- הצהרות מקרה לכלול את הערכים המשווים אליו.
שקול את הקוד הבא כדוגמה:
#includeint main ( ) {
מספר int = 2 ;
החלף ( על אחד ) {
מקרה 1 :
printf ( 'מספר הוא 1' ) ;
לשבור ;
מקרה 2 :
printf ( 'המספר הוא 2' ) ;
לשבור ;
מקרה 3 :
printf ( 'המספר הוא 3' ) ;
לשבור ;
בְּרִירַת מֶחדָל:
printf ( 'מספר אחר מ-1, 2 ו-3' ) ;
לשבור ;
}
לַחֲזוֹר 0 ;
}
התוכנית לעיל מראה כיצד להשתמש במשפט switch כדי לבחון את הערך של המשתנה ' על אחד ' והפעל את גוש הקוד הרלוונטי. במקרה זה, מאז ' על אחד ' מאותחל ל-2, הפלט יהיה ' מספר הוא 2 '.
תְפוּקָה
4: מקונן אם
הצהרות אם הם הצהרות מסועפות המוטמעות בתוך הצהרות if מקוננות אחרות. זה מאפשר הגיון הסתעפות מורכב יותר על ידי בדיקת מספר תנאים בתוך הצהרות מותנות אחרות. הפנימי אם הצהרות מבוצעות רק אם הצהרות ה-outer if מוערכות כ-true.
התחביר הבסיסי עבור הצהרות אם מקוננות מובאים להלן:
אם ( מַצָב ) {אם ( ביטוי ) {
בלוק הצהרות;
} אַחֵר {
בלוק הצהרות;
}
} אַחֵר {
בלוק הצהרות;
}
שקול את הקוד הבא כדוגמה:
#includeint main ( ) {
int num1 = 1 ;
int num2 = חֲמֵשׁ עֶשׂרֵה ;
int num3 = 7 ;
אם ( מספר 1 > מספר 2 ) {
אם ( מספר 1 > מספר 3 ) {
printf ( 'num1=1 הוא המספר הגדול ביותר \n ' ) ;
}
אַחֵר {
printf ( 'num3=7 הוא המספר הגדול ביותר \n ' ) ;
}
}
אַחֵר {
אם ( מספר 2 > מספר 3 ) {
printf ( 'num2=15 הוא המספר הגדול ביותר \n ' ) ;
}
אַחֵר {
printf ( 'num3=7 הוא המספר הגדול ביותר \n ' ) ;
}
}
לַחֲזוֹר 0 ;
}
התוכנית לעיל משווה שלושה מספרים שלמים, ' מספר 1 ', ' מספר 2 ', ו' מספר 3 ', ומשתמש בהצהרות אם מקוננות כדי לקבוע איזה מהם הוא המספר הגדול ביותר. זה קודם משווה ' מספר 1 ' ו' מספר 2 ', ואז משווה את הגדול מבין השניים האלה עם ' מספר 3 '. הפלט יציין לאיזה משתנה יש את הערך הגדול ביותר.
תְפוּקָה
5: אחרת-אם סולם
אנו עשויים בקלות לפתור בעיה מורכבת כאשר קיימים קריטריונים רבים בסדר עוקב על ידי שימוש ב-a סולם-אם אוֹ ביטוי אחר-אם .
להלן התחביר עבור אחרת-אם סולם הַצהָרָה:
אם ( מצב 1 ){
בלוק הצהרות;
}
אַחֵר אם ( מצב2 )
{
בלוק הצהרות;
}
אַחֵר אם ( מצב 3 )
{
בלוק הצהרות;
}
אַחֵר
{
הצהרת ברירת מחדל
}
שקול את הקוד הבא כדוגמה:
#includeint main ( ) {
int סימנים = 80 ;
אם ( סימנים > = 90 && סימנים = 80 && סימנים = 70 && סימנים = 60 && סימנים = חמישים && סימנים < 60 ) {
printf ( 'כיתה: D' ) ;
}
אַחֵר {
printf ( 'ציון: נכשל' ) ;
}
לַחֲזוֹר 0 ;
}
התוכנית לעיל מעסיקה אם-אחר היגיון לקבוע ציון לפי הערך הנוכחי של המשתנה 'ציונים'. בהתאם לערך של 'ציונים', התוכנית תוציא ציון מקביל החל מ-A+ ועד נכשל.
תְפוּקָה
6: הצהרת הפסקה
ה הצהרת הפסקה היא הצהרת זרימת בקרה חשובה בתכנות C המאפשרת למתכנתים לשלוט בהתנהגות של לולאות והצהרות מתג. ה הצהרת הפסקה יש שני יישומים בתכנות C:
- כאשר לולאה מגיעה ל-a לשבור הצהרה, היא מסתיימת באופן מיידי, ושליטה בתוכנית מועברת להצהרה שעוקבת אחרי הלולאה.
- ניתן להשתמש בו כדי לסיים תיק על ידי שימוש בו למשפט ה-switch.
התחביר עבור ה לשבור הַצהָרָה:
לשבור ;תסתכל על הקוד לדוגמה:
#includeint main ( ) {
מספר int = 12 ;
בזמן ( על אחד חֲמֵשׁ עֶשׂרֵה ) {
לשבור ;
}
}
לַחֲזוֹר 0 ;
}
חלק זה של קוד C מכריז על לולאת while שפועלת כל עוד המשתנה השלם ' על אחד ' הוא פחות מ-22 ומאתחל אותו ל-12. בלולאה, ' על אחד ” מוגדל ב-1 והערך שלו מדווח לקונסולה באמצעות printf . לאחר מכן מסתיימת הלולאה עם a משפט הפסקה אם 'מספר' גדול מ-15 כפי שנקבע על ידי הצהרת if. קוד זה למעשה מסיים את הלולאה לאחר הדפסת הערכים של 'num' בין 12 ל-15 (כולל). התוכנית מסתיימת בהחזרת 0, מה שמראה שהיא רצה כהלכה.
תְפוּקָה
7: המשך הצהרה
בתכנות C, ה לְהַמשִׁיך הצהרה דומה ל- לשבור הַצהָרָה. במקום להטיל סיום, הוא מאלץ את האיטרציה הבאה של הלולאה ומדלג על כל קוד שביניהם. קטעי הבדיקה המותנית וההגדלה של לולאת for מבוצעים על ידי ה לְהַמשִׁיך ביטוי. המבחנים המותנים של לולאות ה-while וה-Do-While עוברות על ידי בקרת התוכנית כתוצאה מה- לְהַמשִׁיך הַצהָרָה.
תחביר של להמשיך בהצהרות הוא:
לְהַמשִׁיך ;תסתכל על הדוגמה הזו.
#includeint main ( ) {
מספר int = 12 ;
בזמן ( על אחד חֲמֵשׁ עֶשׂרֵה ) {
לְהַמשִׁיך ;
}
}
לַחֲזוֹר 0 ;
}
לולאת while בתוכנית לעיל משמשת להדפסת הערך של המשתנה ' על אחד ' אם הוא קטן מ-22. אם ' על אחד ” עולה על 15 במהלך הלולאה, ה לְהַמשִׁיך ההצהרה מבוצעת, והאיטרציה הנוכחית של הלולאה מדלגת. במקרה זה, הלולאה תתבצע חמש פעמים, ותדפיס את הערך של 'num' בכל פעם, עד ' על אחד ' מגיע ל-16 והלולאה מדלגת על האיטרציה שבה ' על אחד ” הוא 16, ואז ממשיך עם האיטרציות הנותרות עד שהלולאה מסתיימת.
תְפוּקָה
סיכום
קבלת החלטות ו מִסעָף הם רכיבים קריטיים של שפת C המאפשרים ליצור יישומים מורכבים ואינטראקטיביים המטפלים בתנאים שונים בעולם האמיתי. ההצהרות המותנות, if-else ו-switch, הם המקרים העיקריים שבהם נעשה שימוש ביצירה מבוסס החלטות אלגוריתמים. למרות ש מִסעָף עשוי להוות אתגר בארגון הקודים, עם תכנון וביצוע נכונים, מתכנתים יכולים ליצור תוכנות יעילות וללא שגיאות העונות על דרישות ספציפיות.