TechCodeview

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

שגיאות בזמן הידור

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

השגיאות בזמן ההידור יכולות להיות:

• שגיאות תחביר
• שגיאות סמנטיות

שגיאות תחביר

כאשר המתכנת אינו עוקב אחר התחביר של שפת תכנות כלשהי, אז המהדר יזרוק את שגיאת התחביר.

לדוגמה,

int a, b:

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

שגיאות סמנטיות

השגיאות הסמנטיות קיימות כאשר ההצהרות אינן משמעותיות עבור המהדר.

לדוגמה,

a+b=c;

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

את ההצהרה לעיל ניתן לכתוב מחדש כ:

c=a+b;

שגיאות בזמן ריצה

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

מיזוג מיון java

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

חלוקה באפס:

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

 #include int main() { int a = 10; int b = 0; int result = a / b; // Division by zero printf('Result: %d
', result); return 0; } 

תְפוּקָה:

 Floating point exception (core dumped) 

הֶסבֵּר:

א 'חריג נקודה צפה' הודעת שגיאה מופקת כאשר התוכנית נתקלת בבעיית זמן ריצה בגלל חלוקה באפס.

גישה למערך מחוץ לתחום:

א שגיאת זמן ריצה מתרחש כאשר נגישות לרכיב מערך מחוץ לגבולות מסוימים. שגיאה מתרחשת כאשר אינדקס גדול מגודל המערך וחוקי הגישה לזיכרון נשברים. הנה דוגמה:

 #include int main() { int arr[5] = {1, 2, 3, 4, 5}; int index = 10; int value = arr[index]; // Accessing array out of bounds printf('Value: %d
', value); return 0; } 

תְפוּקָה:

 Segmentation fault (core dumped) 

הֶסבֵּר:

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

הפניית מצביע Null:

א שגיאת זמן ריצה קורה כאשר אתה מנסה לגשת ל-a זיכרון null pointer כתובת, המכונה הסתייגות מצביע אפס. גישה למצביעי null גורמת להתנהגות בלתי צפויה מכיוון שהם אינם מצביעים על מיקומי זיכרון לגיטימיים . הנה דוגמה:

 #include int main() { int* ptr = NULL; // Null pointer int value = *ptr; // Null pointer dereference printf('Value: %d
', value); return 0; } 

תְפוּקָה:

 Segmentation fault (core dumped) 

הֶסבֵּר:

הניסיון ל התייחסות מצביע null מביא ל-a תקלת פילוח , מה שגורם לתוכנית לקרוס עם הודעת שגיאה.

הצפת מחסנית:

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

 #include void recursiveFunction() { recursiveFunction(); // Recursive call without termination condition } int main() { recursiveFunction(); return 0; } 

תְפוּקָה:

 Segmentation fault (core dumped) 

הֶסבֵּר:

התוכנית מתחילה רקורסיה אינסופית , אשר מציף את המחסנית וגורם לתקלת פילוח.

משתנים שאינם בשימוש:

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

 #include int main() { int uninitializedVariable; printf('Value: %d
', uninitializedVariable); // Using uninitialized variable return 0; } 

תְפוּקָה:

 Some random value (varies each time) 

הֶסבֵּר:

בדוגמה זו, הערך של an משתנה לא מאותחל יכול להיות כל ערך אקראי שנבחר באקראי מאזור הזיכרון המיועד לאותו משתנה.

בואו נסתכל על ההבדלים בין זמן הידור לזמן ריצה:

דוגמה לשגיאת זמן קומפילציה

 #include int main() { int a=20; printf('The value of a is : %d',a): return 0; } 

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

תְפוּקָה

דוגמה לשגיאת זמן ריצה

מעבר בהזמנה מראש

 #include int main() { int a=20; int b=a/0; // division by zero printf('The value of b is : %d',b): return 0; } 

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

תְפוּקָה

סיכום:

לסיכום, התקופות של פיתוח תוכנה ידוע כ זמן קומפילציה ו שגיאות זמן ריצה נפרדים, ולכל אחד יש סט ייחודי של תקלות שעלול להתרחש. שגיאות בזמן הידור קורה כאשר הקוד מומר לצורת הפעלה במהלך שלב ההידור. שגיאות אלו כוללות שגיאות סמנטיות , אשר מייצרים לֹא הֶגיוֹנִי אוֹ קוד אבסורדי , ו תקלות תחביר , הנוגדים את חוקי שפת התכנות. שגיאות אלו מזוהות על ידי מַהְדֵר ודיווח, חסימת הביצוע של הקוד עד שהם יתוקנו.

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