[Powered by Google Translate] ירדן JOZWIAK: ליהוק סוג, במובן הפשוט ביותר, היא
הדרך לשנות את הפרשנות של מחשב של נתונים מסוימים על ידי
במפורש או שינוי סוג הנתונים שלה.
כגון שינוי int כדי לצוף, או להיפך.
כדי להבין ליהוק סוג, אנחנו צריכים
תתחיל עם הבסיס -
סוגי נתונים עצמם.
בשפות מחשב כמו C, כל המשתנים יש איזושהי
מסוג הנתונים שקובע כיצד המחשב, וכן
המשתמש, מפרש שמשתנה.
סוגי נתונים מספריים כגון, לצוף int, ארוך ארוך ו
כפול, לכולם יש מאפיינים הייחודיים משלהם והם
משמש לציון ערכים של משתנה טווחים ודיוק.
ליהוק סוג מאפשר לנו לקחת מספר נקודה צפה כמו
3.14 ולקבל את החלק שלפני הנקודה העשרונית, 3 במקרה זה,
על ידי יציקתו לint.
בואו ניקח דוגמה מהשפה האנגליה לקצר
סקירה של סוגים, ולראות כיצד ניתן לשנות סוג הליהוק
הדרך בה אנו מפרשים את פיסת המידע.
לקבלת נתונים, בואו ניקח את הסמלים כאן.
אני מתייחס רק לקווים מוגדרים היטב אלה
סמלים, אבל כמו מישהו שמכיר את השפה האנגליה,
אתה מזהה מייד שהם, למעשה, מכתבים.
אתה במרומז הבנת את סוג הנתונים.
כאשר מסתכלים על זה מחרוזת של אותיות שניתן לראות 2
מילים שונות, כל אחד עם משמעות משלו.
יש שם עצם, הרוח, כמו בנושב הרוח חיצונית.
ויש את הפועל, הרוח, כמו שבצריך
רוח השעון האנלוגי שלי.
זוהי דוגמה מעניינת, כי אנחנו יכולים לראות
כיצד הסוג שאנו מקצים לנתונים שלנו, בין אם עצם או
פעלים, שינויים איך להשתמש בנתונים אלה -
כמילת רוח או הרוח.
למרות שמחשב לא אכפת לו דקדוק וחלקים
הדיבור באנגלית, אותו העיקרון הבסיסי חל.
כלומר, אנחנו יכולים לשנות את הפרשנות שלו מדויק
אותם נתונים המאוחסנים בזיכרון, פשוט על ידי היציקה ל
סוג אחר.
הנה את הגדלים של הסוגים הנפוצים ביותר על 32-bit
מערכת הפעלה.
יש לנו בבתי char, int 1 ולצוף ב4 בתים, ארוך
ארוך וכפול ב8 בתים.
בגלל int תופס 4 בתים, זה ייקח עד 32 סיבי
כשהוא מאוחסן בזיכרון כסדרת ינארי
של אפסים ואחדים.
כל זמן שהמשתנה שלנו נשאר כסוג int,
מחשב תמיד יהיה להמיר אלה והאפסים האלה מ
בינארי למספר המקורי.
עם זאת, אנו יכולים באופן תיאורטי להטיל אלה 32
ביטים לשורה של סוגי וליאניים.
ואז המחשב כבר לא רואה את מספר, אבל
במקום אוסף של אפסים ואחדים.
גם אנחנו יכולים לנסות לקרוא את נתונים כמספריים שונים
הקלד, או אפילו כמחרוזת של ארבע דמויות.
כאשר עוסקים במספרים בליהוק, עליך לשקול כיצד
הדיוק של הערך שלך יהיה מושפע.
קח בחשבון שהדיוק יכול להישאר אותו הדבר,
או שאתה יכול לאבד את הדיוק, אבל אתה אף פעם לא יכול לקבל דיוק.
בואו נעבור במשך השלוש הדרכים הנפוצות ביותר שאתה יכול
לאבד את הדיוק.
יציקה לצוף לint תגרום באבדן הכל
לאחר הנקודה העשרונית, ולכן אתה נשאר
במספר השלם.
אם תיקחו את x המצוף שיהיה שווה 3.7, שאנו יכולים להטיל
x זה משתנה int פשוט על ידי כתיבה בint
סוגריים.
בכל פעם שמשתמשים במונח הזה ממש כאן, אהיה יעיל
ניתן להשתמש בערך השלושה משום שאנחנו כבר מקוצצים
כל מה שאחרי הנקודה העשרונית.
אנחנו גם יכולים להמיר ארוכים ארוכים לint, שתהיה
בדומה להוביל לאובדן של ביטים גבוהים מסדר.
ארוך ארוך תופס 8 בתים, או 64 סיביים בזיכרון.
לכן, כאשר אנו מטילים אותו לint שיש 4 בתים, או 32 בלבד
ביטים, אנו למעשה כורתים את כל הביטים כי
מייצג את הערכים בינאריים הגבוהים יותר.
אתה יכול גם להטיל כפול כדי לצוף, אשר תיתן לי
אתה הקרוב ביותר האפשרי למצוף הכפול ללא
בהכרח עיגול זה.
בדומה לזמן הארוך שלנו להמרת int, ההפסד ב
דיוק הוא משום כפול מכיל יותר נתונים.
כפול יאפשר לך לאחסן 53 ביטים משמעותיים,
בערך 16 ספרות משמעותיות.
בעוד לצוף רק לאפשר לך לאחסן 24
ביטים משמעותיים, בערך 7 ספרות משמעותיות.
בשני המקרים האחרונים, זה עשוי להיות מועיל כדי לחשוב על
הקלד ליהוק כשינוי גודל תמונה.
כשאתה הולך מגודל גדול לגודל קטן, אתה לא יכול לראות
דברים כמו בהירות, משום שאבדת את הנתונים
בצורה של פיקסלים.
ליהוק סוג יכול גם לגרום לצרות כאשר
להטיל ints למצופים.
מאז צף על מכונת 32-bit יש רק 24
ביטים משמעותיים, הם לא יכולים לייצג במדויק ערכים
מעל 2 בחזקה 24, או 16777217.
עכשיו בואו נדבר על ליהוק גלוי וסמוי.
ליהוק מפורש הוא כאשר אנחנו כותבים את הסוג בסוגריים
לפני שם משתנה.
כדוגמה, לפני שכתבנו int בסוגריים לפנינו
לצוף x משתנה.
בדרך זו, אנחנו מקבלים את ערך int,
ערך מקוצץ של 3.7 -
3.
ליהוק משתמע הוא כאשר המהדר משנה באופן אוטומטי
סוגים דומים לסוג סופר, או מבצעים מסוג אחר
ליהוק ללא צורך במשתמש לכתוב
כל קוד נוסף.
לדוגמה, כאשר אנו מוסיפים 5 ו 1.1, הערכים שלנו כבר יש לך
סוגים קשורים עימם.
5 הם int, ואילו 1.1 הם לצוף.
כדי להוסיף אותם, המחשב מטיל 5 למצוף,
אשר היה אותו הדבר כמו בכתיבת 5.0
המקום הראשון.
אבל בדרך זו אנו אומרים מצוף 5, או 5.0, בתוספת מה שכבר הייתה
לצוף, 1.1, ומשם אנחנו יכולים בעצם להוסיף אלה
ערכים ולקבל את הערך 6.1.
ליהוק משתמע גם מאפשר לנו להקצות משתנים של
סוגים שונים זה לזה.
אנחנו תמיד יכולים להקצות סוג פחות מדויק ליותר
1 מדויק.
לדוגמה, אם יש לנו x כפול, וint y -
ואלה יכולים להיות ערכים שהצבנו להם -
אנו יכולים לומר x שווה y.
בגלל כפול יש יותר דיוק מאשר int, ולכן אנחנו
לא יאבד את כל מידע.
מצד השני, זה לא בהכרח יהיה נכון להגיד
y שווה X, משום הכפול עשוי להיות ערך גדול יותר
המספר השלם.
וכך שלמים לא יוכל להכיל את כל
מידע המאוחסן בכפול.
ליהוק משתמע משמש גם בהשוואה למפעילים כמו
יותר מ, פחות מ, או מפעיל השוויון.
בדרך זו אנו יכולים לומר אם 5.1 הן יותר מ 5, ואנחנו מקבלים את
תוצאה אמיתית.
כי 5 הם int, אבל זה אהיה מנודה למצוף כדי
אפשר להשוות למצוף 5.1, היינו אומרים הם 5.1
גדול מ 5.0.
הדבר נכון גם עם אומר שאם 2.0 שווים שווים 2.
היינו גם מקבלים אמיתי, משום שהמחשב יהיה להטיל
שלם 2 לצוף ואז אומר 2.0 שווים שווה 2.0,
זה נכון.
אל תשכחו שגם אנחנו יכולים להטיל בין ints ותווים,
או ערכי ASCII.
תווים גם צריכים להיות מופחתים לינארי, ולכן אתה
יכול בקלות להמיר בין תווים ובהתאמה שלהם
ערכי ASCII.
כדי ללמוד עוד על זה, לבדוק את הווידאו שלנו בASCII.
כאשר אתה לקחת רגע כדי לחשוב על איך נתונים מאוחסנים,
זה מתחיל לעשות הרבה היגיון.
זה בדיוק כמו ההבדל בין רוח ורוח.
הנתונים הם אותו הדבר, אבל הסוג יכול לשנות את האופן שאנו
לפרש אותו.
השם שלי הוא ירדן Jozwiak, cs50 זה.