תכנות מובנה

מתוך ויקיפדיה, האנציקלופדיה החופשית
קפיצה אל: ניווט, חיפוש

תכנות מובנה הוא פרדיגמת תכנות המיועדת לשיפור הבהירות והאיכות של תוכנית מחשב, תוך קיצור משך הפיתוח, באמצעות שימוש נרחב בשגרות ובלוקים ובמבני בקרת זרימה מסוג Do while, והימנעות משימוש בפקודת goto, ששימוש נרחב בה מביא ליצירתו של "קוד ספגטי", שלקורא קשה מאוד להתמצא בו.

המעבר מפקודת goto לתכנות המובנה[עריכת קוד מקור | עריכה]

פקודת goto הייתה פקודת בקרת זרימה יסודית בשפות תכנות פופולריות של שנות ה-60 של המאה ה-20, כגון COBOL ו-BASIC, והייתה בשימוש נרחב גם בשפות תכנות שבהן הייתה פחות חיונית, כגון Fortran ו-PL/I. הפקודה מאפשרת ביצוע קפיצה ברצף הביצוע של התוכנית, לפי שיקולי המתכנת. בדרך זו ניתן לחסוך שכפול קוד, ולהגיע לביצועים אופטימליים. עם זאת, שימוש מופרז בפקודה goto יוצר תוכנית חסרת מבנה ברור, מה שנקרא "קוד ספגטי" (בשל הקושי לעקוב אחר מסלול הבקרה), שמקשה על כתיבת קוד נטול באגים, וקשה מאוד לתחזק או להרחיב אותו.

משפט התכנות המובנה משנת 1966 ומאמרו הנודע משנת 1968 של אדסחר דייקסטרה, "Go To Statement Considered Harmful",[1] הובילו לשלילת השימוש בפקודת goto. לטענת דייקסטרה ורבים אחרים, ניתן לכתוב כל תוכנית מחשב ללא שימוש בפקודת goto. גישתו של דייקסטרה הפכה למקובלת ביותר בעולם התכנות, אך אל מול שלילה מוחלטת של הפקודה הציב דונלד קנות' גישה המתירה שימוש בפקודה במקרים מסוימים, במאמרו "Structured Programming with go to Statements".[2]

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

מאז שנות ה-70 של המאה ה-20, כחלק ממוסכמות תכנות מקצועי, נחשבת פקודת goto מוקצה מחמת מיאוס, וזאת על מנת להקל על תחזוקה והרחבה של קוד קיים: קוד אשר משתמש ב־goto, ולו לעתים נדירות, עלול ליצור תופעות לוואי שקשה לעקוב אחריהן, ומקשה על הבנה של קוד ירושה. מוסכמה זו נאכפת לרוב גם בשפות המאפשרות שימוש ב־goto. עם זאת, במקרים כגון יציאה מקינון מרובה, שימוש ב־goto עשוי להיות הפתרון הנכון (במקרים כאלו ניתן להשתמש בשפות תכנות חדשות במנגנון הטיפול בשגיאות על מנת להשיג תוצאה דומה). בשפות תכנות חדשות, כגון Java, לא ניתן להשתמש פקודת goto.

מרכיבים[עריכת קוד מקור | עריכה]

מבני בקרת זרימה[עריכת קוד מקור | עריכה]

משפט התכנות המובנה יצר את הבסיס התאורטי לתכנות המובנה, בכך שקבע שניתן לכתוב כל תוכנית תוך התבססות על שלושת מבני הבקרה הבאים בלבד:

  • רצף: הפקודות מבוצעות לפי סדר הופעתן בתוכנית.
  • בחירה: פקודה (או קבוצת פקודות) מבוצעת בהתאם לתנאי הנבדק בתוכנית באמצעות פקודת תנאי.
  • איטרציה (לולאה): פקודה (או קבוצת פקודות) מבוצעת שוב ושוב, עד להתקיימותו של תנאי מסוים. נכתבת באמצעות פקודות כגון while, repeat, for או do..until.
תרשימי זרימה המתארים את מבני הבקרה הבסיסיים בתכנות מובנה: רצף, בחירה ולולאה

לשם התאמה משופרת לתכנות מובנה, בשנות ה-70 נערכו בשפת PL/I שינויים אחדים לשיפור בקרת הזרימה: נוספה פקודת LEAVE ליציאה מתוך לולאה, לפקודת DO נוספו האופציות UNTIL ו-REPEAT, ונוספה פקודה לבחירה מרובה בצורה SELECT (expression) {WHEN (expression) group}... OTHERWISE group. גם בשפות תכנות ותיקות אחרות נוספה במשך השנים תמיכה בתכנות מובנה. שפות תכנות מודרניות תוכננו מלכתחילה עם תמיכה בתכנות מובנה.

שגרות[עריכת קוד מקור | עריכה]

שגרה (באנגלית: Subroutine), פרוצדורה (באנגלית: Procedure) או שיטה (באנגלית Method) היא רצף של פקודות המאוגדות יחדיו, במטרה לבצע מטלה מוגדרת, מימוש של אלגוריתם. קריאה לשגרה היא הפעלה שלה תוך כדי פעולת התוכנית. שגרה יכולה שלא לקבל קלט, לקבל קלט יחיד או מספר של קלטים כלשהם. שימוש מושכל בשגרות עשוי לשפר את מבנה התוכנית, את קריאות הקוד ואת מידת הגמישות של התוכנית לביצוע שינויים. שימוש בשגרות מאפשר חלוקה של קוד לחלקים קצרים - שגרות - וכך מקל על וידוא נכונות של כל אחד מחלקי הקוד בנפרד. תוצאה זו מאפשרת להפחית במידה משמעותית את עלויות הפיתוח והתחזוקה של תוכנה.

בלוקים[עריכת קוד מקור | עריכה]

בלוק הוא קבוצת פקודות שניתן להתייחס אליהן כאל פקודה אחת. בשפות תכנות התומכות בבלוקים יש תחביר המאפשר לזהות את תחילתו וסופו של בלוק, למשל הצירוף BEGIN..END ב-PL/I, הזחה בפייתון וסוגריים מסולסלים {...} ב-C ובשפות נוספות.

יציאה מוקדמת משגרה או מלולאה[עריכת קוד מקור | עריכה]

אף שעקרונות התכנות המובנה מומשו בשפות תכנות רבות, חריגה בולטת מעקרונות אלה היא פקודת return, המאפשרת יציאה מוקדמת מתוך שגרה (בניגוד לגישה המחייבת יציאה משגרה רק לאחר הפקודה האחרונה שבה), פקודת break, המאפשרת באופן דומה יציאה מוקדמת מתוך לולאה, ופקודת continue, המציינת להפסיק איטרציה מסוימת בלולאה תוך מעבר לאיטרציה הבאה (אלה בניגוד לגישה המחייבת יציאה מלולאה רק לאחר הפקודה האחרונה שבה). ריבוי נקודות יציאה עלול ליצור באגים, עקב הימנעות אפשרית מביצוע פעולות שחובה לבצען לפני היציאה. יש התומכים בקיום פקודות אלה, המאפשרות קוד פשוט יותר. לעומתם טען ברטראן מייר (Bertrand Meyer) שפקודות אלה הן למעשה פקודת goto בשינוי אדרת, והמליץ בתוקף שלא להשתמש בהן.[4]

לקריאה נוספת[עריכת קוד מקור | עריכה]

  • O.-J. Dahl, E. W. Dijkstra, C. A. R. Hoare, Structured Programming, Academic Press, 1972
  • Richard C. Linger, Bernard I. Witt, H. D. Mills, Structured Programming: Theory and Practice, Addison-Wesley, 1979

קישורים חיצוניים[עריכת קוד מקור | עריכה]

הערות שוליים[עריכת קוד מקור | עריכה]

  1. ^ E. W. Dijkstra, Go To Statement Considered Harmful, Communications of the ACM, 1966
  2. ^ Structured Programming with go to Statements, Computing Surveys, 1974
  3. ^ An Introduction to structured programming in Cobol, IBM, 1975
    An Introduction to Structured Programming in PL/I, IBM, 1976
    An Introduction to Structured Programming in FORTRAN, IBM, July 1977
  4. ^ Bertrand Meyer, Touch of Class: Learning to Program Well with Objects and Contracts, Springer Science & Business Media, 2009, p. 189