ניהול זכרון - העברת משתנים לפי ערך ולפי מצביע - Classes Are Reference
x בעותק ל-100, הערך במקור נשאר 10.פרקי ההרצאה: ניהול זכרון - העברת משתנים לפי ערך ולפי מצביע - Classes Are Reference
תמלול ההרצאה: ניהול זכרון - העברת משתנים לפי ערך ולפי מצביע - Classes Are Reference
הטקסט המלא של הדקות הראשונות בהרצאה «ניהול זכרון - העברת משתנים לפי ערך ולפי מצביע - Classes Are Reference» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
שלום וברוכים הבאים אנחנו רוצים לדון היום על עוד הבדל משמעותי בין סטראקטים לבין מחלקות אז בשביל להסתכל טוב טוב על הדוגמה של היום בואו נקפץ רגע על הקלאס הזה שנקרא view controller אנחנו רואים למעשה שיש פה כבר קלאס ויש פה מתבצעת ירושה ואפילו אני רואה שהפונקציה view did load היא פונקציה שאני יורש
ואני קורא לאבא שיבצע את העבודה שלו עד עכשיו לא יכולנו ממש לדבר על הסינטקס הזה כי לא דיברנו על סינטקס של מחלקות עכשיו אנחנו רוצים להסתכל על עוד הבדל כמו שאמרתי בין סטראקטים לבין מחלקות וכדי לעשות את זה בואו ניצור סטראקט וגם קלאס ואחר כך נוכל לעמוד על ההבדלים ביניהם.
הסטראקט שאני רוצה לייצר ייקרא פוינט אוקיי אז בואו נעשה אותו והפוינט הזה ייצג נקודה במרחב x וy אז בואו נראה סטראקט פוינט ולפוינט כדי להגדיר נקודה במרחב צריך להגדיר x ו-y אז בוא נאמר var x הוא יהיה מספר שלם נניח ו-var y הוא יהיה מספר שלם אוקיי סטראקט סיימתי להגדיר עובד יופי מה לגבי קלאס אם היינו
רוצים להגדיר קלאס אז היינו כותבים קלאס בואו נקרא לו point c כדי לציין שהוא בעצם מחלקה אני לא רוצה לרשת משום דבר אבל אני יכול כי אני בקלאס כמו שאתם רואים השלמה אוטומטית פה מזכירה לי את זה ואתם יודעים אם אני רוצה להגדיר x ו-y כמשתנים אז אני חייב חייב מה אני חייב בניי נכון אז init
ונקבל את x ואת y ונשמור אותם אז עד כאן זה היה בעצם למעשה תרגול כשכזה נכון init ליצור קלאס ליצור סטראקט פנטסטי אז איפה ההבדל אתם יכולים לשאול ההבדל בואו נעמוד עליו עכשיו אני קודם כל אייצר הופעה של הסטראקט ושל הקלאס אז אני אגיד let st struct point שווה ל-point שיצרנו אותו מהסטראקט אתם רואים
דרך אגב תסתכלו איזה יופי רואים שעל פוינט הזה כתוב שהוא סטראקט ועל פוינט הזה אנחנו רואים ציור של סי עגולה כלומר מחלקה.
אוקיי אני אצר נקודה אחת נגיד 10 ו-20 וזה הסטראקט שלי והמופע מהסטראקט בוא נעשה אותו כבר ואני אצר מופע מהקלאס אז בוא נגיד קלאס פוינט שווה לפוינט סי הפעם ואם אתם רוצים אז בוא נגיד 30 x שיהיה 30 ו-y שיהיה פה 40 אז עד כאן לכאורה נראה מאוד מאוד דומה אתם חייבים להסכים עכשיו אוקיי עכשיו בוא נדבר באמת על ההבדל ראשית אני אפתח קודם כל באיזושהי טענה אני
רוצה לטעון שקלאסיים הם בעצם רפרנס טייפס בסוויפט ולכן הם מועברים לפי רפרנס אני מעביר מצביע ממקום למקום אם אתם לא מכירים את המושגים האלה אל תדאגו אני מיד אסביר אני פשוט לוקח בחשבון שחלק מכם כבר יודעים לתכנן באיזושהי שפה ולכן אני מסביר את זה במושגים שווה תכנתים,
עוד מעט אני אסביר את זה גם במונחים של אנשים פשוטים. סטראקטים בסוויפט הם value types ולכן הם מועברים לפי value או במילים אחרות הערכים שלהם מועתקים.
בסדר? עכשיו לפני שאני אפצח פה באיזה אוסף של דגמות קוד בואו נלך רגע להסביר את כל המושגים הללו ונחזור.
אז אנחנו רוצים קודם כל בעצם כדי להבין את הנושא הזה טוב יותר אנחנו רוצים לדעת איך מנוהל הזיכרון של התוכנית. זיכרון של תוכניות מתחלק לשתי חלקים, יש לנו שתי מקומות עיקריים בזיכרון, מאגר זיכרון עקרוני נקרא stack ומאגר זיכרון נוסף נקרא heap.
עכשיו ב-stack שלנו אנחנו שומרים value types, אנחנו שומרים משתנים פשוטים, למשל structים. structים הם value types, איזה value types אנחנו מכירים?
אנחנו מכירים מספרים, אנחנו מכירים סטרינגים בסוויפט, אנחנו מכירים בוליאנים ולמעשה כל המשתנים הבסיסיים ביותר בסוויפט מוגדרים כסטרקטים. הם לא יודעים לעשות ירושה והם נמצאים אך ורק במאגר הזיכרון של הסטאק, שם הם מנוהלים בקפידה ובצורה הכי יעילה שיש.
אפשר לטעון שווליוטייפס מנוהלים בצורה היעילה ביותר והזיכרון שלהם מתנקם מהר מאוד ואין שום חשש לזליגות זיכרון ברגע שמתעסקים אם המבנה נתונים הפשוטים ביותר הלוא הם אסטרקטים שהם value types.
עכשיו אם אני פשוט מגדיר את x להיות 10 x נשמר בסטאק בזיכרון של הסטאק אם אני מגדיר את y להיות נניח 20 גם y יאללה שמים אותו בסטאק אם אני בא ואומר בקוד שלי z שווה ל-y אוקיי אז מה יקרה בסטאק מה אתם אומרים מה יהיה פה בסטאק z יהיה שווה 20. יפה אז זאת התמונה של הסטאק עבור משתנים פרימיטיביים פשוטים לגמרי.
מה קורה אם המשתנה הפרימיטיבי שלי במקרה הזה הוא סטראקט? אז יש לי נגיד את הפוינט הזה, נכון? פוינט שהגדרנו היה סטראקט, היה לו x והיה לו y.
אז עבור הסטראקט גם הוא נשמר בזיכרון הזה של הסטאק, ואנחנו נשמור עבורו משתנה מסוג פוינט בסטאק, יפה. מה קורה אם באיזשהו שלב אתם באים ועושים עותק?
גם העותק הזה נשמר כולו קומפלט בסטאק, הערכים באים ומועתקים, בסדר? value types נשמרים בסטאק ואין דבר כזה לשמור reference או להחזיק מצביע שעוד מעט נדבר מה זה אומר.
במילים אחרות אם עכשיו אנחנו נעשה קופי של הפוינט שלנו אנחנו נעתיק את כל הערכים מה זאת אומרת נעתיק אנחנו נעתיק את x להיות 10 ואת y להיות 20 ועכשיו יש לי שני עותקים ששניהם מכילים פעמיים את כל המידע.
בואו נראה רגע דוגמה כזאת בסוויפט שלנו בסדר? באקסקוד אז הנה יש לנו רגע נשים פה את זה בהערה יש לנו את הסטראקט שלנו שזה מצוין איך קראנו לו במצגת קראנו לו פשוט פוינט בסדר אז אוקיי פוינט הוא סטראקט זוכרים מצוין עכשיו בואו נגיד אני אעשה ממנו קופי var קופי שווה לפוינט שלי ברגע זה עשיתי גבירותיי ורבותיי
קופי מה זאת אומרת עשינו למעשה ענית חדש והכנסנו X 10 והכנסנו Y 20. זאת התמונת זיכרון שלי עכשיו, שימו לב, זאת התמונת זיכרון, יש לי את הפוינט ויש לי את הפוינט קופי, שניהם, הנה זה הפוינט קופי שלי וזה הפוינט, יפה?
שניהם בעצם מוגדרים כמשתנים. עכשיו תעשו לי טובה, שמות שמשתנים יהיו באותיות קטנות, אז במצגת זה כתוב בצורה אחרת קצת, אבל שמות שמשתנים באות קטנה בלבד.
יפה? אז מה תמונת זיכרון? בעצם יצרתי עוד משתנה אחד ושמתי אותו גם בסטאק. למה?
כי זה סטראקט, וסטראקטים הם value types. כלומר, נשמרים בזיכרון של הסטאק, בסדר?
saved in the stack, ואם צריך קופי, כמו שניסינו לעשות, a שווה ל-b, אז קופי, נכון? Copied by values.
יש. זאת נקודה ראשונה שרציתי להסביר לכם. אתם רואים? אמרתי לכם שסטראקטים הם value types ומועברים לפי values, למעשה נוצרים לנו עותקים ברגע שצריך אני אוכיח לכם את הטענה שלי אני אגיד שפוינט קופי נקודה
איקס עכשיו יהיה שווה ל-100 בסדר בואו נדפיס את הערך של פוינט נקודה איקס ובואו נדפיס את הערך של קופי נקודה איקס מה אתם אומרים שזה ידפיס אני אומר ככה פוינט ידפיס 10 ופוינט קופי ידפיס 100 זאת ההתנהגות של סטרקטים גבירותיי ורבותיי זאת ההתנהגות של value