שפות תכנות זקוקות לספריות, פונקציות, תחביר ודברים אחרים כשעובדים איתן. לפיכך, יש סיכוי שהקודים שלנו יכילו שגיאות. לתכנות ב-C++ יש הרבה סוגים שונים של שגיאות. נדון בשגיאת 'אי אפשר להפנות את ה-int ב-C++' כאן. שגיאה זו מתרחשת כאשר אנו מנסים להשתמש באופרטור dereference '*' עם הנתונים מסוג מספר שלם 'int' מכיוון ש'int' הוא סוג נתונים פרימיטיבי. איננו יכולים להרחיק את ה-'int' בתכנות C++. כאן, השגיאה 'לא ניתן להגדיר את ה-int ב-C++' והפתרון שלה ייבדק ביסודיות. כמה קודים ניתנים במדריך זה בו נראה כיצד שגיאה זו מתרחשת וכיצד לטפל בשגיאה מסוג זה ב-C++.
דוגמה 1: Dereference Int
בקוד זה, ננסה להפנות את ה-'int' ב-C++. כעת, אנו פשוט כוללים את קובץ הכותרת 'iostream' כדי להשתמש בפונקציות המוגדרות. מתחת לזה, אנו משתמשים ב-'namespace std' ומפעילים כאן את שיטת 'main()'. לאחר מכן, אנו מכריזים על המשתנה 'my_num' עם סוג הנתונים 'int' ומקצים '99' למשתנה זה.
כעת, אנו מכריזים על 'my_value' של סוג הנתונים 'int' ומאתחלים אותו ב-'*my_num' מה שאומר שאנחנו מנסים להפנות את המשתנה 'my_num' שהוא מסוג הנתונים 'int'. השגיאה נוצרת בשורה זו בזמן הקומפילציה מכיוון שאיננו יכולים להפנות את ה-'int'. אנו רוצים להציג את הערך שאנו מקבלים לאחר ניתוק ה-int, אז אנו שמים את ה-'cout' שבו הוספנו את המשתנה 'my_value'.
קוד 1:
#include
שימוש במרחב שמות std;
int main ( ) {
int my_num = 99 ;
int my_value = * my_num;
cout << 'הערך שאנו מקבלים באמצעות זיהוי ה-int הוא:' << הערך_שלי << endl;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן, אנו עשויים לשים לב שלא מוצג ערך ומתרחשת שגיאה שאומרת שיש ארגומנט מסוג לא חוקי של '*'. משמעות הדבר היא שאיננו יכולים להרחיק את ה'int' ב-C++.
פתרון 1: ללא הרחקה
כאן, נקבל את ערך המספר השלם ישירות ללא ניתוק. אנו מייבאים את קובץ הכותרת 'iostream' מכיוון שחלק מהגדרות הפונקציות קיימות. לאחר מכן, אנו מקלידים את ה-'namespace std' יחד עם מילת המפתח 'using' ולאחר מכן קוראים לשיטת 'main()' כאן. כעת, אנו מאתחלים את המשתנה 'my_num' של סוג הנתונים 'int' עם הערך של '99'.
לאחר מכן, אנו מאתחלים משתנה נוסף בשם 'my_value' ומקצים לו את המשתנה 'my_num' המכיל את המספר השלם. לאחר מכן, אנו מקבלים את הערך השלם הזה ישירות מבלי להרחיק את הערך על ידי הצבת 'my_value' ב-'cout'. זה מקבל ומציג את הערך השלם.
קוד 1:
#includeשימוש במרחב שמות std;
int main ( ) {
int my_num = 99 ;
int my_value = my_num;
cout << 'הערך שאנו מקבלים מבלי להגדיר את הכוונה היא:' << הערך_שלי << endl;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
ערך המספרים השלמים מוצג כאן, אותו אנו מקבלים מבלי להתייחס בקוד C++ שלנו. אנו ניגשים ישירות לערך השלם הזה ומציגים אותו.
פתרון 2: על ידי הרחקת המצביע
קובץ הכותרת 'iostream' מכיל הגדרות פונקציה מסוימות; ייבאנו אותם. לאחר מכן, אנו מפעילים את הפונקציה 'main()' כאן לאחר הקלדת 'namespace std' ואת מילת המפתח 'using'. המשתנה 'my_num' של סוג הנתונים 'int' מאותחל כעת עם הערך של '99'.
לאחר מכן, אנו מאתחלים מצביע 'my_ptr' ומקצים את הכתובת של המשתנה 'my_num' למצביע זה. מתחת לזה, אנו מפנים את המצביע ומקצים את הערך שאנו מקבלים דרכו למשתנה 'my_value' כאשר אתחולנו את ה-'my_value' עם ה-'*my_ptr'. כעת, אנו מניחים את ה-'cout' בו אנו מעבירים את המשתנה 'my_value' כדי להציג את הערך השלם שאנו מקבלים באמצעות הפניית המצביע.
קוד 2:
#includeשימוש במרחב שמות std;
int main ( ) {
int my_num = 99 ;
int * my_ptr = & my_num;
int my_value = * my_ptr;
cout << 'הערך של int שאנו מקבלים עם הפניית מצביע הוא:' << הערך_שלי << endl;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
ערך המספר השלם שאנו מקבלים לאחר זיהוי המצביע בקוד שלנו מוצג כעת כאן. אז, זו הדרך הנכונה להחלת נקודת המוצא ב-C++.
דוגמה 2: Dereferencing Int
הבה ננסה להפנות את ה-'int' ב-C++ בקוד זה. כדי להשתמש בפונקציות המוגדרות ב- 'iostream', אנחנו רק צריכים לכלול את קובץ הכותרת 'iostream'. זה המקום שבו אנו משתמשים ב-'Namespace std' וקוראים לפונקציה 'main()'. לאחר מכן, אנו יוצרים את המשתנה 'a' ונותנים לו את סוג הנתונים 'int' יחד עם הערך של '75'.
מתחת לזה, אנו יוצרים מצביע בשם 'newPointer' ומקצים את הכתובת של המשתנה 'a' למצביע זה בעזרת '&'. לאחר מכן, אנו מאתחלים את המשתנה 'num' למטה עם '*a' המציין שאנו מנסים להפנות את המשתנה 'a' שהוא מסוג הנתונים 'int'. מכיוון שאיננו יכולים להפנות את ה'int', נוצרת כעת שגיאה בשורה זו במהלך ההידור. לאחר מכן, אנו משתמשים גם ב-'cout' שבו נוסיף את המשתנה 'num'.
קוד 2:
#includeשימוש במרחב שמות std;
int main ( ) {
int a = 75 ;
int * newPointer = & א;
מספר int = * א;
cout << 'הערך שמוצא את ה-int הוא:' << על אחד << endl;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן, אנו יכולים לראות שאין ערך מוצג ומופיעה הודעת שגיאה המציינת 'פרמטר סוג לא חוקי של unary'*'. זה מצביע על כך שלא ניתן להגדיר את ה-int ב-C++.
פתרון 1: ללא הרחקה
לא נזדקק להתייחסות כדי לקבל את הערך השלם באופן מיידי. אנו מייבאים אותו מכיוון שקובץ הכותרת 'iostream' מכיל הגדרות פונקציה מסוימות. לאחר מכן הפונקציה 'main()' מופעלת לאחר הזנת מילות המפתח 'using' ו-'namespace std'. המשתנה 'a' של סוג הנתונים 'int' מאותחל כעת עם הערך של '75'. לאחר מכן, אנו מכניסים את ה-'א' ל-'cout' כדי לקבל את הערך השלם הזה באופן מיידי ללא הפרש. זה מאחזר את הערך השלם ומציג אותו כאן.
קוד 1:
#includeשימוש במרחב שמות std;
int main ( ) {
int a = 75 ;
cout << 'הערך שאנו מקבלים ללא התייחסות היא:' << א << endl;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הערך השלם שמתקבל מקוד ה-C++ שלנו ללא ניתוק מובא כאן. ערך מספר שלם זה נגיש מיד והוא מוצג כאן.
פתרון 2:
אנו מייבאים את קובץ הכותרת 'iostream' המכיל כמה הגדרות פונקציה. כאן, אנו מקלידים את ה-'namespace std' ואת מילת המפתח 'using' לפני ביצוע הפונקציה 'main()'. הערך של '75' מוקצה למשתנה 'a'.
לאחר מכן, אנו מכריזים על מצביע בשם 'mypointer' ומאתחלים אותו עם הכתובת של המשתנה 'a' אליו. מתחת לזה, אנו מפנים את המצביע ומקצים את הערך שאנו מקבלים מזה למשתנה 'תוצאה' כאשר אנו מאתחלים את ה'תוצאה' עם '*mypointer'. לאחר זיהוי המצביע, אנו שמים את הפקודה 'cout' ומעבירים את המשתנה 'result' כדי להציג את הערך השלם.
קוד 2:
#includeשימוש במרחב שמות std;
int main ( ) {
int a = 75 ;
int * mypointer = & א;
תוצאה int = * mypointer;
cout << 'הערך שאנו מקבלים באמצעות הפניית המצביע הוא:' << תוֹצָאָה << endl;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
זוהי הטכניקה הנכונה ליישם ניתוק ב-C++. הוא מציג את הערך השלם שהשגנו לאחר ניתוק המצביע במקום ניתוק ה'int'.
סיכום
בדקנו שכאשר אנו מנסים לקבל את הערך על ידי הרחקת ה-'int' ב-C++, יתרחש 'פרמטר הסוג הלא חוקי של '*' בעל int' שגיאה לא חוקית, מה שאומר שלא ניתן להרחיק את ה-int ב-C++. הסברנו גם את הפתרון לשגיאה זו. השתמשנו בקוד שבו התרחשו השגיאות ובקודים שבהם סיפקנו את הפתרון של אותה שגיאה במדריך זה.