1
00:00:00,000 --> 00:00:02,350
>> [השמעת מוסיקה]

2
00:00:02,350 --> 00:00:05,444

3
00:00:05,444 --> 00:00:06,360
דאג LLOYD: בסדר.

4
00:00:06,360 --> 00:00:07,770
סוג של נושא מוזר, נכון?

5
00:00:07,770 --> 00:00:09,050
מספרי קסם.

6
00:00:09,050 --> 00:00:12,012
מה איילה הוא מתכוון כשהוא
מדבר על מספרי קסם?

7
00:00:12,012 --> 00:00:14,220
ובכן, חלק מהתוכניות
שאנחנו כבר נכתבו בCS50

8
00:00:14,220 --> 00:00:16,660
עד כה היו כמה מוזר
מספרים שנזרקו סוג של בהם.

9
00:00:16,660 --> 00:00:19,680
אולי מסיבות שאנחנו עושים לא
לגמרי מבין עכשיו.

10
00:00:19,680 --> 00:00:23,950
לדוגמא, בבעיה מריו, ש
כתרים הגובה של הפירמידה בגיל 23.

11
00:00:23,950 --> 00:00:26,880
אנחנו במפורש אמרתי לך
לא יכול ללכת גבוה יותר מ -23.

12
00:00:26,880 --> 00:00:28,702
>> אבל מה 23 אומר?

13
00:00:28,702 --> 00:00:30,410
ובכן, אם אתה קורא את
spec בזהירות, אתה

14
00:00:30,410 --> 00:00:32,493
אולי ראה ש
סיבה שהכתרנו אותו בגיל 23

15
00:00:32,493 --> 00:00:36,160
בגלל הגובה הסטנדרטי
של חלון מסוף הוא 24.

16
00:00:36,160 --> 00:00:38,860
ולכן אם יש לנו
פירמידה להיות גבוהה יותר מזה,

17
00:00:38,860 --> 00:00:41,290
זה יכול לעשות את הדבר המוזר הזה
שבו הוא פועל מחוץ למסך.

18
00:00:41,290 --> 00:00:45,140
ואתה יודע, מה עושה
זה אומר בהקשר, נכון?

19
00:00:45,140 --> 00:00:48,880
>> האם המשמעות של 23 ברור מייד
למישהו שמסתכל על התכנית שלך

20
00:00:48,880 --> 00:00:51,550
ואולי יש שונה
חלון מסוף גודל?

21
00:00:51,550 --> 00:00:52,330
כנראה שלא.

22
00:00:52,330 --> 00:00:53,080
זה נראה כמו, אישור.

23
00:00:53,080 --> 00:00:55,005
ובכן, מדוע שזה רק פחות מ 23?

24
00:00:55,005 --> 00:00:56,880
באופן כללי, זה סוג
של הרגל רעה בעצם

25
00:00:56,880 --> 00:00:58,940
לכתוב קבועים לתוך הקוד שלך.

26
00:00:58,940 --> 00:01:02,190
בכך, כאשר אתה בעצם לעשות
לכתוב מתמדת לקוד שלך,

27
00:01:02,190 --> 00:01:05,630
לפעמים הוא מכונה באמצעות
מספרי קסם, וזה משהו ש

28
00:01:05,630 --> 00:01:08,030
אנחנו בדרך כלל רוצים לנסות ולהימנע.

29
00:01:08,030 --> 00:01:12,830
>> לדוגמא, בואו נסתכל
בפונקציה פשוטה זו כאן.

30
00:01:12,830 --> 00:01:15,726
ברור שאין נתונים
סוג C בנקרא כרטיס או סיפון.

31
00:01:15,726 --> 00:01:16,600
אז רק לשאת איתי.

32
00:01:16,600 --> 00:01:18,910
זה קצת
פסאודו קוד מעורב כאן.

33
00:01:18,910 --> 00:01:21,050
זוהי פונקציה שנקראת
להתמודד כרטיס שכנראה

34
00:01:21,050 --> 00:01:26,570
לוקח סיפון כפרמטר שלה, ו
פלט רצוני כרטיס בודד.

35
00:01:26,570 --> 00:01:30,990
>> ואני עושה כאן משהו שבו אני
יש לולאה שעוברת 0-52,

36
00:01:30,990 --> 00:01:33,394
ואני עוסק כרטיס.

37
00:01:33,394 --> 00:01:35,310
ובכן, יש לנו קסם
מספר בכאן, נכון.

38
00:01:35,310 --> 00:01:38,790
האם אתה רואה מה הוא מספר הקסם?

39
00:01:38,790 --> 00:01:42,280
או יותר מכך, אתה
לראות מה הבעיה כאן?

40
00:01:42,280 --> 00:01:44,310
במיוחד אם זה
הוא רק פונקציה אחת

41
00:01:44,310 --> 00:01:48,030
בקובץ עצמו ב
תיקייה המכילה

42
00:01:48,030 --> 00:01:49,970
חבורה של שונה
קבצים, כל אחד מהם

43
00:01:49,970 --> 00:01:51,670
עושה עוד דבר לחפיסת קלפים.

44
00:01:51,670 --> 00:01:57,310
אולי זה מערבב אותם, או עוסק יד
של חמישה כרטיסים במקום כרטיס בודד.

45
00:01:57,310 --> 00:01:59,420
>> האם אתה רואה מה ש
בעיה יכולה להיות כאן?

46
00:01:59,420 --> 00:02:03,220
האם אתה רואה את מספר הקסם
אני כבר מוזרק לתוך הקוד?

47
00:02:03,220 --> 00:02:04,390
זה 52, נכון.

48
00:02:04,390 --> 00:02:06,440
>> כמו, באופן אינטואיטיבי שאתה בוודאי יודע, בסדר.

49
00:02:06,440 --> 00:02:09,740
כמו סיפון סטנדרטי של
כרטיסים מכילים 52 קלפים.

50
00:02:09,740 --> 00:02:12,570
אבל בתכנית שלנו, זה פשוט
סוג של מרחפים שם.

51
00:02:12,570 --> 00:02:15,280
זה כמו פתאום יש 52.

52
00:02:15,280 --> 00:02:18,290
>> דרך אחת לפתור את זה
בעיה היא לעשות את זה.

53
00:02:18,290 --> 00:02:22,724
אנחנו מאוד במפורש עכשיו
קורא את גודל הסיפון כ52.

54
00:02:22,724 --> 00:02:25,390
זה נותן לו קצת יותר אינטואיטיבי
כלומר, כאשר ללולאה

55
00:02:25,390 --> 00:02:28,650
בהמשך אנו אז אומרים, אני
הוא פחות מגודל סיפון.

56
00:02:28,650 --> 00:02:32,666
זה פשוט נראה טוב יותר מאשר לומר 52.

57
00:02:32,666 --> 00:02:34,290
עכשיו זה עושה בעצם לפתור את הבעיה.

58
00:02:34,290 --> 00:02:38,460
זה נותן כמה סמלי
משמעות לקבועה.

59
00:02:38,460 --> 00:02:40,820
אבל זה סוג של ממש
להציג את בעיה נוספת

60
00:02:40,820 --> 00:02:43,770
כי לא יכול להיות ברור מייד.

61
00:02:43,770 --> 00:02:45,859
גם אם משתנה זה
הוא הכריז globally--

62
00:02:45,859 --> 00:02:47,650
אתה זוכר מה זה
אומר כאשר אנו מצהירים

63
00:02:47,650 --> 00:02:50,500
משתנה גלובלי לעומת מקומי?

64
00:02:50,500 --> 00:02:53,340
גם אם אנחנו מכריזים על משתנה
בעולם, מה אם יש

65
00:02:53,340 --> 00:02:55,500
פונקציה אחרת ב
החבילה של פונקציות שלנו

66
00:02:55,500 --> 00:02:59,750
עסקה שעם מניפולציה כרטיס
שלא במתכוון משנה גודל סיפון,

67
00:02:59,750 --> 00:03:02,727
או שזה מגדיל אותו על ידי
1 או מקטין אותו על ידי 1.

68
00:03:02,727 --> 00:03:04,060
זה יכול לאיית צרות, נכון?

69
00:03:04,060 --> 00:03:08,261
עם סט במיוחד אם יש לנו עסק
כרטיסים שבו דשדוש הסיפון המלא

70
00:03:08,261 --> 00:03:08,760
נדרש.

71
00:03:08,760 --> 00:03:12,804
אם גודל סיפון יורד
על ידי 1, למשל, ל -51,

72
00:03:12,804 --> 00:03:14,970
אנחנו לא ממש דשדוש
כל הכרטיסים אולי.

73
00:03:14,970 --> 00:03:16,500
אנחנו עוזבים אחד מהם החוצה.

74
00:03:16,500 --> 00:03:21,680
וערך שאולי יכול להיות
חזה או מנוצל על ידי שחקן רע.

75
00:03:21,680 --> 00:03:24,920
>> C מספק מה שנקרא
הוראת עיבוד מוקדמת, ש

76
00:03:24,920 --> 00:03:27,764
גם נקרא מאקרו ל
יצירת קבועים סמליים.

77
00:03:27,764 --> 00:03:30,180
ואכן, יש לך כבר
ראה הוראת עיבוד מוקדמת,

78
00:03:30,180 --> 00:03:32,916
גם אם לא שמע את זה
נקרא שעם #include.

79
00:03:32,916 --> 00:03:37,150
זה עוד דוגמא למאקרו
או הוראת עיבוד מוקדמת.

80
00:03:37,150 --> 00:03:41,290
>> דרך ליצור קבועים סמליים,
או מתן שם לקבוע

81
00:03:41,290 --> 00:03:43,740
כך שיש לו יותר
כלומר, הוא כדלקמן.

82
00:03:43,740 --> 00:03:47,030
define #, שם, החלפה.

83
00:03:47,030 --> 00:03:49,140
באמת חשוב בצד
כאן באמת מהיר.

84
00:03:49,140 --> 00:03:54,180
אין לשים פסיק ב
סוף #defines.

85
00:03:54,180 --> 00:03:57,310
אז זה define #, שם, החלפה.

86
00:03:57,310 --> 00:03:59,540
>> כאשר התכנית שלך היא הידור,
מה שקורה בפועל

87
00:03:59,540 --> 00:04:01,740
הוא מהדר אם הולכים
לעבור את הקוד שלך

88
00:04:01,740 --> 00:04:06,770
ולהחליף את כל מופעים של
המילה "שם" עם כל מה שאתה

89
00:04:06,770 --> 00:04:08,860
לשים כתחליף.

90
00:04:08,860 --> 00:04:13,060
בדומה לכך, אם #include הוא סוג
דומה לשל העתקה והדבקה,

91
00:04:13,060 --> 00:04:15,700
אז define # הוא סוג של
דומה לחיפוש והחלפה,

92
00:04:15,700 --> 00:04:19,180
אם אי פעם השתמש בתכונה שב
תכנית לעיבוד תמלילים, למשל.

93
00:04:19,180 --> 00:04:26,345
>> כך למשל, אם אני
define # pi כ3.14159265,

94
00:04:26,345 --> 00:04:28,720
אם אתה טוב יותר מבחינה מתמטית
פתאום נוטה ואתה

95
00:04:28,720 --> 00:04:31,640
לראות 3.14159265 מעופף
סביב בקוד שלך,

96
00:04:31,640 --> 00:04:33,517
אתה כנראה יודע שזה מדבר על צרכן.

97
00:04:33,517 --> 00:04:35,850
אבל אולי אנחנו יכולים לתת את זה
משמעות סמלית יותר קטנה.

98
00:04:35,850 --> 00:04:39,850
ואנחנו יכולים לומר במקום define #
pi כפה מלא כי מספרים

99
00:04:39,850 --> 00:04:42,110
כי אני לא הולך לשמור
קריאה שוב ושוב.

100
00:04:42,110 --> 00:04:45,560
>> ומה יקרה אז ב
לקמפל זמן הוא כאשר התכנית היא

101
00:04:45,560 --> 00:04:48,530
, הדבר הראשון שנערך ש
שיקרה הוא שזה ילך דרך

102
00:04:48,530 --> 00:04:51,520
והוא יחליף בכל פעם
הוא רואה P הון, אני הון,

103
00:04:51,520 --> 00:04:55,610
זה ממש יהיה להחליף אותו ב
3.14 וכן הלאה, כך שאתה

104
00:04:55,610 --> 00:04:58,090
לא צריך להקליד אותה בכל
זמן בעוד התכנית שלך עדיין

105
00:04:58,090 --> 00:05:00,631
יש את הפונקציונליות שאתה
מצפה, כי אתה עובד

106
00:05:00,631 --> 00:05:05,090
עם מניפולציה, הכפלה,
החלוקה, מה שזה לא על ידי צרכן.

107
00:05:05,090 --> 00:05:08,230
>> אתה לא מוגבל לזה
החלפה למספרים בלבד.

108
00:05:08,230 --> 00:05:12,279
לדוגמא, אני יכול define #
כמובן כCS50 המחרוזת.

109
00:05:12,279 --> 00:05:14,070
במקרה זה, כאשר
תכנית עוברת הידור,

110
00:05:14,070 --> 00:05:16,236
define # יעבור
קוד, להחליף בכל פעם

111
00:05:16,236 --> 00:05:19,900
הוא רואה "כמובן" עם CS50 המחרוזת.

112
00:05:19,900 --> 00:05:21,720
>> תוכל להבחין כאן
גם כי אני לעתים קרובות

113
00:05:21,720 --> 00:05:26,090
define # כולי מוגדר סמלי
קבועים, כביכול,

114
00:05:26,090 --> 00:05:28,130
תמיד נמצא בכל כמוסות.

115
00:05:28,130 --> 00:05:28,960
זה כנס.

116
00:05:28,960 --> 00:05:30,170
זה לא נדרש.

117
00:05:30,170 --> 00:05:33,900
הסיבה בדרך כלל אנשים ישתמשו
כל הבירות כאשר הם #defining

118
00:05:33,900 --> 00:05:37,590
רק כדי לעשות את זה ממש ברור ש
אלמנט מסוים של הקוד שלי

119
00:05:37,590 --> 00:05:38,820
הוא קבוע מוגדר.

120
00:05:38,820 --> 00:05:43,730
אם זה היה באותיות קטנות, זה אפשרי ש
זה עלול לבלבל אותם עם משתנה.

121
00:05:43,730 --> 00:05:46,120
וזה כנראה
לא דבר טוב לעשות.

122
00:05:46,120 --> 00:05:48,910
>> אז זה בפרט
הפתרון הוא הרבה יותר טוב

123
00:05:48,910 --> 00:05:50,550
יותר גם של קודמיו.

124
00:05:50,550 --> 00:05:59,950
אם אני גודל סיפון #define הראשון 52, ולאחר מכן
עכשיו השימוש שלי של 52, או גודל סיפון כאן,

125
00:05:59,950 --> 00:06:01,850
הוא הרבה יותר אינטואיטיבי והרבה יותר בטוח.

126
00:06:01,850 --> 00:06:03,280
אתה לא יכול לתפעל קבוע.

127
00:06:03,280 --> 00:06:05,259
אתה לא יכול להגיד 52 פלוס פלוס.

128
00:06:05,259 --> 00:06:06,800
זה לא הולך להמיר אותו ל -53.

129
00:06:06,800 --> 00:06:09,390
אתה לא יכול לשנות 52 למשהו.

130
00:06:09,390 --> 00:06:12,470
>> באפשרותך לשנות משתנה
הערך שלו הוא 52,

131
00:06:12,470 --> 00:06:14,870
שהיה התיקון הראשון שהיו לנו בעבר.

132
00:06:14,870 --> 00:06:17,000
ואתה יכול להגדיל
משתנה של -53.

133
00:06:17,000 --> 00:06:21,100
אבל אתה לא יכול להגיד 52 פלוס תוספת ו
יש שהופכים פתאום ל52 53.

134
00:06:21,100 --> 00:06:23,350
52 הוא תמיד 52.

135
00:06:23,350 --> 00:06:28,860
ואז אתה לא יכול לשנות בטעות
גודל סיפון כאן על ידי מניפולציה זה,

136
00:06:28,860 --> 00:06:29,940

137
00:06:29,940 --> 00:06:32,390
>> צד טוב נוסף
השפעה אם כי זה

138
00:06:32,390 --> 00:06:38,310
כי אתה מודע לכך שלא
כל המדינות ברחבי העולם

139
00:06:38,310 --> 00:06:40,690
להשתמש חפיסת הקלפים בגודל 52?

140
00:06:40,690 --> 00:06:45,630
לדוגמא, זה ממש נפוץ ב
גרמניה להשתמש בגודל חפיסת 32,

141
00:06:45,630 --> 00:06:48,020
שבו הם להפשיט את חלק
של כרטיסי הערך נמוכים יותר.

142
00:06:48,020 --> 00:06:50,960
ובמקרה הזה, אני
רציתי נמל החבילה שלי

143
00:06:50,960 --> 00:06:55,390
של פונקציות העוסקות ב
מניפולציה כרטיס לגרמניה.

144
00:06:55,390 --> 00:06:59,440
אני יכול בערכאה הראשונה ש
הראה, צריך ללכת ולהחליף

145
00:06:59,440 --> 00:07:03,570
כל המופעים של 52 בקוד שלי עם 32.

146
00:07:03,570 --> 00:07:07,940
>> אבל כאן, בגודל סיפון אם אני define #
32 בחלקו העליון של הקוד שלי,

147
00:07:07,940 --> 00:07:11,730
אם אני צריך לשנות את זה, אני יכול
פשוט ללכת ולשנות את זה דבר אחד.

148
00:07:11,730 --> 00:07:15,010
הדר מחדש את הקוד שלי, וכל
פתאום זה מתפשט דרך.

149
00:07:15,010 --> 00:07:18,850
למעשה, אנחנו יכולים לשנות את הסיפון
גודל לכל ערך שאנחנו רוצים.

150
00:07:18,850 --> 00:07:22,500
>> האם אני יכול לעניין אותך ב
משחק של טנדר גודל סיפון?

151
00:07:22,500 --> 00:07:23,430
>> אני דאג לויד.

152
00:07:23,430 --> 00:07:25,840
וזה CS50.

153
00:07:25,840 --> 00:07:27,772