בוקר אור!

זה עניין שאף פעם לא הבנתי כמו שצריך ותמיד נתקעתי בו - מצביעים

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

void solveSqEq(double *x1, double *x2,
double a, double b, double c)
{
double sqrt_delta = sqrt(b*b – 4*a*c);
*x1 = (-b + sqrt_delta) / (2*a);
*x2 = (-b – sqrt_delta) / (2*a);

}

זו למשל פונקצית עזר לתכנית שאמורה לפתור משוואות ריבועיות (לקוח מאיזה תירגול)

אם נגיד נאתחל בפונקציית מיין

x=7

אז נגיד שבמקום 2000 (אני מדמיין את זה בתור תיבה שיש לה מספר קיטלוג ובתוכה ה"סחורה" - הספרה 7) נמצא הערך של x -> 7

למה בפונקציית המיין אני שולח את x&? מה יקרה אם אשלח את x בלי סימן לפני?

בפונקציה המצורפת, רשום x *. מה יקרה אם ארשום רק x ?

ובגדול, x& זה הכתובת (התיבה) ו x* הערך?

בפונקציה איפה שרשום double a בפונקציית המיין איך זה נשלח, בתור סתם משתנה בלי * או & לפניו?

כמו באנלוגיה שנתת, כשאתה מגדיר משתנה double x = 7.0 אז נוצרת "תיבה" בזכרון במקום כלשהו (נניח 2000) שבה נמצא הערך 7.0. אז הביטוי x מחזיר את הערך 7.0, והביטוי x& מחזיר מצביע לכתובת של x בזכרון, כלומר 2000. אם תעשה x* אז תקבל שגיאת קומפילציה, כי x הוא לא מצביע.

הפעולה * עושה בדיוק ההפך - אם x1 הוא מטיפוס *double והוא כרגע מכיל את הערך 2000, אז הפעולה x1* בעצם ניגשת לתיבה שבמקום 2000.

אם יש לך את הקוד הבא:

int x = 7;
int* p = &x;

אז עכשיו p מצביע לתיבה שבה יושב x, ולכן שתי השורות הבאות שקולות:

x = 10;
*p = 10;

שים לב, כיוון ש-* ו-& הן פעולות הפוכות, לגשת ל (x*)& או ל- (x&)* זה בדיוק כמו לגשת ל-x.

כשאתה קורא ל-solveSqEq, שני הפרמטרים הראשונים שאתה מעביר חייבים להיות מצביעים למשתנים תקניים. כלומר, לכל אחד מהם יש שתי אפשרויות - אתה יכול להגדיר משתנה רגיל ולהעביר אותו באמצעות &, או שאתה יכול להגדיר משתנה מטיפוס מצביע, לשים בו ערך הצבעה למשתנה אחר (או לזכרון שהוקצה דינמית באמצעות malloc) ואז להעביר אותו כמו שהוא, בלי & או *.

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

תחשוב על הזיכרון כעל רכבת שיש בה מושבים. כל מושב ברכבת מייצג מקום בזיכרון.

עכשיו יש גם אנשים שיושבים במושבים האלה. האנשים האלה הם המשתנים שלך.

אנשים יכולים לעבור ממקום למקום, יכולים לקום ולהשאיר מושב ריק ויכולים למלא מושב שהיה ריק.

המושבים לעומת זאת נשארים קבועים במקום ולא יכולים לזוז.

זה בדיוק הרעיון של פוינטרים. ברגע שיש לך פוינטר זה כמו שיש לך מס' מושב.

אתה יכול לעקוב אחרי המושב הזה, לדעת מי יושב שם, להחליף בעצמך את מי שיושב שם, להקים את מי שיושב שם וכו'.

מתי זה טוב? כשאתה רוצה למשל להכניס לפונקציה קלט שתוכל לשנות אותו בתוך הפונקצייה.

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

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

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

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

תודה על ההסבר, בהחלט עזר

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