PracticU

מצביע למצביע - Pointer to Pointer

בלי כתוביותעם כתוביות
PracticU › קורס C למתקדמים - עבודה מול חומרה Win32 › מצביע למצביע - Pointer to Pointer
מילון מושגים:
משתנה - שם שמפנה למקום בזיכרון שבו נשמר ערך שיכול להשתנות במהלך ריצת התוכנית, כמו מספר, טקסט או אובייקט.
זיכרון - רכיב מהיר ונדיף שבו המחשב שומר נתונים ותוכניות בזמן ריצתם. תוכנו נמחק עם כיבוי המחשב.
Visual Studio - סביבת פיתוח משולבת (IDE) של מיקרוסופט לכתיבה, ניפוי והרצה של קוד, בעיקר בשפות .NET.

מצביע למצביע - Pointer to Pointer
מצביע למצביע (Pointer to Pointer) מסביר איך משתנה מצביע יכול להצביע לא רק על ערך, אלא על מצביע אחר, ואיך משנים ערך דרך שרשרת של מצביעים. ההרצאה מציגה את הנושא בעזרת ציור של כתובות בזיכרון.
השלבים העיקריים
1. משתנה ומצביע: מגדירים int i עם הערך 3 ומצביע int* pi שמכיל את הכתובת של i. דרך *pi = 5 משנים את הערך של i.
2. מצביע למצביע: int ppi מכיל את הכתובת של pi. לכן *ppi הוא pi עצמו, ו-ppi הוא הערך שאליו pi מצביע.
3. ציור הכתובות: המרצה משרטט את i בכתובת 1000, את pi בכתובת 2000 שמכיל את הכתובת 1000, ואת ppi שמצביע על pi. המטרה היא להבין מה מכיל כל משתנה.
4. כיוון מחדש של pi: מגדירים משתנה נוסף j בכתובת 4000 עם הערך 4, ואז משנים את pi כך שיצביע על j, דרך ppi.
5. עדכון ערך דרך השרשרת: **ppi = 6 משנה את j, כי השרשרת עוברת מ-ppi אל pi ומשם אל j. הדיבאגר מציג את הערך המשתנה של j בצבע אדום.
6. תצוגה בדיבאגר: Visual Studio מציג את הערך מאחורי מצביע כשמרחפים עליו, וניתן לראות את הכתובת בתצוגה הקסדצימלית.
טעויות נפוצות
- כשמוסיפים כתובת של משתנה מסוג מצביע צריך להוסיף כוכבית כדי שהטיפוסים יתאימו. המרצה מסביר זאת על ידי השוואה בין i לבין pi.
- כשעובדים עם מצביעים רבים כדאי לצייר את הכתובות, כדי לא לאבד את הקשר בין המשתנים.
הסטודנט יכול לאחר ההרצאה לקרוא שרשרת של מצביעים, לשנות ערך דרך מצביע למצביע, ולעקוב אחרי הכתובות בדיבאגר.
השיעור הבא בקורס: מערך של מבנים - Array

פרקי ההרצאה: מצביע למצביע - Pointer to Pointer

  1. 00:00

    פתיחת פרויקט Console והגדרת משתנים

  2. 00:41

    מצביע int ושינוי ערך דרכו

  3. 01:49

    מצביע למצביע: הגדרה ו-PPI

  4. 02:51

    ציור הזיכרון להבנת מצביעים

  5. 04:56

    PPI מצביע ל-PI בזיכרון

  6. 05:59

    הגדרת משתנה J ויעד חדש ל-PI

  7. 07:03

    תוכן PPI הוא כתובת PI

  8. 07:47

    כיוון PI לכתובת של J דרך PPI

תמלול ההרצאה: מצביע למצביע - Pointer to Pointer

הטקסט המלא של הדקות הראשונות בהרצאה «מצביע למצביע - Pointer to Pointer» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.

  1. 00:03

    אוקיי, היום אנחנו נלמד על מצביע למצביע, נפתח visual studio, create project, ולא c-sharp, other languages, c++, מין 32, קונסול, ונקרא לזה pointer to Pointer, Enter, נעשה באפליקיישן סטיינינג, נשאיר את זה כמו שזה, נגיד לו Finish,

  2. 00:37

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

  3. 01:00

    יפה, אז אני יכול לגשת בעזרת כוכבית pi ולהגיד שווה ל-5 וזה הרגע נתתי בעצם ערך ל-i, כך שהוא יהיה 5. בואו נתחיל את i בהתחלה שיהיה שווה ל-3.

  4. 01:20

    אז i מותחל ל-3, Pi מותחל לכתובת של i, ואז כוכבית Pi מקבלה 5, בעצם אני אומר ש-i מקבל 5, יפה. עכשיו נגדיר את int כוכבית כוכבית פוינטר לפוינטר ל-i, וזה שווה לכתובת של Pi.

  5. 01:40

    אז PPI הוא, בואו נקרא את זה, Pi הוא מצביע למצביע ל-int. וכתובת של פי איי, פי איי הוא מצביע לאינט, כתובת של מוסיפים כוכבית. כשאני לוקח את איי ואני אומר כתובת של אני מוסיף כוכבית כדי שתהיה התאמה.

  6. 02:13

    איי הוא מסוג אינט, איי הוא אינט, כתובת של אז היה לי אינט, אמרתי מצד ימין כתובת של אז פה אני מוסיף כוכבית. יפה.

  7. 02:27

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

  8. 03:18

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

  9. 04:11

    יפה ואז אמרנו שהתוכן של פי איי התוכן של פי כי התוכן של אלף, התוכן של אלף, התוכן של אלף זה חמש. שמנו פה חמש. יפה.

  10. 04:28

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

  11. 04:42

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

  12. 05:19

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

  13. 05:44

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

  14. 05:59

    אז ראינו שלפעמים זה מכוון לזה, אבל לפעמים הוא מכוון לאיזה אינט אחר. אז מה שהייתי רוצה זה להגדיר איזה אינט אחר. זה I, הייתי רוצה להגדיר את J. אז בואו נגדיר כאן את J, ו-J יושב ב-4,000.

  15. 06:19

    יפה מאוד. ואז מה? ואז הייתי רוצה להגיד שאני רוצה לכוון את P-I ל-J.

  16. 06:30

    דרך אחת שאני יכול לכוון את P-I ל-J זה להגיד ש-P-I שווה לכתובת של J, בדרך אחרת אז ככה אז אם PPI מצביע ל-PI בואו נכוון אותו אז נגיד שמפה לכאן קליק פה קליק כאן וראש חטא נכוון אותו וניתן לו זנב אז מה שהייתי רוצה זה קודם כל אז את PPI אז את PPI כיוונו כבר להצביע ל-PI

  17. 07:07

    ppi מצביע ל-pi, מה זה אומר? זה אומר שהתוכן של ppi זה הכתובת של pi, כתובת של pi. pi יושב ב-2000, לכן מה שכתוב פה זה 2000, אז בואו ניתן לו פה 2000. יפה. ואז, אם אני רוצה לכוון את pi להצביע לכתובת 4000, במקום ש-pi יצביע לכתובת 1000 ולכן ל-i, אם אני רוצה לכוון את pi להצביע ל-j אז אני צריך להגיד שהתוכן של ppi תוכן של 2000 זה לא 1000 אלא 4000 טוב אבל אז אני צריך את

  18. 08:01

    הכתובת j אוקיי אני אקח את הכתובת של j אז אני אגיד שהתוכן של ppi תוכן של ppi זה pi בעצמו פי איי אני רוצה לכוון אותו לכתובת של ג'י אז אני אגיד שהוא שווה לכתובת של ג'י ואז כיוונתי טוב אבל אין לי ג'י בואו נגדיר את אינט ג'י אינט ג'י ונתחיל אותו בארבע אז אינט ג'י שווה

לקורס המלא: קורס C למתקדמים אונליין

ההרצאה הקודמת: מצביעה לפונקציה - Function Pointer

ההרצאה הבאה: מערך של מבנים - Array

הרצאות קשורות מקורסים אחרים

  • מצביע לפונקציה - Delegate
  • ניהול זכרון - העברת משתנים לפי ערך ולפי מצביע - Classes Are Reference

קורסים נוספים במסלול

  • קורס WinForms - תוכנות רגילות בווינדוס
  • פרויקט מעשי ב-#C - בונים מחשבון פשוט
  • פרויקט מעשי ב-#C - ספר טלפונים
  • פרויקט מעשי ב-#C - תוכנת צייר
  • קורס ADO.NET - חיבור אתר למסד נתונים
  • קורס תכנות מתקדם - #Advanced .NET C