מה ההבדל בין ייחוס (reference) למצביע(pointer)?
כלומר מתי עדיף להשתמש בייחוס ומתי במצביע?
אם מישהו לא הבין, כשאני אומר ייחוס אני מתכוון ל:

קוד:

 
 
 


int &x=y;


 

בדיוק שאלו על זה. אני לא מניח שטרחת לבצע חיפוש.

כלל האצבע אומר משהו פשוט - לא משתמשים במצביעים ב-CPP. ברגע שתדע מתי מותר להפר כללי אצבע, תוכל להשתמש במצביעים.

סאשה הסוס, סוכן אוסינט.‏

אתה יכול לרשום כאן דוגמאות של מתי להשתמש בpointer ומתי בreferences , מקרים ספציפיים.

רפרנס:

• כשאתה מעביר פרמטרים מטיפוסים שאינם פרימיטיביים. לדוגמה:

קוד PHP:

 void foo(const Bar& bar); 


• כשאתה כותב template, ולא יודע מה יהיה הטיפוס:

קוד PHP:

 template<typename T>
void foo(const T& t); 


פויינטר:

• לעולם לא.

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


אגב, אם אתה רוצה להגיב למישהו (נגיד , לי), אתה אמור ללחוץ על כפתור התגובה בתגובה של מי שאתה רוצה להגיב לו.

סאשה הסוס, סוכן אוסינט.‏

ציטוט:

במקור נכתב על ידי סאשה הסוס רפרנס: פויינטר: לעולם לא.

פויינטרים זה דבר שימושי ביותר ב c++ בכל מיני נסיבות.
בנוסף שימוש ב reference גורם לקשיים בקריאה של קוד ולבלבול..

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

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

כשמקבלים פרמטר שלא מתכוונים לשנות, מקבלים אותו כ-const-reference. כל דבר אחר
הוא טעות. כשתופסים חריגות, תופסים אותך כ-const-reference (ואולי אפילו unnamed).
כל דבר אחר הוא טעות.

סאשה הסוס, סוכן אוסינט.‏

אז ממה שאני הבנתי ממך אסור לעשות:

קוד:

void foo(const int i)

אלא חייבים לעשות:

קוד:

void foo(const int &i)

או שלא הבנתי את הכוונות שלך בצורה נכונה?

int הוא טיפוס פרימיטיבי של השפה.

סאשה הסוס, סוכן אוסינט.‏

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

ציטוט:

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

מעניין:

ציטוט:

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

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

סאשה הסוס, סוכן אוסינט.‏

קראתי את התגובה העליונה שלך וזה בסדר כמו שכתבת שם.
לפי התגובה שלך זה לא מובן כי אתה כתבת בהכללה ש"כשמקבלים פרמטר" כאילו זה בכל מקרה.
אבל בכל מקרה למה שיהיה אסור לתת כפרמטר const A a שהוא לא פרימיטיבי בצורה כזו?

למה? מיותר מסיבה אחת:

• זה מבזבז זיכרון.
• זה מבזבז זמן עיבוד.

אלה הם דברים ברורים להחריד. קיימת עוד סיבה:

• יש אובייקטים שאסור להעתיק.

לדוגמה: אם מעבירים אובייקט מטיפוס Thread כפרמטר לפונקציה שעושה לו משהו (בווינדוס לדוגמה, זה תקף בעצם לכל אובייקט קרנל, לחלונות, וכו'); exceptions בדרך כלל אסור להעתיק, ולכן צריך לתפוס אותם כ-const-reference, וכו'.

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

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

סאשה הסוס, סוכן אוסינט.‏

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

אם אפשר לעשות א XOR ב וצריך לעשות א זה אומר שאסור לעשות ב.

סאשה הסוס, סוכן אוסינט.‏

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

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://www.fresh.co.il/scripts/birthday.php?date=27/04/1986]

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

אני אמרתי שאסור, ואתה פשוט מתקשה להבין את זה.

סאשה הסוס, סוכן אוסינט.‏

ואני אמרתי שזה לא אסור אלא כדאי

להעביר by value במקרה שציינתי לא אסור, אלא כדאי? כדאי להעביר by-value במקרה הזה? הזוי לגמרי.

סאשה הסוס, סוכן אוסינט.‏

אתה מתעקש לא להבין אותי...

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

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

סאשה הסוס, סוכן אוסינט.‏

"שאפשר לממש רק אחת מהן" הוא לא משפט נכון כי אפשר לממש את שניהם.
וכשמשהו לא כדאי זה לא אומר שהוא אסור.

וואו, אני מת לראות קוד C++‎ שבו אתה מעביר פרמטר בו זמנית ב-const-reference ו-by-value. קדימה, תראה לי.

סאשה הסוס, סוכן אוסינט.‏

לא שניהם בו זמנית אבל מימוש אפשר לעשות או ב by value או ב by reference(זו הכוונה שלי בהודעה הקודמת)

ולהגיד שאחד אסור בגלל שהשני עדיף זה דבר לא נכון.

לאט לאט אנחנו מתקדמים פה.

אז אם אפשר או להעביר const-reference או by-value (אבל לא בשני האופנים בו-זמנית),
והדרך העדיפה היא להעביר const-reference, מה קורה אם אנחנו מעבירים by-value?
אנחנו מונעים מעצמנו להעביר כ-const-reference (כי אי אפשר גם וגם בו זמנית). כלומר,
אנחנו מונעים מעצמנו אפשרות טובה יותר. לכן, אסור להעביר by-value במקרה שצויין למעלה.

סאשה הסוס, סוכן אוסינט.‏

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

וגם זה אסור.

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

סאשה הסוס, סוכן אוסינט.‏

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

סאשה הסוס, סוכן אוסינט.‏

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

בעצם, כל אדם נורמלי יודע שעדיף לא לבזבז שום דבר, אם אין שום תמורה.

אין טעם לבזבז מקום של אובייקט שלם, ולבצע קריאה מיותרת ל-constructor וקריאה מיותרת ל-destructor (או אפילו שתיים במימושים מסויימים, למיטב זכרוני).

העברה by-value במקרה הזה היא פחות טובה אובייקטיבית. אין להשתמש בה.

סאשה הסוס, סוכן אוסינט.‏

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

עדיף להעביר כ-const-reference, ואסור להעביר by-value. אפשר אחרת, אבל אסור.

סאשה הסוס, סוכן אוסינט.‏

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

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

סאשה הסוס, סוכן אוסינט.‏

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

זה קוד גרוע שמבזבז מקום בזיכרון וזמן ריצה. זה אסור.

סאשה הסוס, סוכן אוסינט.‏

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

סאשה הסוס, סוכן אוסינט.‏

אם אפשר להעביר פרמטר קבוע מטיפוס שאינו פרימיטיבי כרפרנס או by-value (אבל לא שניהם בו זמנית), וצריך להעביר כרפרנס זה אומר שאסור להעביר by-value. זו בדיוק המשמעות של "או כך או כך, אבל לא שניהם גם יחד".

סאשה הסוס, סוכן אוסינט.‏