דוגמה 1:
ה-'iostream' כלול כאן, קובץ הכותרת בו מוצהרות מספר פונקציות. אנו משתמשים בפונקציות הללו המוצהרות בקובץ הכותרות הזה בקוד שלנו, לכן אנו כוללים את קובץ הכותרות הזה. לאחר מכן, יש לנו את ה-'std' שממוקם כאן שכן גם פונקציות כמו 'cin' ו-'cout' מוגדרות בו. אנחנו לא צריכים להקליד 'std' עם כל הפונקציות האלה אם נוסיף את ה-'namespace std' בתחילת הקוד שלנו. לאחר מכן, הפונקציה 'main()' מופעלת כאן, המכונה גם קוד מנהל ההתקן של תוכנית C++.
לאחר מכן, אנו משתמשים במילת המפתח 'נסה' כאן בה אנו מאתחלים את 'my_num1' עם הערך '35'. זהו משתנה סוג הנתונים 'int' כאן. כעת, אנו ממקמים את המשתנה הזה בתוך 'אם' ומציבים תנאי שאומר ש-'my_num1' חייב להיות גדול או שווה ל-'98'. אם התנאי הנתון מתקיים, הוא מתקדם בתוך 'אם' ומבצע את ההצהרה שנכתבה כאן. אנו משתמשים ב-'cout' ומכניסים הודעה שתוצג כאשר התנאי מתקיים.
לאחר מכן, אנו משתמשים במילת המפתח 'לזרוק' לאחר הצבת 'אחר'. במילת המפתח 'לזרוק' זו, אנו מעבירים את 'my_num1' כפרמטר. אנו מוסיפים את החלק 'לתפוס' מתחת לזה. אנו מכניסים את 'my_num2' כפרמטר של 'catch()' ואז משתמשים שוב ב-'cout' בתוך חלק ה-catch הזה. חלק זה מופעל רק כאשר מתרחש חריג בחלק 'נסה'.
קוד 1:
#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
לְנַסוֹת {
int שלי_מספר1 = 35 ;
אם ( שלי_מספר1 >= 98 ) {
cout << 'הגישה ניתנת כאן.' ;
} אַחֵר {
לזרוק ( שלי_מספר1 ) ;
}
}
לתפוס ( int שלי_מספר2 ) {
cout << 'הגישה נדחתה כאן.' << endl ;
cout << 'המספר הוא: ' << שלי_מספר2 ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
המספר שהזנו הוא '35' שהוא פחות מ-'98'. אז, החריג מתרחש שם והחלק 'catch()' מוצג. הגישה לחלק 'נסה' נדחית.
דוגמה 2:
אנו מניחים כאן את קובץ הכותרת 'iostream' ואת 'מרחב השמות std'. לאחר מכן, אנו יוצרים פונקציה 'division()' בה אנו מציבים שני פרמטרים שהם ה'מונה' וה'מכנה' של סוג הנתונים 'int'. הגדרנו את סוג הנתונים של פונקציית 'חלוקה' זו ל'כפול'.
מתחת לזה, נוסיף 'if()' שבו נוסיף את התנאי שהמכנה שווה לאפס. לאחר מכן, אנו משתמשים במילת המפתח 'לזרוק' ומקלידים שם הודעה. הודעה זו מוצגת בכל פעם שהחריג מתרחש בקוד זה בהתאם לתנאי. מתחת לזה, אנו משתמשים במילת המפתח 'החזרה' שבה אנו מציבים 'מונה/מכנה'. אז זה מחזיר את תוצאת החלוקה. כעת, הפונקציה 'main()' נקראת.
לאחר מכן, 'num1' ו-'num2' מאותחלים כמשתני 'int' ומקצים להם '89' ו- '0' בהתאמה. לאחר מכן, אנו מאתחלים את 'התוצאה' של סוג הנתונים 'כפול'. כאן אנו משתמשים במילת המפתח 'נסה'. בחלק זה, אנו מוסיפים משתנה 'תוצאה' זה ומקצים את הפונקציה 'division()' למשתנה זה. אנו מעבירים שני פרמטרים לפונקציה זו: 'num1' ו-'num2'. מתחת לזה, אנו מציגים את ה'תוצאה' שאנו מקבלים לאחר החלת הפונקציה 'חלוקה()'. לאחר מכן, אנו משתמשים גם ב-'catch' וממקמים את 'const char* msg' כדי להציג את ההודעה שהוספנו בעבר.
קוד 2:
#includeבאמצעות מרחב שמות סטד ;
לְהַכפִּיל חֲלוּקָה ( int מונה, int מְכַנֶה ) {
אם ( מְכַנֶה == 0 ) {
לזרוק 'חלוקה באפס לא אפשרית כאן!' ;
}
לַחֲזוֹר ( מוֹנֶה / מְכַנֶה ) ;
}
int רָאשִׁי ( ) {
int מספר 1 = 89 ;
int מספר 2 = 0 ;
לְהַכפִּיל תוֹצָאָה = 0 ;
לְנַסוֹת {
תוֹצָאָה = חֲלוּקָה ( מספר1, מספר2 ) ;
cout << תוֹצָאָה << endl ;
} לתפוס ( const לְהַשְׁחִיר * הודעה ) {
cerr << הודעה << endl ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
המספר שהכנסנו בעבר כמכנה הוא '0'. אז, החריג מתרחש בקוד והוא מציג את ההודעה הנתונה.
דוגמה 3:
נוצרת כאן הפונקציה 'כפיל ()' בה אנו ממקמים את ה'ערך' וה'מכפיל' כפרמטרים של סוג הנתונים 'int'. לאחר מכן, אנו משתמשים ב'אם' שבו נוסיף תנאי מכפיל השווה לאפס. לאחר מכן, 'זרוק' ממוקם במקום בו אנו מוסיפים הצהרה. לאחר מכן, יש לנו את ה'תשואה' שבה אנו מניחים את משתני ה'ערך * מכפיל' שהכרזנו בעבר. אז זה מחזיר כאן את תוצאת הכפל.
לאחר מכן, אנו קוראים ל-'main()' שבו אנו מצהירים על 'int value1' ו-'int value2' עם הערכים '34' ו-'0', בהתאמה. גם ה- 'int m_res' מוכרז ולאחר מכן נקרא הפונקציה 'כפל()' כאן. לאחר ביצוע פונקציה זו, התוצאה נשמרת כעת במשתנה 'm_res' ולאחר מכן מוצגת. לאחר מכן, אנו משתמשים בפונקציית 'תפוס' ומכניסים את ה-'const char* msg' כדי להציג את ההודעה שהוספנו בעבר בחלק 'הזרוק'.
קוד 3:
#includeבאמצעות מרחב שמות סטד ;
לְהַכפִּיל כֶּפֶל ( int ערך , int מַכפִּיל ) {
אם ( מַכפִּיל == 0 ) {
לזרוק 'אנחנו לא מכפילים את הערך באפס!' ;
}
לַחֲזוֹר ( ערך * מַכפִּיל ) ;
}
int רָאשִׁי ( ) {
int ערך1 = 3. 4 ;
int ערך2 = 0 ;
int m_res ;
לְנַסוֹת {
m_res = כֶּפֶל ( ערך1, ערך2 ) ;
cout << m_res << endl ;
} לתפוס ( const לְהַשְׁחִיר * הודעה ) {
cerr << הודעה << endl ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה :
מכיוון שלערך שהזנו בעבר יש '0' כמכפיל, לקוד יש חריג שגורם להצגת ההודעה כאן.
דוגמה 4:
כאן, אנו בונים את הפונקציה 'כפיל()' ומעבירים את ה-'number1' ו-'number2' כפרמטרים של סוג הנתונים 'int'. לאחר מכן, אנו משתמשים באופרטור 'אם' כדי להוסיף לו תנאי שהוא מכפיל הקטן או שווה לאפס. לאחר מכן, ההצהרה מתווספת היכן 'לזרוק' אמור להיות. תוצאת הכפל מוחזרת בסעיף 'החזר' שבו נכניס את המשתנה 'מספר1 * מספר2' שהכרזנו בעבר.
לאחר מכן, אנו מפעילים את הפונקציה 'main()' ומקצים את הערכים '34' ו-'12' ל-'int newNumber1' ו-'int newNumber2', בהתאמה. כאן, הפונקציה 'כפיל()' נקראת לאחר ההכרזה על ה-'int mResult'. כעת, התוצאה של פונקציה זו מאוחסנת במשתנה 'mResult' ומוצגת בהמשך. לאחר מכן אנו משתמשים בפונקציית 'תפוס' ומוסיפים את ה-'const char* msg' כדי להציג את ההודעה שכתבנו בסעיף 'זרוק'.
קוד 4:
#includeבאמצעות מרחב שמות סטד ;
לְהַכפִּיל לְהַכפִּיל ( int מספר 1 , int מספר 2 ) {
אם ( מספר 2 <= 0 ) {
לזרוק 'אנחנו לא מכפילים את הערך בערך אפס או שלילי!' ;
}
לַחֲזוֹר ( מספר 1 * מספר 2 ) ;
}
int רָאשִׁי ( ) {
int newNum1 = 3. 4 ;
int newNum2 = 12 ;
int mResult ;
לְנַסוֹת {
mResult = לְהַכפִּיל ( newNum1, newNum2 ) ;
cout << 'התוצאה של הכפל היא' << mResult << endl ;
}
לתפוס ( const לְהַשְׁחִיר * הודעה ) {
cerr << הודעה << endl ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הערך שאנו מוסיפים הוא '12' עליו נוסיף את התנאי. אז, הפונקציה 'כפיל()' מבוצעת מכיוון שהתנאי אינו נכון. התוצאה של הכפל מוצגת. החלק 'נסה' מבוצע כאן.
סיכום
המושג 'תפוס' והקודים במדריך זה נלמדים בפירוט. חקרנו ביסודיות את הרעיון של 'תפוס ניסיון' והראינו איך זה עובד בתכנות C++. הגדרנו שהמונח 'זרוק' יוצר חריג כאשר נמצאה שגיאה המאפשרת לנו לכתוב את הקוד הייחודי שלנו. באמצעות הביטוי 'תפוס', אנו יכולים לציין גוש קוד שיופעל אם מופיע חריג בחלק ה'נסה'.