ביצוע המרה - Cast
int x = 100; byte b = x; גורם לשגיאה, כי int תופס ארבעה בתים ו-byte בית אחד, ואם הערך יהיה גדול מ-255 הוא לא ייכנס. כדי לאשר את ההמרה כותבים את הטיפוס בסוגריים:byte b = (byte)x;(decimal)12.34.int.Parse או Convert.ToInt32.3 / 4 שבין שני משתני int נותן 0, כי החלוקה נעשית בין מספרים שלמים והשבר נחתך. ההמרה (double)a / b נותנת 0.75, כי אחד האופרנדים כבר double.פרקי ההרצאה: ביצוע המרה - Cast
תמלול ההרצאה: ביצוע המרה - Cast
הטקסט המלא של הדקות הראשונות בהרצאה «ביצוע המרה - Cast» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אנחנו מגיעים לנושא מאוד חשוב ומאוד פשוט אבל הוא יוצר המון בלבול אצל מתכנתים מתחילים. הנושא הזה נקרא קאסטינג או בעברית המרות. בואו נראה מה פירוש קאסטינג ומה יש לדעת בנוגע לזה.
קודם כל נפתח פרויקט חדש, נבחר קונסול אפליקיישן ונקרא לו קאסטינג. עכשיו בואו נגדיר איזשהו משתנה int x, נכניס לתוכו 100 ונגדיר עוד איזשהו משתנה בייט בי ונכניס לתוכו את x ואנחנו רוצים להציג את b וכעת אנחנו רואים שיש לנו שגיאה המערכת אומרת לנו שגיאה על x cannot implicitly convert type int to
byte עכשיו מה בעצם רצינו לעשות כאן היה לנו איזשהו משתנה מטיפוס אינטג'ר שיש בו 100 קיבלנו מהמשתמש או שהכנסנו בקוד ובאיזשהו מקום אחר בקוד היה לנו משתנה נוסף מטיפוס בייט ואמרנו אנחנו רוצים לקחת את המשתנה ולהכניס אותו לתוך המשתנה בית.
עכשיו, אתם יכולים לשאול את עצמכם רגע למה שניהם לא בית או שניהם לא איקס, יותר נכון אינט, אז לא משנה כרגע למה הם לא אותו דבר, אבל קורה הרבה בקוד שיש לנו באזור אחד בקוד משתנה מסוג אחד, ובאזור אחר משתנה מסוג אחר, לא משנה מה הסיבה שהם
סוגים שונים. כנראה שמראש היינו צריכים אותם מסוגים שונים, ואז אנחנו רוצים לקחת את המשתנה מהסוג הראשון ולהכניס אותו לתוך המשתנה מהסוג השני.
ופה אנחנו רואים שיש לנו איזושהי בעיה, אבל אנחנו צריכים להבין למה יש כאן בעיה. הסיבה היא כזאת, אינטג'ר, הגודל שלו בביקרון זה ארבעה בתים. בית זה יחידת זיכרון הכי קטנה שניתן להגדיר בדוטנט.
אוקיי, בית, הגודל שלו בביקרון זה בית אחד. אז אם יש לנו כאן משתנה שהגודל שלו בארבעה בתים, ובגלל שהגודל שלו ארבעה בתים, זה אומר שהוא יכול להחזיק פלוס מינוס שני מיליארד, כלומר מינוס שני מיליארד עד פלוס שני מיליארד, כלומר את המספר שני מיליארד.
ואם יש לנו משתנה שהגודל שלו זה בית אחד, הוא יכול להחזיק בין 0 ל-255, כלומר המקסימום שיכול להיות בו זה 255. אז כמובן שהמחשב בודק אותנו ואומר רגע רגע רגע, מה שיש לך כאן, האינטג'ר הזה יכול לחרוג מהגבולות של הבית, ולכן לא מעניין אותי מה באמת יש בו, כי 100 זה מספר שהוא בטווח 0 עד 255 יכול להיכנס לתוך בית.
אבל המחשב לא בודק מה באמת יש בו, הוא בודק רק מה הטיפוס שלו. האם הטיפוס הזה מאושר להיכנס בתוך בית או לא? אם הוא יותר מדי גדול כמובן שהוא לא מאושר.
אז הסיבה לאי האישור הזה זה בגלל שיכול להיות אולי בעתיד אולי מתישהו יכול להיות שיהיה בו לדוגמה את המספר כבר 300, ו-300, ליתר דיוק נכניס את זה כאן, לא יכול להיכנס בתוך בית.
ולכן המחשב מראש אומר, וזה לא מעניין אותי מה באמת יש בו, אם יש בו 100 או יש בו 300, אני לא מאשר לעשות את ההשמה הזאת. אז אם אנחנו מריצים כרגע בדיקה האם התוכנית עוברת, היא לא עוברת עם שגיאה כזאתית, שגיאת קומפילציה, בדיוק על הנקודה של הקאסטינג.
אז למה חשוב לנו לדעת את כל הנושא של קאסטינג ואיך באמת לאשר את זה? מפני שהמון קורה בתוכנית שאתם רוצים לקחת סוג אחד ולהכניס אותו למשתנה מסוג אחר.
זה דבר שהוא מאוד מאוד נפוץ בפיתוח תוכנה. אז איך אנחנו פותרים את הבעיה הזאת? כל מה שאנחנו צריכים לעשות זה לפני שם המשתנה, לשים את הטיפוס אליו אנחנו רוצים לבצע את ההמרה.
אם אנחנו מבצעים עכשיו בדיקה, אנחנו רואים פה למטה שהמחשב כותב build succeeded. הרצתי בעצם ctrl+shift+b או במקרים מסוימים f6 אתם יכולים להריץ, והתוכנית בודקת האם יש לי שגיאות ויוצרת קובץ אקסקיושן.
אם אנחנו נריץ את הקובץ אקסקיושן אנחנו נראה שאכן המאה הצליח להיכנס. אבל רגע, מה קורה אם יש לנו פה נניח 256? 256 לא יכול בחיים להיכנס לתוך בית. אם אנחנו נעשה את זה אנחנו נקבל משהו שנקרא גלגול.
גלגול זה מצב בו המשתנה חרג מהגבולות, התגלגל ועבר להתחיל לספור מאפס בעצם. 255 כן יכול להיכנס לתוך בית ולכן אם אנחנו נבצע את זה אנחנו נראה שיש בתוך המשתנה b 255. אבל 256 כבר לא יכול ולכן המשתנה מאופס ומתחיל לספור מאפס.
257 ייתן לנו ספירה של 1. 258 ייתן לנו 2. זה נקרא גלגול והוא מתחיל מאפס. חמש מאות ואחת עשרה נותן לנו מאתיים חמישים וחמש. חמש מאות ושתים עשרה שוב פעם נותן לנו אפס.
אז אנחנו רואים שיכול להיות פה גלגולים כאלה, כי בתוך b יכול להיות בין אפס למאתיים חמישים וחמש.
אבל בכל מקרה, בואו נגיד שיש לנו פה אלף. אלף לא יכול להיכנס בתוך בית, ולכן מה שקרה כאן זה איבדנו מידע. במקום אלף אנחנו רואים מאתיים שלושים ושתיים.
אנחנו איבדנו מידע. הפעולה הזאת נקראת קאסטינג. קאסטינג זו פעולה שנועדה להשתיק קומפיילר. הקומפיילר בדק אם יש לנו שגיאות ואמר אני ב-C-Sharp לא מסכים לקחת משתנה אינטג'רי ולהכניס אותו כמו שהוא לתוך משתנה מטיפוס בית.
אם אתה רוצה תעשה קאסטינג. אם אתה עושה קאסטינג אני כבר לא אתן לך את השגיאה אבל זה עובר לאחריותך. עדיין אתה יכול לאבד מידע אם במקרה יש פה משתנה או ערך יותר מדי גדול מאשר יכול להכיל בית.
אז בכל מקום שאנחנו רוצים לקחת ערך מטיפוס גדול ולהכניס אותו לתוך משתנה מטיפוס קטן יותר, אז אנחנו רואים שהקומפיילר שומר עלינו ואומר אני לא מסכים לעשות את זה. אם אתה רוצה לעשות את זה, אתה צריך לתת לי הוראה מפורשת לבצע את הפעולה של הקאסטינג.
שימו לב שפעולת קאסטינג הזאת מאוד מאוד מקומית זה לא אומר שמעכשיו והלאה x הופך להיות בייט x ממשיך להיות אינטג'ר רק למשך הפקודה הזאת הקומפיילר מתייחס לx כאילו שהוא בייט בכדי להצליח לבצע את ההשמה אבל x ממשיך להיות אינטג'ר ממשיך להחזיק את המידע שלו אם אנחנו עכשיו מסתכלים מה ערכו של x אנחנו יכולים לראות שערכו 1000
כמובן אין לנו פה שום שינוי לגבי x מקרה נוסף שיכול להיות קאסטינג יש לנו כאן לדוגמה דאבל. ניקח A ונכניס לתוכו 123.456. יש לנו כאן, נשתנה פלואוט F ואנחנו רוצים להכניס לתוכו את A. ואנחנו עכשיו מקבלים את אותה הבעיה בדיוק כמו מקודם.
פלואוט, הגודל שלו זה 8 בתים. ליתר דיוק דאבל, הגודל שלו זה 8 בתים. פלואוט, הגודל שלו זה 4 בתים.
לכן דאבל מחזיק יותר מידע. זאת הסיבה שהמחשב לא מסכים בצורה ישירה להכניס את הערך שנמצא בתוך דאבל לתוך פלואוט.
ומה שקורה במקרה הזה זה נותן לנו שגיאה, פתרון לומר למחשב להתייחס ל-a כאילו שהוא פלואוט. אם אנחנו נריץ כרגע את התוכנית אנחנו נראה שאכן הוא הצליח להכניס את 123.456 או 456 לתוך משתנה פלואוט, יש את זה בגבולות של פלואוט.
אבל אם היה לנו ערך מאוד מאוד מאוד גדול כמובן שהיינו מאבדים מידע וזה היה על אחריותנו אם היינו לוקחים את הדבר ההפוך לדוגמה אם היינו באים ואומרים יש לנו איזשהו משתנה פלוט נקרא לו a1 והוא שווה בוא נניח 100 ויש לנו משתנה דאבל d a2 והוא שווה לa1 פיסט a2 ונראה שאין לנו פה אפילו
לא חצי שגיאה למה מפני שa1 הוא מטיפוס פלוט בגודל 4 בתים בזיכרון A2 הוא מטיפוס דאבל בגודל שמונה בתים בזיכרון. למחשב אין שום בעיה לקחת את הערך של הארבעה בתים ולהכניס אותו לתוך דאבל של השמונה בתים ולכן הפעולה הזאת מאושרת.
זאת אומרת שאם אנחנו מכניסים איזשהו ערך מטיפוס שמחזיק מעט מידע לטיפוס שמחזיק הרבה מידע אז כמובן שהטיפוס שמחזיק הרבה מידע אין לו שום בעיה להחזיק את המעט מידע והמחשב מאשר לנו לעשות את הפעולה בלי שום קאסטינג.
דוגמא נוספת, לצורך הדוגמא הנוספת בואו נוריד את כל אלה ונתחיל אותה מההתחלה. ניקח כאן דאבל a שווה 12.34 ודצימל b ונחליף את אחור את a. כאן זה מקרה מיוחד אחר מפני שדאבל זה שמונה בתים, דצימל זה 16 בתים.
אז איך זה יכול להיות שבמקרה הזה הוא לא מסוגל לקחת ערך שיכול להיכנס לתוך שמונה בתים להכניס אותו לתוך משתנה שיכול להחזיק 16 בתים.
אנחנו רואים גם כאן שיש לנו את השגיאה. אם אנחנו נבצע קאסטינג ונגיד לו להתייחס לזה כאילו שזה דצימל ונכניס את b, לא תהיה שום בעיה. אז כאן אנחנו רואים שמשהו אחר קרה.
ומה שקרה כאן זה שדצימל בעצם מתאר את הערך