1
00:00:07,632 --> 00:00:10,270
[Powered by Google Translate] ירדן JOZWIAK: ליהוק סוג, במובן הפשוט ביותר, היא

2
00:00:10,270 --> 00:00:13,300
הדרך לשנות את הפרשנות של מחשב של נתונים מסוימים על ידי

3
00:00:13,300 --> 00:00:16,560
במפורש או שינוי סוג הנתונים שלה.

4
00:00:16,560 --> 00:00:19,940
כגון שינוי int כדי לצוף, או להיפך.

5
00:00:19,940 --> 00:00:21,550
כדי להבין ליהוק סוג, אנחנו צריכים

6
00:00:21,550 --> 00:00:22,680
תתחיל עם הבסיס -

7
00:00:22,680 --> 00:00:24,140
סוגי נתונים עצמם.

8
00:00:24,140 --> 00:00:26,960
בשפות מחשב כמו C, כל המשתנים יש איזושהי

9
00:00:26,960 --> 00:00:29,690
מסוג הנתונים שקובע כיצד המחשב, וכן

10
00:00:29,690 --> 00:00:32,140
המשתמש, מפרש שמשתנה.

11
00:00:32,140 --> 00:00:35,160
סוגי נתונים מספריים כגון, לצוף int, ארוך ארוך ו

12
00:00:35,160 --> 00:00:38,110
כפול, לכולם יש מאפיינים הייחודיים משלהם והם

13
00:00:38,110 --> 00:00:41,370
משמש לציון ערכים של משתנה טווחים ודיוק.

14
00:00:41,370 --> 00:00:44,800
ליהוק סוג מאפשר לנו לקחת מספר נקודה צפה כמו

15
00:00:44,800 --> 00:00:49,170
3.14 ולקבל את החלק שלפני הנקודה העשרונית, 3 במקרה זה,

16
00:00:49,170 --> 00:00:51,590
על ידי יציקתו לint.

17
00:00:51,590 --> 00:00:53,900
בואו ניקח דוגמה מהשפה האנגליה לקצר

18
00:00:53,900 --> 00:00:56,910
סקירה של סוגים, ולראות כיצד ניתן לשנות סוג הליהוק

19
00:00:56,910 --> 00:00:59,380
הדרך בה אנו מפרשים את פיסת המידע.

20
00:00:59,380 --> 00:01:05,269
לקבלת נתונים, בואו ניקח את הסמלים כאן.

21
00:01:05,269 --> 00:01:07,570
אני מתייחס רק לקווים מוגדרים היטב אלה

22
00:01:07,570 --> 00:01:10,100
סמלים, אבל כמו מישהו שמכיר את השפה האנגליה,

23
00:01:10,100 --> 00:01:12,750
אתה מזהה מייד שהם, למעשה, מכתבים.

24
00:01:12,750 --> 00:01:15,580
אתה במרומז הבנת את סוג הנתונים.

25
00:01:15,580 --> 00:01:17,620
כאשר מסתכלים על זה מחרוזת של אותיות שניתן לראות 2

26
00:01:17,620 --> 00:01:20,140
מילים שונות, כל אחד עם משמעות משלו.

27
00:01:20,140 --> 00:01:25,530
יש שם עצם, הרוח, כמו בנושב הרוח חיצונית.

28
00:01:25,530 --> 00:01:28,280
ויש את הפועל, הרוח, כמו שבצריך

29
00:01:28,280 --> 00:01:31,410
רוח השעון האנלוגי שלי.

30
00:01:31,410 --> 00:01:33,420
זוהי דוגמה מעניינת, כי אנחנו יכולים לראות

31
00:01:33,420 --> 00:01:36,270
כיצד הסוג שאנו מקצים לנתונים שלנו, בין אם עצם או

32
00:01:36,270 --> 00:01:39,080
פעלים, שינויים איך להשתמש בנתונים אלה -

33
00:01:39,080 --> 00:01:41,730
כמילת רוח או הרוח.

34
00:01:41,730 --> 00:01:44,100
למרות שמחשב לא אכפת לו דקדוק וחלקים

35
00:01:44,100 --> 00:01:47,750
הדיבור באנגלית, אותו העיקרון הבסיסי חל.

36
00:01:47,750 --> 00:01:50,290
כלומר, אנחנו יכולים לשנות את הפרשנות שלו מדויק

37
00:01:50,290 --> 00:01:53,140
אותם נתונים המאוחסנים בזיכרון, פשוט על ידי היציקה ל

38
00:01:53,140 --> 00:01:54,576
סוג אחר.

39
00:01:54,576 --> 00:01:57,250
הנה את הגדלים של הסוגים הנפוצים ביותר על 32-bit

40
00:01:57,250 --> 00:01:58,340
מערכת הפעלה.

41
00:01:58,340 --> 00:02:02,070
יש לנו בבתי char, int 1 ולצוף ב4 בתים, ארוך

42
00:02:02,070 --> 00:02:04,390
ארוך וכפול ב8 בתים.

43
00:02:04,390 --> 00:02:07,670
בגלל int תופס 4 בתים, זה ייקח עד 32 סיבי

44
00:02:07,670 --> 00:02:10,060
כשהוא מאוחסן בזיכרון כסדרת ינארי

45
00:02:10,060 --> 00:02:11,500
של אפסים ואחדים.

46
00:02:11,500 --> 00:02:14,020
כל זמן שהמשתנה שלנו נשאר כסוג int,

47
00:02:14,020 --> 00:02:16,740
מחשב תמיד יהיה להמיר אלה והאפסים האלה מ

48
00:02:16,740 --> 00:02:19,120
בינארי למספר המקורי.

49
00:02:19,120 --> 00:02:21,270
עם זאת, אנו יכולים באופן תיאורטי להטיל אלה 32

50
00:02:21,270 --> 00:02:23,510
ביטים לשורה של סוגי וליאניים.

51
00:02:23,510 --> 00:02:26,090
ואז המחשב כבר לא רואה את מספר, אבל

52
00:02:26,090 --> 00:02:28,810
במקום אוסף של אפסים ואחדים.

53
00:02:28,810 --> 00:02:31,570
גם אנחנו יכולים לנסות לקרוא את נתונים כמספריים שונים

54
00:02:31,570 --> 00:02:34,660
הקלד, או אפילו כמחרוזת של ארבע דמויות.

55
00:02:34,660 --> 00:02:37,820
כאשר עוסקים במספרים בליהוק, עליך לשקול כיצד

56
00:02:37,820 --> 00:02:40,470
הדיוק של הערך שלך יהיה מושפע.

57
00:02:40,470 --> 00:02:43,240
קח בחשבון שהדיוק יכול להישאר אותו הדבר,

58
00:02:43,240 --> 00:02:47,150
או שאתה יכול לאבד את הדיוק, אבל אתה אף פעם לא יכול לקבל דיוק.

59
00:02:47,150 --> 00:02:49,060
בואו נעבור במשך השלוש הדרכים הנפוצות ביותר שאתה יכול

60
00:02:49,060 --> 00:02:50,400
לאבד את הדיוק.

61
00:02:50,400 --> 00:02:53,060
יציקה לצוף לint תגרום באבדן הכל

62
00:02:53,060 --> 00:02:54,900
לאחר הנקודה העשרונית, ולכן אתה נשאר

63
00:02:54,900 --> 00:02:55,950
במספר השלם.

64
00:02:55,950 --> 00:03:02,000
אם תיקחו את x המצוף שיהיה שווה 3.7, שאנו יכולים להטיל

65
00:03:02,000 --> 00:03:05,580
x זה משתנה int פשוט על ידי כתיבה בint

66
00:03:05,580 --> 00:03:07,050
סוגריים.

67
00:03:07,050 --> 00:03:10,010
בכל פעם שמשתמשים במונח הזה ממש כאן, אהיה יעיל

68
00:03:10,010 --> 00:03:12,810
ניתן להשתמש בערך השלושה משום שאנחנו כבר מקוצצים

69
00:03:12,810 --> 00:03:14,880
כל מה שאחרי הנקודה העשרונית.

70
00:03:14,880 --> 00:03:17,210
אנחנו גם יכולים להמיר ארוכים ארוכים לint, שתהיה

71
00:03:17,210 --> 00:03:20,760
בדומה להוביל לאובדן של ביטים גבוהים מסדר.

72
00:03:20,760 --> 00:03:23,910
ארוך ארוך תופס 8 בתים, או 64 סיביים בזיכרון.

73
00:03:23,910 --> 00:03:27,050
לכן, כאשר אנו מטילים אותו לint שיש 4 בתים, או 32 בלבד

74
00:03:27,050 --> 00:03:29,820
ביטים, אנו למעשה כורתים את כל הביטים כי

75
00:03:29,820 --> 00:03:32,420
מייצג את הערכים בינאריים הגבוהים יותר.

76
00:03:32,420 --> 00:03:34,690
אתה יכול גם להטיל כפול כדי לצוף, אשר תיתן לי

77
00:03:34,690 --> 00:03:37,340
אתה הקרוב ביותר האפשרי למצוף הכפול ללא

78
00:03:37,340 --> 00:03:39,100
בהכרח עיגול זה.

79
00:03:39,100 --> 00:03:41,840
בדומה לזמן הארוך שלנו להמרת int, ההפסד ב

80
00:03:41,840 --> 00:03:44,890
דיוק הוא משום כפול מכיל יותר נתונים.

81
00:03:44,890 --> 00:03:47,910
כפול יאפשר לך לאחסן 53 ביטים משמעותיים,

82
00:03:47,910 --> 00:03:50,650
בערך 16 ספרות משמעותיות.

83
00:03:50,650 --> 00:03:53,050
בעוד לצוף רק לאפשר לך לאחסן 24

84
00:03:53,050 --> 00:03:56,235
ביטים משמעותיים, בערך 7 ספרות משמעותיות.

85
00:03:56,235 --> 00:03:58,700
בשני המקרים האחרונים, זה עשוי להיות מועיל כדי לחשוב על

86
00:03:58,700 --> 00:04:01,200
הקלד ליהוק כשינוי גודל תמונה.

87
00:04:01,200 --> 00:04:03,860
כשאתה הולך מגודל גדול לגודל קטן, אתה לא יכול לראות

88
00:04:03,860 --> 00:04:05,600
דברים כמו בהירות, משום שאבדת את הנתונים

89
00:04:05,600 --> 00:04:07,530
בצורה של פיקסלים.

90
00:04:07,530 --> 00:04:09,270
ליהוק סוג יכול גם לגרום לצרות כאשר

91
00:04:09,270 --> 00:04:11,050
להטיל ints למצופים.

92
00:04:11,050 --> 00:04:13,920
מאז צף על מכונת 32-bit יש רק 24

93
00:04:13,920 --> 00:04:16,959
ביטים משמעותיים, הם לא יכולים לייצג במדויק ערכים

94
00:04:16,959 --> 00:04:22,750
מעל 2 בחזקה 24, או 16777217.

95
00:04:22,750 --> 00:04:25,540
עכשיו בואו נדבר על ליהוק גלוי וסמוי.

96
00:04:25,540 --> 00:04:28,000
ליהוק מפורש הוא כאשר אנחנו כותבים את הסוג בסוגריים

97
00:04:28,000 --> 00:04:29,430
לפני שם משתנה.

98
00:04:29,430 --> 00:04:33,100
כדוגמה, לפני שכתבנו int בסוגריים לפנינו

99
00:04:33,100 --> 00:04:35,640
לצוף x משתנה.

100
00:04:35,640 --> 00:04:37,200
בדרך זו, אנחנו מקבלים את ערך int,

101
00:04:37,200 --> 00:04:38,593
ערך מקוצץ של 3.7 -

102
00:04:38,593 --> 00:04:40,370
3.

103
00:04:40,370 --> 00:04:42,970
ליהוק משתמע הוא כאשר המהדר משנה באופן אוטומטי

104
00:04:42,970 --> 00:04:46,340
סוגים דומים לסוג סופר, או מבצעים מסוג אחר

105
00:04:46,340 --> 00:04:48,310
ליהוק ללא צורך במשתמש לכתוב

106
00:04:48,310 --> 00:04:49,720
כל קוד נוסף.

107
00:04:49,720 --> 00:04:53,550
לדוגמה, כאשר אנו מוסיפים 5 ו 1.1, הערכים שלנו כבר יש לך

108
00:04:53,550 --> 00:04:55,680
סוגים קשורים עימם.

109
00:04:55,680 --> 00:04:59,480
5 הם int, ואילו 1.1 הם לצוף.

110
00:04:59,480 --> 00:05:02,390
כדי להוסיף אותם, המחשב מטיל 5 למצוף,

111
00:05:02,390 --> 00:05:04,530
אשר היה אותו הדבר כמו בכתיבת 5.0

112
00:05:04,530 --> 00:05:06,476
המקום הראשון.

113
00:05:06,476 --> 00:05:13,210
אבל בדרך זו אנו אומרים מצוף 5, או 5.0, בתוספת מה שכבר הייתה

114
00:05:13,210 --> 00:05:16,960
לצוף, 1.1, ומשם אנחנו יכולים בעצם להוסיף אלה

115
00:05:16,960 --> 00:05:18,640
ערכים ולקבל את הערך 6.1.

116
00:05:21,170 --> 00:05:23,500
ליהוק משתמע גם מאפשר לנו להקצות משתנים של

117
00:05:23,500 --> 00:05:25,590
סוגים שונים זה לזה.

118
00:05:25,590 --> 00:05:28,110
אנחנו תמיד יכולים להקצות סוג פחות מדויק ליותר

119
00:05:28,110 --> 00:05:29,250
1 מדויק.

120
00:05:29,250 --> 00:05:37,060
לדוגמה, אם יש לנו x כפול, וint y -

121
00:05:37,060 --> 00:05:40,120
ואלה יכולים להיות ערכים שהצבנו להם -

122
00:05:40,120 --> 00:05:43,560
אנו יכולים לומר x שווה y.

123
00:05:43,560 --> 00:05:46,340
בגלל כפול יש יותר דיוק מאשר int, ולכן אנחנו

124
00:05:46,340 --> 00:05:48,380
לא יאבד את כל מידע.

125
00:05:48,380 --> 00:05:50,420
מצד השני, זה לא בהכרח יהיה נכון להגיד

126
00:05:50,420 --> 00:05:54,060
y שווה X, משום הכפול עשוי להיות ערך גדול יותר

127
00:05:54,060 --> 00:05:55,220
המספר השלם.

128
00:05:55,220 --> 00:05:57,420
וכך שלמים לא יוכל להכיל את כל

129
00:05:57,420 --> 00:05:59,560
מידע המאוחסן בכפול.

130
00:05:59,560 --> 00:06:02,610
ליהוק משתמע משמש גם בהשוואה למפעילים כמו

131
00:06:02,610 --> 00:06:06,410
יותר מ, פחות מ, או מפעיל השוויון.

132
00:06:06,410 --> 00:06:13,050
בדרך זו אנו יכולים לומר אם 5.1 הן יותר מ 5, ואנחנו מקבלים את

133
00:06:13,050 --> 00:06:14,750
תוצאה אמיתית.

134
00:06:14,750 --> 00:06:18,470
כי 5 הם int, אבל זה אהיה מנודה למצוף כדי

135
00:06:18,470 --> 00:06:22,090
אפשר להשוות למצוף 5.1, היינו אומרים הם 5.1

136
00:06:22,090 --> 00:06:24,550
גדול מ 5.0.

137
00:06:24,550 --> 00:06:31,320
הדבר נכון גם עם אומר שאם 2.0 שווים שווים 2.

138
00:06:31,320 --> 00:06:34,190
היינו גם מקבלים אמיתי, משום שהמחשב יהיה להטיל

139
00:06:34,190 --> 00:06:39,750
שלם 2 לצוף ואז אומר 2.0 שווים שווה 2.0,

140
00:06:39,750 --> 00:06:41,660
זה נכון.

141
00:06:41,660 --> 00:06:44,180
אל תשכחו שגם אנחנו יכולים להטיל בין ints ותווים,

142
00:06:44,180 --> 00:06:46,350
או ערכי ASCII.

143
00:06:46,350 --> 00:06:49,690
תווים גם צריכים להיות מופחתים לינארי, ולכן אתה

144
00:06:49,690 --> 00:06:51,920
יכול בקלות להמיר בין תווים ובהתאמה שלהם

145
00:06:51,920 --> 00:06:53,260
ערכי ASCII.

146
00:06:53,260 --> 00:06:56,180
כדי ללמוד עוד על זה, לבדוק את הווידאו שלנו בASCII.

147
00:06:56,180 --> 00:06:58,080
כאשר אתה לקחת רגע כדי לחשוב על איך נתונים מאוחסנים,

148
00:06:58,080 --> 00:06:59,990
זה מתחיל לעשות הרבה היגיון.

149
00:06:59,990 --> 00:07:02,790
זה בדיוק כמו ההבדל בין רוח ורוח.

150
00:07:02,790 --> 00:07:05,490
הנתונים הם אותו הדבר, אבל הסוג יכול לשנות את האופן שאנו

151
00:07:05,490 --> 00:07:06,720
לפרש אותו.

152
00:07:06,720 --> 00:07:10,430
השם שלי הוא ירדן Jozwiak, cs50 זה.