מהו מצביע ריק (ריק*)?
מצביע ריק, המכונה גם מצביע גנרי, הוא מצביע שאינו משויך לשום סוג נתונים ספציפי, מה שהופך אותו למתאים להצבעה על כל סוג של נתונים. במילים אחרות, א מצביע ריק יכול להצביע על מספר שלם, תו, מחרוזת או כל סוג נתונים אחר. גמישות זו הופכת את מצביעי הריק לכלי רב עוצמה בתכנות C ו-C++.
הצהרת מצביע ריק ב-C ו-C++
ב-C ו-C++, ה מצביע ריק מוצהר באמצעות התחביר הבא:
בָּטֵל * ptr ;
שימוש ב-Void Pointers ב-C ו-C++
מצביעים בטלים ב-C משמשים בעיקר כאשר סוג הנתונים של משתנה אינו ידוע או יכול להשתנות בזמן הריצה. הם מאפשרים דרך גנרית לאחסן ולתפעל נתונים מבלי צורך לדעת את סוג הנתונים הספציפי שלו. זה מועיל במיוחד כאשר עוסקים בפונקציות או מבני נתונים שיכולים להתמודד עם סוגים שונים של נתונים.
שימוש נפוץ אחד של מצביעים ריק נמצא בפונקציות הקצאת זיכרון כגון malloc() אשר מחזירה נקודת מצביע ריק לבלוק זיכרון שניתן להשתמש בו לאחסון כל סוג נתונים. לאחר מכן, המתכנת יכול להטיל את מצביע הריק לסוג הנתונים המתאים כדי לגשת ולתפעל את הנתונים המאוחסנים בבלוק הזיכרון שהוקצה.
שימוש נוסף במצביעי ריק ב-C הוא ב מצביעי פונקציה , שהם משתנים המאחסנים את כתובת הזיכרון של פונקציה. ניתן להשתמש במצביעי ריק כדי לאחסן את כתובת הזיכרון של כל פונקציה, ללא קשר לסוג ההחזר או רשימת הפרמטרים שלה, מה שמאפשר גמישות רבה יותר בשימוש במצביעי פונקציה.
השימוש של מצביעים ריק ב-C++ כמעט דומה, עם זאת, ניתן להשתמש בהם גם ליצירת ממשק גנרי עבור אובייקטים ממחלקות שונות. זה מושג לעתים קרובות באמצעות שימוש בפונקציות וירטואליות, המאפשרות לטפל באובייקטים ממחלקות שונות באופן אחיד. יתר על כן, C++ מציע בדיקת סוגים קפדנית יותר מאשר C, מה שאומר ששימוש מצביעים ריק באופן שגוי עלול לגרום ליותר שגיאות ובאגים.
נקודות שכדאי לקחת בחשבון בעת שימוש ב- Void Pointers ב-C ו-C++
להלן מספר נקודות שכדאי לשקול בעת השימוש מצביעים ריק ב-C ו-C++.
1: ב-C, בָּטֵל* יכול לשמש כערך החזרה ופרמטר פונקציה אבל ב-C++ אתה חייב להיות מצביע מסוג נתונים ספציפי.
לדוגמה:
ב-C, הקוד ניתן להלן:
#include#include
בָּטֵל * add_numbers ( int א , int ב ) {
int * תוֹצָאָה = malloc ( מידה של ( int ) ) ;
* תוֹצָאָה = א + ב ;
לַחֲזוֹר ( בָּטֵל * ) תוֹצָאָה ;
}
בָּטֵל הדפס_תוצאה ( בָּטֵל * תוֹצָאָה ) {
int * ptr = ( int * ) תוֹצָאָה ;
printf ( 'התוצאה היא: %d \n ' , * ptr ) ;
חינם ( ptr ) ;
}
int רָאשִׁי ( ) {
int מספר 1 = 5 , מספר 2 = 7 ;
בָּטֵל * תוֹצָאָה = add_numbers ( מספר 1 , מספר 2 ) ;
הדפס_תוצאה ( תוֹצָאָה ) ;
לַחֲזוֹר 0 ;
}
הקוד לעיל מגדיר פונקציה add_numbers() שמחזיר א בָּטֵל* מצביע לתוצאה של הוספת שני מספרים שלמים שהועברו כארגומנטים. הפונקציה print_result() לוקח מצביע ריק* ומדפיס את התוצאה. בפונקציה main() אנו קוראים add_numbers() ולהעביר את המתקבל מצביע ריק* ל print_result() להדפסה.
ב-C++, נדרש סוג נתונים ספציפי.
#includeבאמצעות מרחב שמות std ;
בָּטֵל printInt ( int * על אחד ) {
cout << 'המספר השלם הוא:' << * על אחד << endl ;
}
int רָאשִׁי ( ) {
int איקס = 10 ;
int * ptr = & איקס ;
printInt ( ptr ) ;
לַחֲזוֹר 0 ;
}
2: ב-C, אתה יכול להמיר את מצביע הריק לסוג מצביע אחר דרך המרה מרומזת. אבל ב-C++ אתה צריך להשתמש ב- המרה מפורשת כדי להמיר את מצביע ריק לכל סוג מצביע אחר.
הנה דוגמה פשוטה של קוד עבור C ו-C++ כדי להמחיש את ההבדל בין משתמע ו המרה מפורשת שֶׁל מצביעים ריק לסוגי מצביעים אחרים:
ב-C משתמשים בקוד הבא:
#includeבָּטֵל printChar ( בָּטֵל * ch ) {
לְהַשְׁחִיר ג = * ( לְהַשְׁחִיר * ) ch ;
printf ( '%c \n ' , ג ) ;
}
int רָאשִׁי ( ) {
לְהַשְׁחִיר ג = 'א' ;
בָּטֵל * ptr = & ג ;
printChar ( ptr ) ;
לַחֲזוֹר 0 ;
}
הקוד לעיל מגדיר פונקציה printChar שלוקח מצביע ריק כפרמטר ומדפיס את התו המאוחסן במיקום הזיכרון הזה. בפונקציה הראשית, משתנה char ג מוגדר והכתובת שלו מאוחסנת במצביע ריק ptr. ה printChar לאחר מכן נקרא הפונקציה עם ה- מצביע ריק 'ptr' בתור טיעון. מצביע הריק מומר במפורש למצביע char ב- 'printChar' פונקציה לגשת ולהדפיס את הערך המאוחסן ב 'ג' .
ב-C++, הקוד ניתן להלן:
#includeבָּטֵל printInt ( בָּטֵל * על אחד ) {
int * ptr = static_cast < int *> ( על אחד ) ;
סטד :: cout << * ptr << סטד :: endl ;
}
int רָאשִׁי ( ) {
int איקס = 10 ;
בָּטֵל * ptr = & איקס ;
printInt ( ptr ) ;
לַחֲזוֹר 0 ;
}
הקוד לעיל מגדיר פונקציה printInt שלוקח את מספר מצביע ריק כפרמטר ומטיל אותו למצביע שלם באמצעות ה- אופרטור static_cast . לאחר מכן הפונקציה מדפיסה את הערך של המספר השלם שאליו מצביע המצביע המוטל. בפונקציה הראשית, משתנה מספר שלם x מוגדר והכתובת שלו מאוחסנת ב-a מצביע void ptr, אשר מועבר לאחר מכן ל- printInt פוּנקצִיָה. הפלט של התוכנית הוא הערך של x, שהוא 10.
מחשבות אחרונות
ה בָּטֵל מצביעים ב-C ו-C++ מספקים דרך רבת עוצמה לתמרן נתונים מבלי צורך לדעת את סוג הנתונים הספציפי שלהם. הם שימושיים עבור הקצאת זיכרון ומצביעי פונקציות, כמו גם ליצירת ממשק גנרי עבור אובייקטים ממחלקות שונות ב-C++. עם זאת, חשוב לקחת בחשבון את ההבדלים בין C ו-C++ בשימוש שלהם מצביעים בטלים , כגון הצורך בסוגי נתונים ספציפיים ב-C++ והצורך בהמרה מפורשת בעת השלכת מצביעי חללים לסוגי מצביעים אחרים. שיקול זהיר של נקודות אלה יכול להוביל לשימוש יעיל ואפקטיבי יותר של מצביעים בטלים בתכנות.