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

2
00:00:12,410 --> 00:00:12,830
>> דוד Malan: בסדר.

3
00:00:12,830 --> 00:00:13,370
ברוך שובך.

4
00:00:13,370 --> 00:00:16,510
זה CS50, ואת זה הוא
שבוע אחד, המשיך.

5
00:00:16,510 --> 00:00:20,050
אז אחת הסיבות שאנחנו כבר עוברים
סביב טכנולוגיות כמו

6
00:00:20,050 --> 00:00:24,120
גוגל הזכוכית היא שהם מגיעים עם
משהו שנקרא API,

7
00:00:24,120 --> 00:00:25,980
ממשק תכנות יישומים.

8
00:00:25,980 --> 00:00:28,830
ומה זה אומר הוא שעם
קבצים הנכונים ועם הזכות

9
00:00:28,830 --> 00:00:32,850
תיעוד, למעשה אתה יכול לכתוב
תוכנה עבור מכשירים אפילו כמו אלה.

10
00:00:32,850 --> 00:00:36,200
>> ואז מה שיש לנו בראש לכיוון
סוף הסמסטרים הוא, אם פרויקט

11
00:00:36,200 --> 00:00:39,310
מעורבת, למשל, גוגל עשויה זכוכית
ערעור, נראה מה אנחנו יכולים לעשות ב

12
00:00:39,310 --> 00:00:42,220
מבחינת משדלת אותך עם כמה
loaner חומרה, כמו גם

13
00:00:42,220 --> 00:00:46,500
API ציבורי נגיש, כך שאתה יכול
למעשה להתחיל ליצור תוכנה

14
00:00:46,500 --> 00:00:48,630
שפועל על אותו שגוגל זכוכית.

15
00:00:48,630 --> 00:00:51,710
>> מכשיר נוסף שיש לנו כבר משחק
עם של המנוח שחשבנו שיכולים להיות

16
00:00:51,710 --> 00:00:53,910
כיף בסוף הסמסטר הוא
הדבר הקטן הזה כאן.

17
00:00:53,910 --> 00:00:56,860
זה נקרא Motion קפיצה, ומה שאתה
עומד לראות הוא מבחינה טכנית

18
00:00:56,860 --> 00:01:00,280
פרסומת למכשיר, אבל זה
אין מה לדבר זה בפרט

19
00:01:00,280 --> 00:01:01,240
מכשיר מסוגל.

20
00:01:01,240 --> 00:01:05,550
וזה גם מגיע עם ה-API באמצעות
שבו אתה יכול לכתוב תוכנה כדי

21
00:01:05,550 --> 00:01:10,545
לשלוט במחשב שלך באופן
ממש כמו סרט של דקה אחת זה כאן.

22
00:01:10,545 --> 00:01:12,070
>> [השמעת וידאו]

23
00:01:12,070 --> 00:02:08,002

24
00:02:08,002 --> 00:02:08,590
>> [השמעת וידאו הסוף]

25
00:02:08,590 --> 00:02:11,190
>> אז עכשיו, מכשיר זה קורה לי
ייעשה באופן קצת USB

26
00:02:11,190 --> 00:02:14,290
מחבר שאתה יכול לחבר אליך
מחשב, אבל אני לא אתפלא

27
00:02:14,290 --> 00:02:17,930
אם לפני זמן רב שיש לנו סוגים שונים של אלה
טכנולוגיות בקבוצה הבאה של מחשבים

28
00:02:17,930 --> 00:02:20,510
ומקינטוש, כך שאתה יכול, ואכן,
אינטראקציה עימו ב

29
00:02:20,510 --> 00:02:21,650
אופן כזה.

30
00:02:21,650 --> 00:02:24,250
למעשה, מה שחשבתי שאני רוצה לעשות, יותר מדי, הוא
אני משכתי את הפגנה קטנה

31
00:02:24,250 --> 00:02:25,860
תכנית שמגיע עם תוכנה זו.

32
00:02:25,860 --> 00:02:28,700
אז שמו לי חיישן הקטן
מול המחשב הנייד שלי.

33
00:02:28,700 --> 00:02:32,420
>> וכמו שאתה יכול לראות, זה כבר מבין
כי את היד שלי היא שיש

34
00:02:32,420 --> 00:02:33,400
השולט בה.

35
00:02:33,400 --> 00:02:37,900
וכל יישום שזה עושה זה
swimmingly דברים קטנים כמו זה.

36
00:02:37,900 --> 00:02:41,080
אבל אתה יכול לראות כי, אכן,
יש לי חמש אצבעות שם.

37
00:02:41,080 --> 00:02:44,270
אם אנחנו יכולים לקבל את זה כדי לעשות את כל 10,
אתה יכול לדמיין פסנתר מסודר

38
00:02:44,270 --> 00:02:45,390
יישום או משהו דומה.

39
00:02:45,390 --> 00:02:47,820
אז אם אתה רוצה לבוא אחרי השיעור
היום ולשחק עם זה כמו

40
00:02:47,820 --> 00:02:49,720
טוב, אתה מוזמן.

41
00:02:49,720 --> 00:02:52,930
נוסף על כך שלקראת סוף הסמסטר.

42
00:02:52,930 --> 00:02:54,420
>> אז כמה מנהלי
הכרזות.

43
00:02:54,420 --> 00:02:58,690
אחד, לעשות סעיף על ידי ביום שישי הקרוב
בצהריים בcs60.net/section.

44
00:02:58,690 --> 00:03:01,260
כתובת אתר שהוא על הקורס של
דף הבית גם כן.

45
00:03:01,260 --> 00:03:04,010
בינתיים, אם כי, supersections
יהיה הופעה ראשונה ביום ראשון הקרוב.

46
00:03:04,010 --> 00:03:07,800
Supersections הוא דבר חד פעמי,
כי זה לוקח לנו קצת זמן לעבוד

47
00:03:07,800 --> 00:03:09,470
את מי שבסעיף ובו.

48
00:03:09,470 --> 00:03:12,280
>> אז יום ראשון הקרוב זה, יהיה אחד
סעיף פחות נוח לאלה,

49
00:03:12,280 --> 00:03:14,040
סעיף אחד למי
יותר נוח.

50
00:03:14,040 --> 00:03:16,110
ואלו מכם אי שם ב
בין מוזמנים ללכת

51
00:03:16,110 --> 00:03:17,850
או בשניהם או אף אחד.

52
00:03:17,850 --> 00:03:19,150
שני אלה יהיו מצולמים.

53
00:03:19,150 --> 00:03:22,740
הם יהיו באולם גדול יותר
סעיף בדרך כלל להיות בו

54
00:03:22,740 --> 00:03:26,110
אבל המטרה כאן היא לצייד אותך עם
נחמה עם בעיה מוגדרת אחת,

55
00:03:26,110 --> 00:03:29,910
עם C, עם מכשיר CS50, זה
בסוף השבוע, גם לפני שתמצא אותך

56
00:03:29,910 --> 00:03:31,050
הקצאת סעיף פורמאלית.

57
00:03:31,050 --> 00:03:34,700
אז אתה פוגש TF שלך ושלך קטן יותר
קבוצה של sectionmates בכ

58
00:03:34,700 --> 00:03:36,350
הזמן של שבוע.

59
00:03:36,350 --> 00:03:38,200
>> שעתי עבודה, בינתיים,
כבר קורה.

60
00:03:38,200 --> 00:03:41,020
האם לנצל אותם הלילה או
הלילה אם אתה רוצה מחר.

61
00:03:41,020 --> 00:03:43,460
סט 0 בעיה הוא עקב ביום שישי.

62
00:03:43,460 --> 00:03:46,680
זהו יום יאוחר מ
באופן קבוע, מתוכנן ביום חמישי.

63
00:03:46,680 --> 00:03:50,410
אבל עם 1 סט בעיה, אתה תראה
שזה כולל כמה חימום

64
00:03:50,410 --> 00:03:52,770
תרגילים שבה אתה עצמך
יכול להאריך אותך

65
00:03:52,770 --> 00:03:54,660
מועד אחרון להגשת יום חמישי ליום שישי.

66
00:03:54,660 --> 00:03:58,410
1 סט בעיה, בינתיים, יהיה הופעה ראשונה
באתר האינטרנט של הקורס הקרוב

67
00:03:58,410 --> 00:04:02,000
יום שישי, אם אתה רוצה להתכרבל עם
זה כמו שעשיתי פעם, לפני הרבה זמן מאוחר

68
00:04:02,000 --> 00:04:04,370
יום שישי בלילה בחדר שלך.

69
00:04:04,370 --> 00:04:07,660
>> אז cs50.net/appliance הוא המקום שבו
אתה יכול לקבל את מכשיר CS50

70
00:04:07,660 --> 00:04:09,040
שהתחלנו להשתמש ביום שני.

71
00:04:09,040 --> 00:04:10,140
אנו נשתמש בזה קצת יותר היום.

72
00:04:10,140 --> 00:04:14,040
אבל היה סמוך ובטוח כי הבעיה להגדיר 1
המפרט תעבור

73
00:04:14,040 --> 00:04:16,490
בדיוק את השלבים שאתה צריך
לקום ושהפעלתו.

74
00:04:16,490 --> 00:04:22,120
אז אל תדאגו לעשות את זה לפני
1 Pset אם אתה מעדיף שלא.

75
00:04:22,120 --> 00:04:22,660
>> בסדר.

76
00:04:22,660 --> 00:04:27,180
אז אנחנו נראים ביום שני בקוד מקור,
אבל בהקשר של חדש

77
00:04:27,180 --> 00:04:30,895
שפת תכנות, כלומר ג ו-C,
שלא כמו שריטה, לא גרפי.

78
00:04:30,895 --> 00:04:32,270
זה לא חידת חתיכות.

79
00:04:32,270 --> 00:04:34,450
זה יותר כמו אנגלית תחביר.

80
00:04:34,450 --> 00:04:37,140
ויש עוד כמה צעדים המעורבים
בעצם כתיבה ובהפעלתו

81
00:04:37,140 --> 00:04:41,650
תכנית ב-C, משום שחוץ ממקור
קוד כזה, אתה צריך משהו

82
00:04:41,650 --> 00:04:42,890
נקרא מהדר.

83
00:04:42,890 --> 00:04:46,682
ובמונחים של הדיוטות, מה
אין מהדר לעשות עבורנו?

84
00:04:46,682 --> 00:04:47,650
כן.

85
00:04:47,650 --> 00:04:51,040
>> תלמיד: הוא ממיר את הקוד
שאתה כותב ל0s ו 1s.

86
00:04:51,040 --> 00:04:51,151
>> דוד Malan: טוב.

87
00:04:51,151 --> 00:04:53,580
אז הוא ממיר את הקוד ש
אנו כותבים כדי 0s ו 1s.

88
00:04:53,580 --> 00:04:57,730
הוא ממיר את קוד מקור של מה שנקרא ל
קוד יעד, האחרון שבם נראה

89
00:04:57,730 --> 00:04:59,140
משהו קטן כזה.

90
00:04:59,140 --> 00:05:02,860
וזה המעבד שלך, את המוח בתוך של
המחשב שלך, שבגלל

91
00:05:02,860 --> 00:05:06,280
אנשים שיצרו את המחשבים האלה,
יודע מה הרצפים האלה

92
00:05:06,280 --> 00:05:07,460
ממוצע של 0s ו 1s.

93
00:05:07,460 --> 00:05:08,640
>> אולי זה אומר שהדפסה.

94
00:05:08,640 --> 00:05:10,265
אולי זה אומר שבנוסף.

95
00:05:10,265 --> 00:05:11,610
אולי זה אומר שחיסור.

96
00:05:11,610 --> 00:05:13,350
אולי זה אומר להציג בצורה גרפית.

97
00:05:13,350 --> 00:05:16,870
יש דפוסים מוגדרים מראש של ביטים
שהעולם החליט אומר

98
00:05:16,870 --> 00:05:17,700
דברים מסוימים.

99
00:05:17,700 --> 00:05:20,760
אבל על פי רוב בקורס זה,
אנחנו נעבוד ברמה גבוהה יותר, ו

100
00:05:20,760 --> 00:05:24,180
אנו לוקחים כמובן מאליו שקיימת
דברים כמו מהדרים שיכולים

101
00:05:24,180 --> 00:05:27,670
להפוך את פונקצית קוד המקור שלנו
בדרך בה אנו מתכוונים.

102
00:05:27,670 --> 00:05:31,660
>> אז התכנית הראשונה שכתבנו בשבוע שעבר
ולאחר מכן החל לנמל, ולכן כדי

103
00:05:31,660 --> 00:05:33,920
לדבר, C האחרון
יום שני, היה זה.

104
00:05:33,920 --> 00:05:35,700
כשלחץ על הדגל ירוק, לומר שלום.

105
00:05:35,700 --> 00:05:37,430
זה היה, כמובן,
נכתב בסריטות.

106
00:05:37,430 --> 00:05:40,710
ואני טענו שאת המקבילה
תכנית ב-C נראית קצת

107
00:05:40,710 --> 00:05:41,520
משהו כזה.

108
00:05:41,520 --> 00:05:45,050
>> אז מה חשבתי שאנחנו היינו עושים בהתחלה הוא,
בואו להפריד את מה שנראה בתחילה

109
00:05:45,050 --> 00:05:48,790
מבט חטוף, יש להודות, כמסתורי למדי
תחביר, אבל אתה מתחיל לשים לב

110
00:05:48,790 --> 00:05:50,160
דפוסים די מהר.

111
00:05:50,160 --> 00:05:53,770
מה שאנחנו נעשה גם היום הוא מספקים
לך עם מודל המנטלי לחלק

112
00:05:53,770 --> 00:05:57,280
הקנונית, כמה מבנים סטנדרטיים
בתכנות.

113
00:05:57,280 --> 00:06:00,420
ואז אנחנו באמת תוכלו לשים את ידינו
מלוכלך עם כמה דוגמאות, כמו גם.

114
00:06:00,420 --> 00:06:04,140
>> אז לאלה מכם יותר נוחים,
להבין שזה שבוע ולאחר מכן הבא

115
00:06:04,140 --> 00:06:05,940
שבוע עשוי להיות קצת ביקורת טובה מאוד.

116
00:06:05,940 --> 00:06:08,810
אבל במיוחד כאשר מהדורת ההאקר
בעיה של 1 סט יוצא ב

117
00:06:08,810 --> 00:06:12,330
באתר הבית של הקורס ביום שישי, אני חושב
תגלו שגם לך למלא

118
00:06:12,330 --> 00:06:15,390
כמה מקומות ריקים במהלך השבוע הבא או שתיים,
אתה מתחיל לקבל יותר ויותר

119
00:06:15,390 --> 00:06:18,410
מאותגר ונתקל
דברים חדשים וחדשים יותר.

120
00:06:18,410 --> 00:06:21,310
>> אז בואו להקניט מלבד תכנית זו
כמה שורות בכל פעם.

121
00:06:21,310 --> 00:06:24,140
בחלקו העליון, יש לנו מה
נקרא טכני

122
00:06:24,140 --> 00:06:25,950
הוראת preprocessor.

123
00:06:25,950 --> 00:06:30,510
זוהי רק שורת קוד שאומרת
כדי לכלול את התוכן של קובץ,

124
00:06:30,510 --> 00:06:35,080
קרא לי סטנדרטי / N, קלט סטנדרטי -
או, סליחה, קלט / פלט הסטנדרטי, תקן

125
00:06:35,080 --> 00:06:38,670
קלט / פלט,. שעות, בתוך
בתכנית שלי.

126
00:06:38,670 --> 00:06:41,670
>> אז במילים אחרות, אם אני כתבתי את זה
תכנית עם עורך טקסט פשוט כמו

127
00:06:41,670 --> 00:06:45,260
gedit, המקבילה הפשוטה יותר של
משהו כמו Microsoft Word, ש

128
00:06:45,260 --> 00:06:50,970
הוראה, # כולל stdio.h, היא רק
הולך לספר את המהדר, לתפוס

129
00:06:50,970 --> 00:06:56,080
תוכן של קובץ אחר ש, stdio.h,
ולהדביק אותם כאן.

130
00:06:56,080 --> 00:06:57,090
>> עכשיו, למה אכפת לי?

131
00:06:57,090 --> 00:07:01,850
מה שאנחנו טוענים הוא בתוך קובץ זה
קרא stdio.h, אשר מאוחסן

132
00:07:01,850 --> 00:07:05,490
מקום בכונן הקשיח שלי, או בזה
מקרה, אי שם במכשיר CS50?

133
00:07:05,490 --> 00:07:06,635
מישהו אחר שם אותו שם בשבילי.

134
00:07:06,635 --> 00:07:09,910
אבל מה יש בו?

135
00:07:09,910 --> 00:07:13,020
>> כן, כך שזה הכרזה
פונקציה בשם printf.

136
00:07:13,020 --> 00:07:17,400
אז נזכר printf הפונקציה ה
מילים ותווים ומציגים

137
00:07:17,400 --> 00:07:20,160
מספרים המופיעים על המסך בהצעה שלי.

138
00:07:20,160 --> 00:07:21,220
אבל אני לא כתבתי את זה.

139
00:07:21,220 --> 00:07:22,230
CS50 לא כתב אותו.

140
00:07:22,230 --> 00:07:26,990
שנים לפני שמישהו כתבו אותו, והם
בעצם נתן לנו את המתכון לזה

141
00:07:26,990 --> 00:07:29,110
בקובץ שנקרא stdio.h.

142
00:07:29,110 --> 00:07:33,240
כך שהשורה ראשונה רק נותנת לי לגשת
לפונקציות שמישהו אחר

143
00:07:33,240 --> 00:07:36,500
כתב לפני שנים, בין
אשר printf.

144
00:07:36,500 --> 00:07:39,450
>> עכשיו, בשורה הבאה אני הולך לנופפי
ביד, לפחות עד השבוע הבא.

145
00:07:39,450 --> 00:07:43,620
אבל לעת עתה, יודע שהוא int הראשי (חלל)
בעצם שווה ערך לכך

146
00:07:43,620 --> 00:07:46,310
פיסת הפאזל צהובה כאשר
הדגל ירוק לחיצה עליו.

147
00:07:46,310 --> 00:07:49,510
העולם, לפני שנים, החליט שאם
אתה כותב בתכנית

148
00:07:49,510 --> 00:07:53,150
שפה בשם C, אתה מתחיל
התכנית שלך עם קו

149
00:07:53,150 --> 00:07:54,410
זה נראה ככה.

150
00:07:54,410 --> 00:07:57,650
כמעט בזמן של שבוע, זה יעשה
תחושת int מה הוא, מה הוא חלל ריק.

151
00:07:57,650 --> 00:08:00,840
אבל לעת עתה, רק לחשוב על זה
כפיסת הפאזל הצהובה הזה.

152
00:08:00,840 --> 00:08:04,550
>> עכשיו הבא, יש לנו סד מתולתל ואחרי
על ידי סד מתולתל קרוב אחר,

153
00:08:04,550 --> 00:08:05,240
אם אפשר לומר כך.

154
00:08:05,240 --> 00:08:07,430
ואנו רואים בכל אלה
תוכניות ב-C, כמו גם

155
00:08:07,430 --> 00:08:08,930
JavaScript ו-PHP.

156
00:08:08,930 --> 00:08:11,345
ואלה הם רק לתמצת
קווים הקשורים של קוד.

157
00:08:11,345 --> 00:08:14,600
הסד המתולתל הפתוח למעשה
אומר, הנה מגיע קצת קוד.

158
00:08:14,600 --> 00:08:17,590
וסד המתולתל הסגור, שהוא
זווית לכיוון השני, בדיוק

159
00:08:17,590 --> 00:08:19,920
אמצעי, זהו זה ל
הקוד הרלוונטי.

160
00:08:19,920 --> 00:08:22,970
>> אז השורה עסיסית בזה ראשון
תכנית היא אחרון, printf,

161
00:08:22,970 --> 00:08:25,080
במרכאות, שלום עולם.

162
00:08:25,080 --> 00:08:30,670
ואני קראתי את הדבר בין
ציטוטים מה הפעם האחרונה?

163
00:08:30,670 --> 00:08:31,285
אז זה מחרוזת.

164
00:08:31,285 --> 00:08:35,309
ומחרוזת היא רק טכנאי
טווח עבור רצף של

165
00:08:35,309 --> 00:08:37,169
דמויות, מילה, משפט.

166
00:08:37,169 --> 00:08:39,380
יכלה אפילו אות אחת
להיות מצוטט כפול.

167
00:08:39,380 --> 00:08:41,840
אבל זה רצף של אפס
תווים או יותר.

168
00:08:41,840 --> 00:08:43,650
>> לוכסן-N, אם כי, נראה
קצת מוזר.

169
00:08:43,650 --> 00:08:46,290
אבל זה פשוט התכוון למשהו
פשוט למחשב.

170
00:08:46,290 --> 00:08:48,060
מה קו נטוי-n?

171
00:08:48,060 --> 00:08:48,570
קו חדש.

172
00:08:48,570 --> 00:08:52,490
אז זה פשוט רצף המיוחד של
דמויות שהעולם החליט

173
00:08:52,490 --> 00:08:56,880
אמצעי לשים מעבר שורה ממש שם,
בגלל המהדר למעשה יקבל

174
00:08:56,880 --> 00:09:02,280
מבולבל, בדרך כלל, אם אתה, מאוד
מובן, אבל באופן שגוי, רק

175
00:09:02,280 --> 00:09:04,570
תתחיל להכות על Enter כדי לשים
קווים חדשים בקוד שלך.

176
00:09:04,570 --> 00:09:07,150
אתה צריך להיות קצת יותר
מפורש עם קו נטוי-n.

177
00:09:07,150 --> 00:09:10,540
>> ואנו רואים שיש כמה אחרים כגון
דפוסים לתווים מיוחדים.

178
00:09:10,540 --> 00:09:14,340
למשל, אם אתה רוצה לתת לך
אכפת לנדוד למקרה פינה,

179
00:09:14,340 --> 00:09:18,080
נניח שאני רוצה להדפיס
ציטוט כפול על המסך עבור

180
00:09:18,080 --> 00:09:21,840
מהסיבה כלשהי, שהיה נראה
להיות בעייתי, ממש קטן?

181
00:09:21,840 --> 00:09:24,990
כי אם אני שם את ציטוט כפול ב
אמצע "שלום, העולם", לכל מה

182
00:09:24,990 --> 00:09:30,120
סיבה, מדוע שנראה
פוטנציאל בעייתי?

183
00:09:30,120 --> 00:09:32,180
זה שובר את המחרוזת.

184
00:09:32,180 --> 00:09:34,700
>> מהדר הוא רק תכנית.

185
00:09:34,700 --> 00:09:37,210
תכנית כמו מהדר היא רק הולכת
לקרוא את הקוד שלך למעלה עד למטה,

186
00:09:37,210 --> 00:09:37,990
משמאל לימין.

187
00:09:37,990 --> 00:09:41,850
ואם רואה שלוש מרכאות כפולות במקום
לשתיים, זה לא הולך לדעת

188
00:09:41,850 --> 00:09:45,210
אם אתה אומר שהדבר שמשמאל
צריכה להיות מחרוזת, או דבר

189
00:09:45,210 --> 00:09:46,570
הנכון, או את כל העניין.

190
00:09:46,570 --> 00:09:50,560
זה לא ברור, ואז מה טיפוסי
מהדר הייתי לעשות הוא פשוט להתחרפן,

191
00:09:50,560 --> 00:09:53,710
ואתן לך הודעת שגיאה כלשהי, ו
לגרום לך להתמודד עם הבעיה.

192
00:09:53,710 --> 00:09:58,120
>> אז בהתחשב בכך שהלוכסן-n פירוש חדש
קו, מה היה האינסטינקטים שלך עכשיו

193
00:09:58,120 --> 00:10:02,610
להתחיל להיות בו אם אתה רוצה לכלול
משהו חריג כמו כפול

194
00:10:02,610 --> 00:10:06,210
תצטט את החלק הפנימי של זה מצוטט אחרת
מחרוזת?

195
00:10:06,210 --> 00:10:07,640
ציטוט נטוי הפוך כפול.

196
00:10:07,640 --> 00:10:09,630
וכך יהיה לנו לראות את זה
סוג של דפוס מדי.

197
00:10:09,630 --> 00:10:12,490
>> אם אתה רוצה לעשות משהו קצת
מוזר, אתה תמצא כי

198
00:10:12,490 --> 00:10:15,060
פתרונות לעתים קרובות לעקוב אחר דפוס,
וקו הנטוי

199
00:10:15,060 --> 00:10:17,150
מציין רצף בריחה.

200
00:10:17,150 --> 00:10:20,320
וזה רק אומר שמשהו מיוחד
שאנחנו צריכים לייצג ב

201
00:10:20,320 --> 00:10:21,060
דרך אחרת.

202
00:10:21,060 --> 00:10:23,830
באשר לאיך אתה מייצג
קו נטוי, ובכן, אנחנו

203
00:10:23,830 --> 00:10:24,550
תחזור לזה.

204
00:10:24,550 --> 00:10:26,930
אבל התשובה, גם היא למעשה
קצת ברור.

205
00:10:26,930 --> 00:10:31,080
>> אז בואו עכשיו להכניס קצת אחר
תכנות בונה

206
00:10:31,080 --> 00:10:31,915
שראית בלגרד.

207
00:10:31,915 --> 00:10:34,790
יש לך כנראה מובן מאליו
כבר אם כבר צלל לתוך

208
00:10:34,790 --> 00:10:36,060
בעיה מוגדרת 0.

209
00:10:36,060 --> 00:10:40,950
אבל בואו עכשיו להציג את התחביר ב-C
לאלה אחרת אינטואיטיבי למדי

210
00:10:40,950 --> 00:10:42,300
רעיונות, לפחות חלק מהם.

211
00:10:42,300 --> 00:10:45,570
>> אז הרעיון הזה של תנאי או
סניף, בעוד שבעברנו

212
00:10:45,570 --> 00:10:49,330
ייצג אותו עם קוד שנראה
ככה בצד השמאל בלגרד -

213
00:10:49,330 --> 00:10:52,200
אם x קטן מ-y, אז אומרים כך -

214
00:10:52,200 --> 00:10:56,760
במקום כעת ב-C - תנו לי לחדד
במקרה הפשוט ביותר -

215
00:10:56,760 --> 00:11:01,235
אנחנו פשוט הולכים להגיד, אם, פתחו
סוגריים, משהו נכון -

216
00:11:01,235 --> 00:11:04,190
ביטוי בוליאני הוא הולך
שבו שכבר אמר מצב -

217
00:11:04,190 --> 00:11:08,170
סגור סוגריים, אז מה
בתוך הסוגריים המסולסלים האלה.

218
00:11:08,170 --> 00:11:11,020
>> אז גם כאן, בסוגריים המסולסלים
הם כמו סוג של שריטה של

219
00:11:11,020 --> 00:11:12,460
חלקי הפאזל בצורת פרסה.

220
00:11:12,460 --> 00:11:14,890
לעשות את מה שבתוך סוגריים מסולסלים אלה.

221
00:11:14,890 --> 00:11:16,790
במקרה זה, לחתוך לקצץ.

222
00:11:16,790 --> 00:11:19,720
ומבחין זאת היא קדימה
לקצץ, לא קו נטוי.

223
00:11:19,720 --> 00:11:21,440
קו נטוי, קו נטוי,
למי הוא כבר מתוכנת

224
00:11:21,440 --> 00:11:23,370
בעבר, רק אומר -

225
00:11:23,370 --> 00:11:24,190
זה רק הערה.

226
00:11:24,190 --> 00:11:26,630
תגובה היא לא קו
של קוד, כשלעצמה.

227
00:11:26,630 --> 00:11:30,200
זה קו של אנגלית שאתה,
אנושי, שכתב לעצמך כדי

228
00:11:30,200 --> 00:11:33,540
אולי להזכיר לך לעשות משהו, כדי
להסביר לעצמך, כדי להסביר לי

229
00:11:33,540 --> 00:11:35,260
מישהו אחר, מה הקוד שלך עושה.

230
00:11:35,260 --> 00:11:37,050
זה רק תגובה תיאורי.

231
00:11:37,050 --> 00:11:40,880
>> עכשיו, כמובן, אנחנו יכולים להיות דו סטרי
מזלג על הכביש רק על ידי עושה את זה,

232
00:11:40,880 --> 00:11:43,930
מזלג שלוש דרך בכביש על ידי עושה
זה, ואם ימשיכו כך

233
00:11:43,930 --> 00:11:47,570
דפוס, אתה יכול לקבל דרך ארבעה,
חמישה כיוונים, שישה מזלגות דרך בכביש אם

234
00:11:47,570 --> 00:11:50,150
אתה צריך לטפל בו, ואכן,
כי תנאים רבים.

235
00:11:50,150 --> 00:11:52,010
ואז שם לב להקבלה כאן -

236
00:11:52,010 --> 00:11:55,070
אם (תנאים), אחר אם (מצב),
ורק אחד שזה קצת

237
00:11:55,070 --> 00:11:58,010
המוזר הוא שעבר, שבי
כי הוא פשוט אחר.

238
00:11:58,010 --> 00:12:01,170
אבל שוב, זה זהה,
מבחינה מושגית, על מה שעשינו

239
00:12:01,170 --> 00:12:04,690
כבר, למרות שהתחביר יהיה
לוקח קצת זמן להתרגל.

240
00:12:04,690 --> 00:12:07,730
>> עכשיו, בדוגמה זו, יש
חלק תחביר מוזר אחר.

241
00:12:07,730 --> 00:12:11,220
אנו רואים printf שוב, סוגריים פותחים,
וסוגריים קרובים.

242
00:12:11,220 --> 00:12:13,190
ובתוך קיים
מחרוזת מצוטטת.

243
00:12:13,190 --> 00:12:17,060
בסוגריים, בהקשר
של printf, ללכת בצד השמאל

244
00:12:17,060 --> 00:12:18,160
וזכותו של מה?

245
00:12:18,160 --> 00:12:22,190
מה שאנו מתארים שצוטטנו
מחרוזת כבאופן כללי יותר?

246
00:12:22,190 --> 00:12:23,320
>> אז זה ויכוח.

247
00:12:23,320 --> 00:12:26,620
בכל פעם שיש לך פונקציה, כמו
printf, ולאחר מכן paren פתוח ו

248
00:12:26,620 --> 00:12:30,330
paren הקרוב ומשהו בתוך
זה, בין אם זה מחרוזת, או

249
00:12:30,330 --> 00:12:34,420
מספר שלם, או כל דבר אחר, הדבר ב
בין הסוגריים האלה נקרא

250
00:12:34,420 --> 00:12:35,110
טיעון.

251
00:12:35,110 --> 00:12:37,910
>> וויכוח רק משפיע
ההתנהגות של הפונקציה.

252
00:12:37,910 --> 00:12:39,990
במקרה זה, זה די ברור איך.

253
00:12:39,990 --> 00:12:44,480
X <Y הוא מה שמועבר ב,
אם אפשר לומר כך, כטיעון.

254
00:12:44,480 --> 00:12:47,720
Printf והולך
להדפיס בדיוק את זה.

255
00:12:47,720 --> 00:12:51,590
כי מה שבטוח, לפני השנים האדם
שיושם printf היה לי מושג

256
00:12:51,590 --> 00:12:55,000
מה שאנו ממשיכי אדם היו
הולך להשתמש printf ל.

257
00:12:55,000 --> 00:12:58,610
אז זאת הסיבה שהטיעונים קיימים, כדי
להשפיע על התנהגות לאחר הפונקציה של

258
00:12:58,610 --> 00:12:59,450
כבר נכתב.

259
00:12:59,450 --> 00:13:00,780
>> עכשיו, ביטוי בוליאני.

260
00:13:00,780 --> 00:13:02,470
אלה שראינו לפני כן בגרד.

261
00:13:02,470 --> 00:13:06,680
מתברר בC אתה יכול גם "או"
אותם ביחד, אם אפשר לומר כך.

262
00:13:06,680 --> 00:13:10,930
שני קווים אנכיים אומר שהבלוק הזה
של קוד, זה עושה את זה, יהיה

263
00:13:10,930 --> 00:13:15,350
לבצע אם התנאי הראשון הוא נכון
או התנאי השני הוא נכון.

264
00:13:15,350 --> 00:13:17,710
ולמרות שאתה אולי לא הייתי עושה
זה בסריטות, אתה יכול באמת

265
00:13:17,710 --> 00:13:20,580
לעשות את זה בסריטות, ואתה יכול גם
להביע את עצמך באופן שונה -

266
00:13:20,580 --> 00:13:25,300
אם התנאי הראשון והשני
המצב נכון, אז אין מה

267
00:13:25,300 --> 00:13:27,160
בתוך הסוגריים המסולסלים.

268
00:13:27,160 --> 00:13:31,210
>> ובדיוק כמו בצד, סיבה שזה
אמפרסנד כפול וכפול

269
00:13:31,210 --> 00:13:34,610
פס אנכי, נראה בסופו של
שבר אנכי יחיד ו

270
00:13:34,610 --> 00:13:38,710
אמפרסנד יחיד למעשה יש שונה
כלומר בג אז לעת עתה,

271
00:13:38,710 --> 00:13:41,840
כפילות זו של סמלים
הוא מכוון.

272
00:13:41,840 --> 00:13:45,070
>> אז בואו נציג, בקצרה,
קצת אחרים כך של תחביר.

273
00:13:45,070 --> 00:13:48,940
זה לא ממש לשאת מעל ל
שריטה, אבל אני טוען שאני יכול

274
00:13:48,940 --> 00:13:55,190
ליישם את הרעיון של אם אחר, אם
דבר אחר, אם אחר, אם הצהרה אחרת באמצעות

275
00:13:55,190 --> 00:13:56,760
משהו שנקרא הצהרה בורר.

276
00:13:56,760 --> 00:14:00,820
והסיבה היחידה שזה באמת קיים
הוא פשוט לתת לך, המתכנת,

277
00:14:00,820 --> 00:14:05,470
דרך לפתרון קצת שונה במקצת
בעיה, למרות שזה הגיוני

278
00:14:05,470 --> 00:14:07,340
לא נותן לך את כל יכולות חדשות.

279
00:14:07,340 --> 00:14:08,530
>> בכך אני מתכוון לזה.

280
00:14:08,530 --> 00:14:13,330
כשאתה אומר מתג, ולאחר מכן רווח,
ולאחר מכן זוג סוגריים, בתוך

281
00:14:13,330 --> 00:14:14,570
אשר הולך ביטוי -

282
00:14:14,570 --> 00:14:18,010
וזה יכול להיות קצת לא ברור,
בהתחלה, אבל זה לא ויכוח,

283
00:14:18,010 --> 00:14:20,680
מבחינה טכנית, כי מתג
אינה פונקציה.

284
00:14:20,680 --> 00:14:24,230
אז לעת עתה, רק להניח כי אנו משתמשים
סוגריים במקומות שונים

285
00:14:24,230 --> 00:14:25,250
מסיבות שונות.

286
00:14:25,250 --> 00:14:29,310
>> אז לעבור על ביטוי אומר שאני יכול
לשים בתוך משתנה מאלה

287
00:14:29,310 --> 00:14:31,350
סוגריים שבו כתוב ביטוי.

288
00:14:31,350 --> 00:14:33,090
ולאחר מכן, אם כי משתנה -

289
00:14:33,090 --> 00:14:35,400
מניח שזה נקרא X, ו
זה רק מספר שלם -

290
00:14:35,400 --> 00:14:38,900
אז אני יכול למנות בשקופית שלי
כאן משהו כזה.

291
00:14:38,900 --> 00:14:41,690
אם x הוא משתנה שלי, ואני
רוצה לעשות משהו אם x

292
00:14:41,690 --> 00:14:43,480
שווה 1, אני יכול לעשות את זה.

293
00:14:43,480 --> 00:14:46,660
>> אם אני רוצה לעשות במקום משהו
אם x הוא 2, אני יכול לעשות את זה.

294
00:14:46,660 --> 00:14:50,390
דבר אחר, אם אני רוצה לעשות משהו אחר
לגמרי, אני יכול לקבל את ברירת מחדל במקרה

295
00:14:50,390 --> 00:14:52,750
מקרה שבו אני עושה את הדבר האחר הזה.

296
00:14:52,750 --> 00:14:58,730
אז במובן הזה, זה שווה ערך ל
אם x שווה שווה 1, אחר אם אחר,

297
00:14:58,730 --> 00:15:01,150
אבל אני מזכיר את זה עכשיו רק בגלל
אנחנו תראו את זה שוב.

298
00:15:01,150 --> 00:15:03,720
אבל לעת עתה, רק יודע שזה קיים.

299
00:15:03,720 --> 00:15:04,220
>> בסדר.

300
00:15:04,220 --> 00:15:07,660
אז הזוג האחרון אלה הם קצת יותר
מורכב במבט הראשון, אבל הם עושים

301
00:15:07,660 --> 00:15:09,385
משהו פשוט למדי.

302
00:15:09,385 --> 00:15:14,410
ללולאה ב-C הוא נתח של קוד ש
פשוט עושה משהו שוב ו

303
00:15:14,410 --> 00:15:15,330
שוב ושוב.

304
00:15:15,330 --> 00:15:17,590
והדבר המעצבן רק על זה הוא
שהוא שזה קצת סתום

305
00:15:17,590 --> 00:15:21,380
להביע את עצמך בזה מחזורי
דפוס, אבל העולם טופל על

306
00:15:21,380 --> 00:15:22,450
הדרך הבאה.

307
00:15:22,450 --> 00:15:25,760
>> כאשר אתה משתמש בלולאה, יש לך
זוג סוגריים שוב.

308
00:15:25,760 --> 00:15:27,570
ושים לב את שני פסיק
לשם.

309
00:15:27,570 --> 00:15:34,380
אלה שני פסיק שלוש נפרד
ביטויים שונים בתוך של

310
00:15:34,380 --> 00:15:35,020
סוגריים.

311
00:15:35,020 --> 00:15:37,170
אחת הוא מה שנקרא האתחולים.

312
00:15:37,170 --> 00:15:38,830
אחד מהם הוא המצב שנקרא.

313
00:15:38,830 --> 00:15:40,210
ואחת הוא את העדכונים שנקראו.

314
00:15:40,210 --> 00:15:43,240
>> הסתכלתי באופן מופשט, זה
לחלוטין לא ברור, אז בואו נראים

315
00:15:43,240 --> 00:15:44,630
בדוגמה קונקרטית.

316
00:15:44,630 --> 00:15:46,720
בשריטה שהיו לנו גוש חוזר.

317
00:15:46,720 --> 00:15:50,670
ובלוק זה אמר לחזור 10 פעמים, אומר
"שלום, עולם". תן לי לתבוע

318
00:15:50,670 --> 00:15:53,810
עכשיו, ואנחנו עוד נחזור לזה, ו
גם את זה, יקבל יותר מוכר

319
00:15:53,810 --> 00:15:57,345
לך לפני זמן רב, שווה ערך C
קוד יכול להיות אמר להיות זה -

320
00:15:57,345 --> 00:16:02,320
להצהרה וחלל, זוג
סוגריים, שימו לב לפסיק ב

321
00:16:02,320 --> 00:16:05,730
שם, מה שיפריד בין שלוש ברורים
דברים, האתחול, את

322
00:16:05,730 --> 00:16:07,320
מצבו, ואת העדכון.

323
00:16:07,320 --> 00:16:08,840
>> ותיקח ניחוש מה
הראשון הוא עושה.

324
00:16:08,840 --> 00:16:10,690
אני int = 0.

325
00:16:10,690 --> 00:16:15,120
במונחים של הדיוטות מחוספסת, מה היא
שעושה לנו, כנראה?

326
00:16:15,120 --> 00:16:15,590
אז כן.

327
00:16:15,590 --> 00:16:19,630
זה שהכריז על משתנה בשמי,
וזה מה שנותן לו ערך?

328
00:16:19,630 --> 00:16:20,220
0.

329
00:16:20,220 --> 00:16:24,280
אז זה יוצר משתנה בשם
אני, אחסון 0 הערך בו.

330
00:16:24,280 --> 00:16:26,420
זה האתחול מה שנקרא.

331
00:16:26,420 --> 00:16:29,360
>> בסדר, עכשיו אני טענו לפני
כי הדבר באמצע, אני

332
00:16:29,360 --> 00:16:31,760
<10, הוא המצב.

333
00:16:31,760 --> 00:16:32,730
אז מה הוא עושה?

334
00:16:32,730 --> 00:16:36,560
ובכן, מה עושה כאשר ללולאה
תכנית עם ללולאה לרוץ, הוא

335
00:16:36,560 --> 00:16:41,050
בכל פעם שמחשב פועל באמצעות
לולאה זו, מלמעלה למטה, עד הראש

336
00:16:41,050 --> 00:16:43,740
תחתון, בדיוק כמו שאתם עשית כש
סופרים את עצמכם ולשבת,

337
00:16:43,740 --> 00:16:47,090
שוב ושוב ושוב,
המחשב הולך

338
00:16:47,090 --> 00:16:48,560
כדי לבדוק את המצב הזה.

339
00:16:48,560 --> 00:16:51,140
ואם אני הוא פחות מ -10,
זה יעשה את זה שוב.

340
00:16:51,140 --> 00:16:53,100
אם אני הוא פחות מ -10,
זה יעשה את זה שוב.

341
00:16:53,100 --> 00:16:55,030
אם אני פחות מעשר,
זה יעשה את זה שוב.

342
00:16:55,030 --> 00:16:57,330
כך שנראה כי מראה כי
אני מקווה שאני משתנה.

343
00:16:57,330 --> 00:16:59,010
אחרת, תהיה לנו ללולאה אינסופית.

344
00:16:59,010 --> 00:17:02,590
ואכן, אני משתנה, כי
הדבר האחרון שאחרי פסיק יש

345
00:17:02,590 --> 00:17:05,569
הוא התחביר הסתום משהו של i + +.

346
00:17:05,569 --> 00:17:07,630
אבל אלה מכם שכבר עשו את זה
בעבר, זה רק אומר

347
00:17:07,630 --> 00:17:08,609
די פשוט מה?

348
00:17:08,609 --> 00:17:09,730
>> תלמידים: [חציצת קולות].

349
00:17:09,730 --> 00:17:10,740
>> דוד Malan: 1 הוסף לי.

350
00:17:10,740 --> 00:17:11,819
להגדיל לי.

351
00:17:11,819 --> 00:17:13,910
אז ראינו את הפאזל סריטות
חתיכה בשביל זה, בעצם.

352
00:17:13,910 --> 00:17:18,230
זה לא נראה כמו אני + +, אבל זה פשוט
פירושו, בפשטות, להגדיל

353
00:17:18,230 --> 00:17:24,040
אני מעריך עד ליום 1 בכל פעם שאתה עושה את זה.

354
00:17:24,040 --> 00:17:26,910
כך, פשוטו כמשמעו, אתה מתחיל על ידי
אני מאתחל ל -0.

355
00:17:26,910 --> 00:17:29,520
אתה ולאחר מכן לבדוק את המצב שלך.

356
00:17:29,520 --> 00:17:31,070
האם 0 פחות מ 10?

357
00:17:31,070 --> 00:17:31,730
כן.

358
00:17:31,730 --> 00:17:32,910
אנחנו עוברים את הלולאה.

359
00:17:32,910 --> 00:17:35,150
>> הדבר הבא שאני טוען את המחשב של
הולך לעשות הוא שזה הולך

360
00:17:35,150 --> 00:17:35,910
כדי להגדיל לי.

361
00:17:35,910 --> 00:17:37,080
אז אני כרגע הוא 1.

362
00:17:37,080 --> 00:17:37,940
הוא בודק את מצבו.

363
00:17:37,940 --> 00:17:39,290
הוא פחות 1 מ 10?

364
00:17:39,290 --> 00:17:39,930
כמובן.

365
00:17:39,930 --> 00:17:41,030
אז עושה את זה שוב.

366
00:17:41,030 --> 00:17:43,580
אז זה מרווחים + + ל 2.

367
00:17:43,580 --> 00:17:44,610
האם 2 פחות מ 10?

368
00:17:44,610 --> 00:17:45,230
כן.

369
00:17:45,230 --> 00:17:46,670
ושוב ושוב ושוב.

370
00:17:46,670 --> 00:17:50,070
וסופו של דבר, בגלל
בתוספת-plussing, אנחנו מקבלים אני שווה 10.

371
00:17:50,070 --> 00:17:51,675
האם 10 פחות מ 10?

372
00:17:51,675 --> 00:17:52,990
ובכן, ברור שלא.

373
00:17:52,990 --> 00:17:55,320
וזה הנקודה שבה
ללולאה פשוט מפסיק.

374
00:17:55,320 --> 00:17:58,320
ואם יש לך יותר על קוד
מסך למטה, המחשב

375
00:17:58,320 --> 00:18:01,620
תמורה להפעיל קוד שבמקום.

376
00:18:01,620 --> 00:18:05,380
>> אז שוב, למרות שזה הולך
נראה ומרגיש קצת מוזר ב

377
00:18:05,380 --> 00:18:07,830
ראשון, ובוודאי לאלו מכם ש
אף פעם לא תכנתתי לפני, זה

378
00:18:07,830 --> 00:18:11,640
פשוטו כמשמעו, מפחית מושגית
למה שאחרת מאוד

379
00:18:11,640 --> 00:18:14,330
חידה פשוטה
חתיכה בלגרד.

380
00:18:14,330 --> 00:18:19,130
>> בסדר, הבטחתי שיש הייתי
להיות אנלוגים אחרים בלגרד.

381
00:18:19,130 --> 00:18:20,060
אין זה אחד יותר מדי.

382
00:18:20,060 --> 00:18:21,700
וראינו בפעם האחרונה לזמן קצר זה.

383
00:18:21,700 --> 00:18:23,530
אבל תזכור לנצח
לחסום בסריטות?

384
00:18:23,530 --> 00:18:25,490
זה פשוט עושה משהו לנצח?

385
00:18:25,490 --> 00:18:27,470
אני טענו שאתה יכול ליישם
זה בדרך זו.

386
00:18:27,470 --> 00:18:29,740
ולמעשה אתה יכול ליישם את זה
בכמה דרכים שונות.

387
00:18:29,740 --> 00:18:34,260
>> אבל את הלולאה בזמן היא פשוט שונה
הדרך ב-C של לבטא את עצמך.

388
00:18:34,260 --> 00:18:37,080
בסופו של היום, אתה לא יכול לעשות
כל דבר עם לולאה בזמן שאתה

389
00:18:37,080 --> 00:18:38,360
לא יכול עם ללולאה.

390
00:18:38,360 --> 00:18:41,430
ולכן הם בסופו של
יום פונקציונלי זהה.

391
00:18:41,430 --> 00:18:43,840
אבל זה מאפשר לך להביע את עצמך
קצת אחר ב

392
00:18:43,840 --> 00:18:44,850
הדרך הבאה.

393
00:18:44,850 --> 00:18:49,720
>> עם הלולאה בזמן, זה מה שיש ב
סוגריים שבדקו שוב ו

394
00:18:49,720 --> 00:18:51,050
שוב ושוב.

395
00:18:51,050 --> 00:18:55,100
וברגע שביטוי זה הוא שקר,
לאחר מכן הלולאה מפסיקה ביצוע,

396
00:18:55,100 --> 00:18:57,890
והמחשב ממשיך
לרוץ כל קוד האחר

397
00:18:57,890 --> 00:18:59,230
יש בקובץ שלך.

398
00:18:59,230 --> 00:19:02,180
>> אבל מה שמעניין הוא כאן
כי אני ממש הקלדה נכונה.

399
00:19:02,180 --> 00:19:06,680
ואמת היא סוג של הערך בוליאני,
ערך אמת או שקר.

400
00:19:06,680 --> 00:19:09,750
כל כך נכון יכול אי פעם להיות
שקר, אם יש לי, פשוטו כמשמעו,

401
00:19:09,750 --> 00:19:11,970
בקידוד הקשיח אותו בתוכנית שלי?

402
00:19:11,970 --> 00:19:12,470
אז לא.

403
00:19:12,470 --> 00:19:13,730
זה קצת מוזר שעשיתי את זה.

404
00:19:13,730 --> 00:19:15,190
אבל האמת היא אמת.

405
00:19:15,190 --> 00:19:16,320
אין שום תוספת-plussing.

406
00:19:16,320 --> 00:19:17,820
אין שימוש במשתנים בכאן.

407
00:19:17,820 --> 00:19:22,740
אז בגלל שאני בקידוד קשיח בזמן נכון, זה
לולאה היא תמיד הולכת להעריך

408
00:19:22,740 --> 00:19:24,090
שוב ושוב ושוב.

409
00:19:24,090 --> 00:19:27,660
>> אז כמה פעמים הוא שלום העולם
הולך להדפיס על המסך?

410
00:19:27,660 --> 00:19:28,170
לנצח.

411
00:19:28,170 --> 00:19:31,980
מספר אינסופי של פעמים עד
סוללה מת או חלק חיצוני אחר

412
00:19:31,980 --> 00:19:32,730
אירוע שקורה.

413
00:19:32,730 --> 00:19:35,880
אז זה כנראה לא את התכנית הטובה ביותר
לכתוב, כי אם המשתמש

414
00:19:35,880 --> 00:19:38,660
לא יכול להפסיק את התכנית שלך, זה
כנראה לא מה שהתכוונת.

415
00:19:38,660 --> 00:19:41,070
>> אבל לפעמים, תוכניות צריכות
יש לולאה אינסופית.

416
00:19:41,070 --> 00:19:44,050
לדוגמה, אם המחשב שלך יש
שעון על זה, זה בהחלט יהיה

417
00:19:44,050 --> 00:19:48,130
נחמד אם השעון שלך זה לשמור על העדכון
עצמו לנצח, אם כי פעם אחת

418
00:19:48,130 --> 00:19:50,500
שני או אחת לדקה או
משהו כזה.

419
00:19:50,500 --> 00:19:53,690
לולאות אינסופיות אז גם
האם יש המקום שלהם.

420
00:19:53,690 --> 00:19:54,360
>> בסדר.

421
00:19:54,360 --> 00:19:55,190
לבסוף, זה אחד.

422
00:19:55,190 --> 00:19:57,770
ואת זה הוא קצת שונה
תפקודי, ואנו נחזור אל

423
00:19:57,770 --> 00:19:59,460
זה כנראה ב1 Pset.

424
00:19:59,460 --> 00:20:02,370
אבל יש עוד סוג של לולאה
קרא לעשות בזמן שהלולאה.

425
00:20:02,370 --> 00:20:07,100
וההבדל היחיד בין כאן
לעשות בזמן לולאה ו, אומרת, לולאה בזמן,

426
00:20:07,100 --> 00:20:11,120
הוא שמצבו לא נבדק
לפני שאתה מבצע את הקוד, אבל אחרי

427
00:20:11,120 --> 00:20:12,080
שלך לבצע את הקוד.

428
00:20:12,080 --> 00:20:15,380
אז בראש ובאילו
לולאה, ואילו לעשות בזמן

429
00:20:15,380 --> 00:20:16,560
בודק אותו בתחתית.

430
00:20:16,560 --> 00:20:21,370
>> וזה רק אומר שהלולאה בזמן
יהיה בדרך כלל לבצע פעמים נוספות

431
00:20:21,370 --> 00:20:24,630
או פחות פעמים מאשר לולאה בזמן?

432
00:20:24,630 --> 00:20:30,810
פעמים עם פוטנציאל ליותר, כי לעשות
בעוד לולאה בבירור אומרת לעשות את זה,

433
00:20:30,810 --> 00:20:34,600
רק לאחר שיצביע לך לבדוק
אם בתוך מצבו של

434
00:20:34,600 --> 00:20:35,980
סוגריים הוא נכונים.

435
00:20:35,980 --> 00:20:37,940
>> אז אנחנו תראו את זה שוב
כנראה ב1 Pset.

436
00:20:37,940 --> 00:20:41,150
אם אי פעם אתה רוצה לעשות משהו ב
לפחות פעם אחת, ואז אולי קצת יותר

437
00:20:41,150 --> 00:20:43,350
פעמים, זה טוב
לבנות לשימוש.

438
00:20:43,350 --> 00:20:46,970
אבל לולאה בזמן, לעומת זאת, תהיה
לבדוק את המצב הראשון שלה.

439
00:20:46,970 --> 00:20:50,660
וזהו זה ללולאות ב-C, אין
בזמן, ואילו, וללולאות.

440
00:20:50,660 --> 00:20:54,700
ושוב, הם די יפה למפות בחזרה
לשריטה, מלבד זה לא עושה

441
00:20:54,700 --> 00:20:57,350
יש בדיוק אותו הדבר האנלוגי בלגרד.

442
00:20:57,350 --> 00:20:58,880
>> ובכן, מה לגבי, עכשיו, משתנה?

443
00:20:58,880 --> 00:21:02,600
אז ככה אני הכריז על משתנה
תחבירי יום האחר.

444
00:21:02,600 --> 00:21:06,440
היה לי int, שטענתי
הוא מספר שלם.

445
00:21:06,440 --> 00:21:09,690
אז היה לי נגד נקרא משתנה,
ולאחר מכן פסיק.

446
00:21:09,690 --> 00:21:11,070
אז מהו הקו הזה של הקוד עושה?

447
00:21:11,070 --> 00:21:14,540
זה, בפשטות, שהכריז
משתנה -

448
00:21:14,540 --> 00:21:17,940
כלומר, שואל את המחשב, תן לי
איזה זיכרון, תן לי כמה פיסות - ב

449
00:21:17,940 --> 00:21:19,450
שבו אני יכול לאחסן את מה?

450
00:21:19,450 --> 00:21:20,300
Int.

451
00:21:20,300 --> 00:21:23,570
והפסיק רק אומר
סוף שורת קוד.

452
00:21:23,570 --> 00:21:25,500
>> עכשיו, הקו השני הוא כנראה
די ניחוש.

453
00:21:25,500 --> 00:21:29,710
מהו נגדי = 0; עושה?

454
00:21:29,710 --> 00:21:31,690
זה הקצאת 0 נגד.

455
00:21:31,690 --> 00:21:33,470
ואז זה דבר האחר
זה קצת מעצבן

456
00:21:33,470 --> 00:21:34,540
לעומת, יניח, אלגברה.

457
00:21:34,540 --> 00:21:39,110
ואילו באלגברה, סימן שוויון פירושו
שווים, כאן ב-C, שווה

458
00:21:39,110 --> 00:21:40,470
סימן פירושו משימה.

459
00:21:40,470 --> 00:21:45,380
אז זה אומר לשים את מה בצד הימין
אל מה בצד השמאל.

460
00:21:45,380 --> 00:21:49,030
ואנו רואים סמל אחר, שווים
שווה, כאשר אנו רוצים לבדוק באמת

461
00:21:49,030 --> 00:21:50,570
לאיכות, קצת מעצבן.

462
00:21:50,570 --> 00:21:52,590
>> אבל זה קצת לא יעיל.

463
00:21:52,590 --> 00:21:55,090
זה סוג של מעצבן שיש לי
כדי להצהיר על משתנה ו

464
00:21:55,090 --> 00:21:56,110
לאחר מכן לתת לו ערך.

465
00:21:56,110 --> 00:21:59,380
כך למעשה מאפשר לנו C לפשט את זה
ופשוט לעשות את זה בבת אחת.

466
00:21:59,380 --> 00:22:01,330
אתה יכול להצהיר על המשתנה
בצד השמאל.

467
00:22:01,330 --> 00:22:04,590
אתה עדיין יכול לעשות את המשימה על
זכות על ידי הצבת שסימן שוויון ב

468
00:22:04,590 --> 00:22:05,030
האמצע.

469
00:22:05,030 --> 00:22:08,740
אז בסופו של היום, שני אלה הם
שווה, אבל זה, בכנות,

470
00:22:08,740 --> 00:22:11,840
כנראה את הרגל טובה יותר להיכנס
רק בגלל שזה קצת פחות

471
00:22:11,840 --> 00:22:15,040
קוד, שזה קצת יותר קל לקריאה,
וזה רק מחמיר את

472
00:22:15,040 --> 00:22:17,470
הקוד שלך, אם אפשר לומר כך.

473
00:22:17,470 --> 00:22:22,120
>> על כל שאלה עד כה על הלולאות,
על משתנים, על תנאים, על

474
00:22:22,120 --> 00:22:27,001
Booleans, בין אם מבחינה טכנית
או רעיוני?

475
00:22:27,001 --> 00:22:28,010
בסדר.

476
00:22:28,010 --> 00:22:30,690
אז עכשיו הבא זה מקבל
קצת יותר מעניין.

477
00:22:30,690 --> 00:22:34,790
וזו הדוגמא שהצבתי שעבר
זמן שרק ממפה דוגמא סריטות

478
00:22:34,790 --> 00:22:35,820
מעל לג

479
00:22:35,820 --> 00:22:36,580
>> אז פונקציה.

480
00:22:36,580 --> 00:22:38,110
במונחים של הדיוטות, מה זה פונקציה?

481
00:22:38,110 --> 00:22:42,900

482
00:22:42,900 --> 00:22:44,350
צריך להיות נועז יותר עם התשובה שלך.

483
00:22:44,350 --> 00:22:45,020
מה פונקציה?

484
00:22:45,020 --> 00:22:46,320
>> תלמיד: האם משהו.

485
00:22:46,320 --> 00:22:46,780
>> מלאן דוד: מה זה?

486
00:22:46,780 --> 00:22:48,000
>> תלמיד: האם משהו.

487
00:22:48,000 --> 00:22:48,710
>> דוד Malan: האם משהו.

488
00:22:48,710 --> 00:22:49,000
אישור.

489
00:22:49,000 --> 00:22:49,590
נתחיל שם.

490
00:22:49,590 --> 00:22:51,270
אז פונקציה עושה משהו.

491
00:22:51,270 --> 00:22:55,160
אז זה קטע קוד זה
למעשה מיושם במקומות אחרים, כי

492
00:22:55,160 --> 00:22:56,620
אכן עושה משהו.

493
00:22:56,620 --> 00:23:00,180
עכשיו, מה שמעניין בפונקציה
הוא שזה יכול לקחת קלט,

494
00:23:00,180 --> 00:23:02,710
וזה יכול לייצר תפוקה.

495
00:23:02,710 --> 00:23:05,090
ובוא באמת ניקח
תסתכל על זה.

496
00:23:05,090 --> 00:23:09,030
>> אז האיש מאחורי הווילון
היה מכוון לפני רגע.

497
00:23:09,030 --> 00:23:10,320
כאן יש לנו שולחן.

498
00:23:10,320 --> 00:23:13,010
אבל נניח שזה בעצם
מייצג תיבה גדולה.

499
00:23:13,010 --> 00:23:14,940
אז זה מה שנקרא קופסה שחורה.

500
00:23:14,940 --> 00:23:19,800
ובכלל, בעיצוב, במחשב
מדע, קופסות שחורות רק כדי להפנות

501
00:23:19,800 --> 00:23:22,510
פיסות פונקציונליות שמישהו
יישם, ואתה לא

502
00:23:22,510 --> 00:23:26,140
בהכרח יודעים או אכפת לי איך זה
יישם מתחת למכסת המנוע.

503
00:23:26,140 --> 00:23:28,960
אכפת לך רק שהקופסה שחורה הזאת,
שאנחנו עכשיו נתחיל לקרוא

504
00:23:28,960 --> 00:23:30,730
פונקציה, עושה משהו.

505
00:23:30,730 --> 00:23:34,710
>> כך, למשל, אם הקופסה השחורה הזה על
השלב כאן מייצג printf,

506
00:23:34,710 --> 00:23:38,040
פונקציה, אני יודע מדוגמאות קודמות
שלוקח printf אחד או יותר

507
00:23:38,040 --> 00:23:40,910
טיעונים, וראשון מאלה
טיעונים צריכים להיות מחרוזת, כמו

508
00:23:40,910 --> 00:23:44,780
"שלום, עולם". ובכן, אם אני האדם
כותב את התכנית, ואני רוצה

509
00:23:44,780 --> 00:23:50,460
להשתמש printf, אני, למשל, עלול
לקחת פיסת נייר ריק פה ו

510
00:23:50,460 --> 00:23:55,060
בטוש שחור ולכתוב עליו -

511
00:23:55,060 --> 00:23:56,580
אני שגוי "עולם" -

512
00:23:56,580 --> 00:23:59,560
H-E-L-L-O.

513
00:23:59,560 --> 00:24:04,220
>> אז אני אקח את הטוש השחור שלי ואני
לכתוב, גדול וכקריא שאני יכול על

514
00:24:04,220 --> 00:24:07,260
זה חתיכת נייר, "שלום, עולם", ו
עכשיו אני טוען שזה הטיעון שלי.

515
00:24:07,260 --> 00:24:09,740
זוהי מחרוזת מיוצגת עם
פיסת נייר לבן.

516
00:24:09,740 --> 00:24:13,030
והקלט שלי עכשיו לפונקציה
printf הולך להיות זה.

517
00:24:13,030 --> 00:24:18,250
אז אני קורא printf, עובר
טענה כי כקלט אליו.

518
00:24:18,250 --> 00:24:22,110

519
00:24:22,110 --> 00:24:26,740
>> ועכשיו, אני לא יודע איך האדם ש
printf כתב עשה את זה לפני שנים, אבל

520
00:24:26,740 --> 00:24:31,110
אני יודע שמהתיעוד שלה
מטרתו בחיים היא להדפיס את מה שאני

521
00:24:31,110 --> 00:24:34,410
לספק לו כקלט.

522
00:24:34,410 --> 00:24:40,630
וכך, למרות שיישום זה
הוא ללא ידיעתי

523
00:24:40,630 --> 00:24:44,170
מתחת למכסת המנוע, עכשיו
אני רואה, הו, זה נעשה.

524
00:24:44,170 --> 00:24:45,740
זה כבר הדפיס משהו
על המסך.

525
00:24:45,740 --> 00:24:49,070
ועכשיו לשלוט בתכנית, אם יש
היו יותר שורות קוד, הייתי

526
00:24:49,070 --> 00:24:51,070
עכשיו חזר אליי.

527
00:24:51,070 --> 00:24:52,290
וכן את העובדה שקולטון -

528
00:24:52,290 --> 00:24:55,370
יברך את לבו, הוא מסתתר כאן תחת
שולחן לפני כולכם -

529
00:24:55,370 --> 00:24:59,530
מכוון שבאיני יודע
ולא אכפת לי איך הוא printf

530
00:24:59,530 --> 00:25:00,100
יושם.

531
00:25:00,100 --> 00:25:03,390
אני רק יודע, שוב, משלה
תיעוד, מה היא עושה ואיך אני

532
00:25:03,390 --> 00:25:05,040
אני אמור להשתמש בו.

533
00:25:05,040 --> 00:25:09,140
>> עכשיו, זוכר שprintf יכול לקבל
קצת יותר מתוחכם.

534
00:25:09,140 --> 00:25:12,220
שוב, אנחנו מדברים רק על
מקבילה של הבלוק תגיד של סריטות.

535
00:25:12,220 --> 00:25:14,230
אבל אני גם עשיתי את זה בפעם האחרונה.

536
00:25:14,230 --> 00:25:17,270
אני רוצה להפוך את תכנית שלום שלי
קצת יותר דינמי ולא רק קשה

537
00:25:17,270 --> 00:25:19,740
קוד משהו כמו "עולם", ו
בהחלט לא משהו שקוד קשה

538
00:25:19,740 --> 00:25:22,520
שרירותי כמו D--V-I-D
לתכנית.

539
00:25:22,520 --> 00:25:27,510
רציתי לשאול את המשתמש שלו או שלה
שם, ואז לעשות משהו עם

540
00:25:27,510 --> 00:25:29,720
שהמחרוזת שהם מספקים.

541
00:25:29,720 --> 00:25:32,690
>> אז יש משהו קצת שונה
כאן. printf, לפני רגע,

542
00:25:32,690 --> 00:25:35,860
לא, באמת, לעשות משהו, אבל זה
לא החזיר לי כלום.

543
00:25:35,860 --> 00:25:36,020
נכון?

544
00:25:36,020 --> 00:25:38,910
קולטון לא מסר לי שום דבר
בחזרה, לא פיסת נייר.

545
00:25:38,910 --> 00:25:40,320
היה רק ​​תופעת לוואי.

546
00:25:40,320 --> 00:25:44,510
מתן שלי "שלום, העולם", כפי
טיעון להביא קולטון ב

547
00:25:44,510 --> 00:25:48,420
תופעת לוואי של מילה, כמה מילים,
המופיע על המסך.

548
00:25:48,420 --> 00:25:51,350
>> getstring, אם כי, הוא קצת
שונה. getstring גם

549
00:25:51,350 --> 00:25:54,590
פונקציה, אבל היא מחזירה ערך כלשהו.

550
00:25:54,590 --> 00:25:56,370
זה לא רק שיש לי
תופעת לוואי אסתטית.

551
00:25:56,370 --> 00:26:00,230
זה נותן לי בעצם, האדם
התקשרות או באמצעות הפונקציה,

552
00:26:00,230 --> 00:26:01,320
משהו בחזרה.

553
00:26:01,320 --> 00:26:05,740
אז במקרה הזה, הוא getstring
התקשרתי עם getstring הפתוח

554
00:26:05,740 --> 00:26:07,510
פארן, קרוב paren.

555
00:26:07,510 --> 00:26:11,370
האם getstring, אם כן, לקחת
כל טענות או קלט?

556
00:26:11,370 --> 00:26:12,340
לא, זה לא נראה.

557
00:26:12,340 --> 00:26:14,460
מטרתו בחיים היא
רק כדי לקבל את מחרוזת.

558
00:26:14,460 --> 00:26:16,910
זה לא צריך שום פירוט רב יותר מזה.

559
00:26:16,910 --> 00:26:20,430
אז הרשה לי להמשיך ולהעמיד פן ש,
שוב, קופסה שחורה זה לא printf,

560
00:26:20,430 --> 00:26:25,160
אבל getstring, ותן לי, האדם
כתיבת תכנית זו, להתקשר או להשתמש

561
00:26:25,160 --> 00:26:29,720
getstring רק על ידי כתיבה
G-E-T-S-T-R-I-N-G, פתוח פארן, קרוב

562
00:26:29,720 --> 00:26:32,170
פארן, getstring.

563
00:26:32,170 --> 00:26:36,920
>> עכשיו, אין לי מושג איך צוות CS50
יושם getstring, אבל אני יודע ש

564
00:26:36,920 --> 00:26:41,240
אם תחכה מספיק זמן, הוא יעשה את שלו
דבר מתחת למכסת המנוע, אולי באמצעות

565
00:26:41,240 --> 00:26:44,940
חלק מהמשתנים, אולי בעזרת כמה
תנאים, אולי בעזרת כמה לולאות,

566
00:26:44,940 --> 00:26:48,170
אולי בעזרת כמה פונקציות,
אולי באמצעות -

567
00:26:48,170 --> 00:26:52,290
רק מנסה דוכן - אולי באמצעות
כמה תכונות תכנות אחרות.

568
00:26:52,290 --> 00:26:55,350
אבל אם אני אחכה מספיק זמן - במציאות,
במחשב, זה קורה

569
00:26:55,350 --> 00:26:56,270
סופר מהיר -

570
00:26:56,270 --> 00:26:59,910
אם אחכה מספיק זמן, פונקציה זו
getstring הוא הולך לקבל מחרוזת

571
00:26:59,910 --> 00:27:04,060
מהמשתמש, שהוא ככל הנראה להקליד
את זה על המקלדת שלהם, ו

572
00:27:04,060 --> 00:27:08,090
לאחר מכן, כשאתה מקבל getstring נעשה
אותם תווים מהמשתמש

573
00:27:08,090 --> 00:27:14,080
ואחסונם למחרוזת, כי
פונקציה, getstring, הוא הולכת להיות

574
00:27:14,080 --> 00:27:17,990
מוכן בשבילי כמה פלט שבו אני
הולך לאחזור בדרך של

575
00:27:17,990 --> 00:27:19,470
אופרטור ההשמה.

576
00:27:19,470 --> 00:27:25,390
>> ואם אני הולך, אכן, לפלט
כאן, יש לו בנדיבות Obosi

577
00:27:25,390 --> 00:27:29,900
השתתף, בלי לדעת את זה ב
לקדם, על ידי כתיבת השם שלו על זה

578
00:27:29,900 --> 00:27:33,100
משתנה, אשר מייצג
מחרוזת.

579
00:27:33,100 --> 00:27:35,640
עכשיו, מפעיל המשימה אומר, גם
אם כי זה עלול להרגיש קצת

580
00:27:35,640 --> 00:27:38,790
מיותר, אני באמת צריכה לעשות
כדי להפוך את העותק זה שלי.

581
00:27:38,790 --> 00:27:40,700
כי ביד השמאל
צד - אופס! -

582
00:27:40,700 --> 00:27:45,760
שם לב שיש לי בעצם מחרוזת
שם בצד השמאל.

583
00:27:45,760 --> 00:27:48,280
אז אני גם הולך לעשות
עותק משלי לכך.

584
00:27:48,280 --> 00:27:50,990
וזה קצת שקר לבן,
בגלל שנראה בשבוע או שניים של

585
00:27:50,990 --> 00:27:54,100
זמן שמייתרים הם לא ממש
מה שהם נראים.

586
00:27:54,100 --> 00:27:56,700
>> אבל לעת עתה, הנה ערך ההחזרה.

587
00:27:56,700 --> 00:28:00,160
הנה העותק שלו שלי אחרי
באמצעות אופרטור ההשמה.

588
00:28:00,160 --> 00:28:01,790
ועכשיו, מה אני רוצה לעשות עכשיו?

589
00:28:01,790 --> 00:28:04,080
עכשיו יש לנו את השנייה
משתי שורות של קוד.

590
00:28:04,080 --> 00:28:05,640
אז עכשיו אני רוצה לקרוא לprintf.

591
00:28:05,640 --> 00:28:08,500
בואו נעמיד פנים שעכשיו שחור
תיבה היא חזרה שוב להיות

592
00:28:08,500 --> 00:28:10,210
printf ולא getstring.

593
00:28:10,210 --> 00:28:12,200
>> Printf זמן זה הולך
לקחת כמה ויכוחים?

594
00:28:12,200 --> 00:28:14,890

595
00:28:14,890 --> 00:28:16,770
אז תראה, זה כמו שתיים.

596
00:28:16,770 --> 00:28:18,860
יש שני פסיקים בשם, אבל
אחד מאותם פסיקים, זה

597
00:28:18,860 --> 00:28:20,220
בתוך המרכאות.

598
00:28:20,220 --> 00:28:23,190
אז הטענה הראשונה היא, פשוטו כמשמעו,
זה הולך להיות.

599
00:28:23,190 --> 00:28:31,850
H-E-L-L-O, פסיק, באחוזים
ים, קו נטוי-n.

600
00:28:31,850 --> 00:28:36,560
ועכשיו אני מתן לא טיעון אחד,
אבל שני טיעונים לprintf.

601
00:28:36,560 --> 00:28:39,530
>> ומה printf אמור לעשות עם
שתי הכניסות האלה אחרי שאני עובר אותם ב

602
00:28:39,530 --> 00:28:42,050
כטיעונים?

603
00:28:42,050 --> 00:28:45,360
זה אמור לקחת שני של
שלהם, שקראתי בהשם, ולכן

604
00:28:45,360 --> 00:28:48,660
קטע שני של נייר שכתבתי את
לפני רגע הוא קרא בשם.

605
00:28:48,660 --> 00:28:53,550
זה הולך התוספת של הערך בתוך
של משתנה שלתוך מציין המיקום,

606
00:28:53,550 --> 00:28:58,310
% S, כך ששוב, ברגע של
זמן, אנו רואים תופעת לוואי של

607
00:28:58,310 --> 00:29:04,180
לאחר שקראנו printf, לפיה עכשיו אנחנו
לא רואה את "שלום, עולם", אבל "שלום,

608
00:29:04,180 --> 00:29:04,710
Obosi ".

609
00:29:04,710 --> 00:29:08,730
>> אז מחיאות כפיים לשניהם
המתנדבים שלנו, רק שאחד מהם ידעו

610
00:29:08,730 --> 00:29:12,010
זה לא היה קורה.

611
00:29:12,010 --> 00:29:12,990
בסדר.

612
00:29:12,990 --> 00:29:16,480
אז, אולי, פשוט כמו שהיה,
בהחלט, אם אתה כבר מכיר

613
00:29:16,480 --> 00:29:20,190
עם כזה, אני מקווה שאתה לעולם לא
לשכוח כי חזותי מסוים של איך

614
00:29:20,190 --> 00:29:21,220
פונקציות יעבדו.

615
00:29:21,220 --> 00:29:23,000
>> אז יש יותר מאשר רק getstring.

616
00:29:23,000 --> 00:29:26,020
בתוך ספריית CS50, יש
חבורה שלמה של פונקציות, אשר כולם

617
00:29:26,020 --> 00:29:29,510
מהוונים רק כדי להבהיר
שכתבנו את הפונקציות האלה.

618
00:29:29,510 --> 00:29:33,610
בדרך כלל, ב-C, כמעט בכל השני
פונקציה שתשמש אותך היא אותיות קטנות.

619
00:29:33,610 --> 00:29:36,190
אבל אנחנו בכוונה להשתמש באותיות גדולות
רק כדי להבהיר, כי אלה

620
00:29:36,190 --> 00:29:39,880
הם גלגלים עזר מסוגים כי תוכל
להשתמש רק כמה שבועות כי

621
00:29:39,880 --> 00:29:42,890
לפשט את התהליך של קבלה
קלט מהמשתמש.

622
00:29:42,890 --> 00:29:46,740
>> ספריית CS50 לא עושה שום דבר
שאתם עצמכם לא היו יכולים לעשות על ידי

623
00:29:46,740 --> 00:29:50,230
רק באמצעות קוד C מ
ספר לימוד אולדסקול.

624
00:29:50,230 --> 00:29:53,310
אבל, שוב, אנחנו משתמשים בם כאימונים
גלגלים של מיני עבור רק כמה

625
00:29:53,310 --> 00:29:57,250
שבועות, כך שנוכל להיפטר מ
מורכבות שבקרוב תוכל להבין

626
00:29:57,250 --> 00:30:00,460
את עצמך לעשות משהו כמו
יחסית פשוט כמו לקבל

627
00:30:00,460 --> 00:30:02,080
קלט ממשתמש.

628
00:30:02,080 --> 00:30:05,540
>> אז תדע שיהיה לך גישה
לgetchar, GetDouble -

629
00:30:05,540 --> 00:30:06,050
כפול.

630
00:30:06,050 --> 00:30:07,050
ממה - ולאחר מכן GetFloat.

631
00:30:07,050 --> 00:30:07,600
מה מצוף?

632
00:30:07,600 --> 00:30:09,382
בואו נתחיל שם.

633
00:30:09,382 --> 00:30:10,600
>> תלמיד: [לא ברור].

634
00:30:10,600 --> 00:30:10,790
>> דוד Malan: כן.

635
00:30:10,790 --> 00:30:12,120
זה מספר עם נקודה עשרונית.

636
00:30:12,120 --> 00:30:15,930
אז אילו int הוא מספר שלם, אשר
הוא רק מספר עם 0 עד 9,

637
00:30:15,930 --> 00:30:18,940
איזה מספר החזרות ממנו,
מצוף הוא משהו

638
00:30:18,940 --> 00:30:20,100
עם נקודה עשרונית.

639
00:30:20,100 --> 00:30:26,090
וכפול, בינתיים, הוא גם
מספר עם נקודה עשרונית, אבל יותר

640
00:30:26,090 --> 00:30:28,160
מספרים לאחר הנקודה העשרונית
נקודה, שעלול להיות.

641
00:30:28,160 --> 00:30:30,040
>> אז אנחנו נחזור לזה עוד הרבה לפני.

642
00:30:30,040 --> 00:30:34,560
אבל בדרך כלל, כל אחד מסוגים אלה
הנתונים, כל אחד מסוגים של משתנים אלו

643
00:30:34,560 --> 00:30:39,380
שספרייה כמו שלנו יכולה לחזור ל
לך, להשתמש במספרים שונים של ביטים ל

644
00:30:39,380 --> 00:30:40,290
אחסון מידע.

645
00:30:40,290 --> 00:30:43,910
בדרך כלל, תו, שרק אומר
תו אחד, משתמש 8 סיביות.

646
00:30:43,910 --> 00:30:47,490
וזה בעצם עולה בקנה אחד עם שלנו
בתים של מתנדבים בשבוע שעבר ש

647
00:30:47,490 --> 00:30:50,410
עלה וייצג את אחד
תווי ASCII בכל פעם.

648
00:30:50,410 --> 00:30:51,850
אז תו הוא 8 סיביות.

649
00:30:51,850 --> 00:30:54,430
>> לצוף במקרה
32 סיביות, בדרך כלל.

650
00:30:54,430 --> 00:30:59,230
וכפול, כמו שאתם יכולים לנחש, הוא
למעשה 64 סיביות, שהוא פשוט יותר,

651
00:30:59,230 --> 00:31:01,360
מה שאומר שאתה יכול להיות גדול יותר
מספרים או יותר דיוק.

652
00:31:01,360 --> 00:31:03,000
אבל שוב, עוד על כך בפעם אחרת.

653
00:31:03,000 --> 00:31:06,550
GetLongLong, בינתיים, אם כי בטיפשות
בשם, הוא באמת רק

654
00:31:06,550 --> 00:31:10,770
מספר שלם שהוא גדול פי שניים, פי שתיים
ארוך, באופן פוטנציאלי, כפי שקבוע

655
00:31:10,770 --> 00:31:12,940
מספר שלם, 64 סיביות במקום 32.

656
00:31:12,940 --> 00:31:14,560
וGetString אנחנו כבר משתמשים.

657
00:31:14,560 --> 00:31:18,870
>> אבל מתברר, בספריית CS50,
אשר מיושם, כפי שנראה, ב

658
00:31:18,870 --> 00:31:23,560
הצורה של שני הקבצים, שהאחד מהם
נקרא cs50.h, יש שתיים אחרים

659
00:31:23,560 --> 00:31:24,770
סוגי נתונים.

660
00:31:24,770 --> 00:31:29,700
Booleans לא קיים בC. אתה יכול
לדמות אותם רק על ידי שימוש 0s ו 1s

661
00:31:29,700 --> 00:31:30,850
לאורך כל התוכניות שלך.

662
00:31:30,850 --> 00:31:35,500
אבל אנחנו בספריית CS50 יצרנו
הסמלים "אמיתיים" ו "שקר"

663
00:31:35,500 --> 00:31:38,580
לייצג ו1 0 כדי שלא
יש למשהו קוד קשה

664
00:31:38,580 --> 00:31:39,810
ממש כמו 1 ו -0.

665
00:31:39,810 --> 00:31:40,980
אבל אנחנו תראו אותם שוב.

666
00:31:40,980 --> 00:31:42,330
>> המיתרים, גם לא קיים.

667
00:31:42,330 --> 00:31:44,520
וזה למה שהזכרתי זה
קצת שקר לבן לעת עתה.

668
00:31:44,520 --> 00:31:46,660
אבל נצטרך לקלף כי
שכבה לפני זמן רב.

669
00:31:46,660 --> 00:31:49,540
אבל לעת עתה, היא מחרוזת
רצף של תווים.

670
00:31:49,540 --> 00:31:51,790
>> בינתיים, ב-C, אתה אכן
יש סוגי נתונים שונים.

671
00:31:51,790 --> 00:31:53,200
שים לב אלה הם אותיות קטנות.

672
00:31:53,200 --> 00:31:56,960
אז את הפונקציות שראית לפני רגע
הם פונקציות שנכתבו על ידי CS50

673
00:31:56,960 --> 00:32:02,310
אחזור אליך ערך שנופל
לאחת מהקטגוריות הללו.

674
00:32:02,310 --> 00:32:06,730
>> כמה רמות גיליונות רק כדי לשתול
הזרע כאן. printf לא פשוט

675
00:32:06,730 --> 00:32:08,600
לקחת% s כמצייני מיקום.

676
00:32:08,600 --> 00:32:13,490
זה לוקח% d עבור מספרים שלמים עשרוניים,
או% אני עובד גם כן.

677
00:32:13,490 --> 00:32:19,450
% F הוא צף ערכי נקודה. % ג הוא עבור
char, אם אתה רוצה רק כדי לחבר אחד

678
00:32:19,450 --> 00:32:23,510
תו למחרוזת מעוצבת מראש
כמו שאנחנו כבר עושים, אתה יכול להשתמש% ג.

679
00:32:23,510 --> 00:32:28,490
>> ואז, קצת מעצבן, LLD% הוא
למספר עשרוני שלם רב, רב מאוד,

680
00:32:28,490 --> 00:32:31,050
רק אומר שאם אתה צריך באמת
מספר גדול ואתה משתמש במשהו

681
00:32:31,050 --> 00:32:35,450
שם ארוך ארוך, שאנחנו נבוא
בחזרה בpset, אתה יכול להשתמש ל% LLD

682
00:32:35,450 --> 00:32:40,700
תגיד printf, תקע גדול באמת
מספר שלם בדרך שלו שני או

683
00:32:40,700 --> 00:32:41,830
איזה ויכוח אחר.

684
00:32:41,830 --> 00:32:45,700
>> ולבסוף, הבטחתי כי
יש כמה בריחה אחרת

685
00:32:45,700 --> 00:32:47,670
רצפים שprintf תומך בם.

686
00:32:47,670 --> 00:32:49,160
ראינו את הקו הנטוי-n.

687
00:32:49,160 --> 00:32:50,510
לוכסן-R אתה יכול לראות.

688
00:32:50,510 --> 00:32:51,780
זה סוג של דבר מאסכולה ישנה.

689
00:32:51,780 --> 00:32:55,920
אם אי פעם השתמשו במכונת כתיבה אמיתית שנים
לפני ואתה משך על הארכובה

690
00:32:55,920 --> 00:32:59,810
אשר לא רק מסובב את הגלגל כדי
להזיז את ההרכב, הוא גם עבר

691
00:32:59,810 --> 00:33:03,730
כל העניין כל הדרך חזרה אל
מהשמאל, ובכן, קו נטוי-R פשוט

692
00:33:03,730 --> 00:33:06,480
בעצם מעביר את הסמן אחורי
לתחילתו של הקו

693
00:33:06,480 --> 00:33:07,830
בלי להזיז אותו.

694
00:33:07,830 --> 00:33:09,780
אבל שוב, נוסף על כך,
אולי, בעתיד.

695
00:33:09,780 --> 00:33:13,670
>> לוכסן-ציטוט, קו נטוי הפוך כפול,
קו נטוי קו נטוי, הוא

696
00:33:13,670 --> 00:33:16,600
פתרון לחידה קטנטנה
אני רמזתי קודם לכן.

697
00:33:16,600 --> 00:33:18,920
וקו הנטוי-0 היא למעשה
די מעניין.

698
00:33:18,920 --> 00:33:21,470
אבל אנחנו נחזור אל
כי לפני זמן רב.

699
00:33:21,470 --> 00:33:25,640
>> אז תן לי להיכנס, עכשיו, CS50
מכשיר, ובואו בעצם עושים

700
00:33:25,640 --> 00:33:28,930
מהיר להתחמם עם אחת דוגמאות
אנחנו כבר ואז לעבור ל

701
00:33:28,930 --> 00:33:31,160
משהו קצת יותר מורכב.

702
00:33:31,160 --> 00:33:34,980
אז אם אני פותח את התכנית שלי
נקרא gedit -

703
00:33:34,980 --> 00:33:36,840
זו היא העורך הגרפי שלי.

704
00:33:36,840 --> 00:33:38,460
ואני יכול לעשות את זה -

705
00:33:38,460 --> 00:33:39,820
תנו לי לסגור את החלון שיש -

706
00:33:39,820 --> 00:33:42,720
בדרך של סמל זה כאן למטה,
gedit, בחלק התחתון השמאלי

707
00:33:42,720 --> 00:33:44,170
פינה הבאה לתפריט.

708
00:33:44,170 --> 00:33:48,670
>> אני הולך להמשיך ולהתקדם, ו
להציל את הדוגמא הזאת ל, תניח, ג'ון

709
00:33:48,670 --> 00:33:49,660
התיקייה של אוניברסיטת הרווארד.

710
00:33:49,660 --> 00:33:52,690
התיקייה של ג'ון הרווארד היא רק ביתו
ספרייה שבה כל הקבצים שלו לחיות

711
00:33:52,690 --> 00:33:53,340
כברירת מחדל.

712
00:33:53,340 --> 00:33:58,410
ואני הולך לשמור את זה כ
קובץ בשם hello-0.c.

713
00:33:58,410 --> 00:34:01,260
ואני בחרתי את השם הזה רק כדי שאותו
שורות עם הקוד לדוגמא על

714
00:34:01,260 --> 00:34:04,210
האתר של וכמובן ב
קטעי וידאו באינטרנט.

715
00:34:04,210 --> 00:34:06,320
>> אז עכשיו אני הולך להתחיל
לכתוב את התכנית הראשונה שלי.

716
00:34:06,320 --> 00:34:08,469
תן לי להתקרב לקריאות.

717
00:34:08,469 --> 00:34:12,760
ואני הולך קדימה, ואומר int
החלל ראשי, שהוא בדיוק כמו ש

718
00:34:12,760 --> 00:34:14,900
פיסת הפאזל צהובה ש
מתחיל תכנית.

719
00:34:14,900 --> 00:34:18,290
אני מקבל את הרגל מעל
שנים של פתיחת הסד המתולתל שלי, ולאחר מכן

720
00:34:18,290 --> 00:34:22,000
גם לסגור אותו ולאחר מכן חוזר ל
שבו אני רוצה לשים את הקוד שלי, רק

721
00:34:22,000 --> 00:34:24,630
כי זה עוזר לי לשמור על הכל
מאוזן, במיוחד כ

722
00:34:24,630 --> 00:34:25,880
התכנית מקבלת ארוכה.

723
00:34:25,880 --> 00:34:29,239
>> ועכשיו, כאן, אני הולך קדימה
ואומרים, printf, מירכאות,

724
00:34:29,239 --> 00:34:34,330
שלום עולם, קו נטוי-n, קרוב ציטוט,
סוגריים קרובים, פסיק.

725
00:34:34,330 --> 00:34:38,100
אז אני פשוט חוזר על כל מה שיש לנו
כבר לוקח כמובן מאליו עד כה.

726
00:34:38,100 --> 00:34:39,270
עכשיו אני הולך להקטין את התצוגה.

727
00:34:39,270 --> 00:34:43,030
>> וחלון המסוף הזה כאן למטה, מה
האם מותר לי לעשות את זה בשחור

728
00:34:43,030 --> 00:34:44,389
ולבן חלון?

729
00:34:44,389 --> 00:34:46,977
מה אני יכול להשתמש בו ל?

730
00:34:46,977 --> 00:34:49,770
אז זה מקום שבו אני מפעיל את הפקודות ו
שבו אני יכול לאסוף את הדברים.

731
00:34:49,770 --> 00:34:50,620
ואני הולך לשמור את זה פשוט.

732
00:34:50,620 --> 00:34:52,780
אני הולך להשתמש בתכנית
קראתי הפוך, שאינו

733
00:34:52,780 --> 00:34:54,020
מבחינה טכנית מהדר.

734
00:34:54,020 --> 00:34:56,360
קלאנג בשמו של המהדר, אבל
אנחנו נחזור לזה ב

735
00:34:56,360 --> 00:34:57,190
שבוע או שתיים של זמן.

736
00:34:57,190 --> 00:35:03,410
>> לעת עתה, אני רק הולך להקליד לעשות
שלום-0, אבל אלו מכם שהיו

737
00:35:03,410 --> 00:35:07,050
השוואה במוחך את מה שאני רק
הקליד למה שהייתי צריך להיות מוקלדות רשאי

738
00:35:07,050 --> 00:35:10,180
כבר יודע שאני עשיתי
משהו כאן לא בסדר.

739
00:35:10,180 --> 00:35:12,160
עכשיו, יש באופן ברור כמה טעויות.

740
00:35:12,160 --> 00:35:16,742
לפני שאני אפילו מסתכל על מה שהם, בכל
מחשבות על מה שעשיתי לא בסדר?

741
00:35:16,742 --> 00:35:18,590
>> תלמידים: [חציצת קולות].

742
00:35:18,590 --> 00:35:18,840
>> דוד Malan: כן.

743
00:35:18,840 --> 00:35:20,640
חסר לי קובץ הכותרת של הספרייה.

744
00:35:20,640 --> 00:35:24,240
כל אחד מהקבצים. H אלה נקראים כותרת
קבצים, והם ביחד

745
00:35:24,240 --> 00:35:25,680
שייכים לדברים בשם ספריות.

746
00:35:25,680 --> 00:35:28,030
ספריות הן רק גושים של קוד
שאנשים אחרים כתבו.

747
00:35:28,030 --> 00:35:32,140
אז [הסטנדרטי? אני?] ספרייה היא
אוסף של קבצים המכילים קוד

748
00:35:32,140 --> 00:35:33,330
שאנשים אחרים כתבו.

749
00:35:33,330 --> 00:35:34,820
>> אז אני מפספס את זה.

750
00:35:34,820 --> 00:35:36,520
אז למה אני מקבל הודעת שגיאה?

751
00:35:36,520 --> 00:35:40,840
ובכן, הרשה לי לגלול לגבות ב
חלון המסוף שלי כאן.

752
00:35:40,840 --> 00:35:44,310
ולרוע מזל, ב-C, כמו בהרבה
שפות תכנות, בעיקר

753
00:35:44,310 --> 00:35:47,830
אם כל זה חדש לך, השגיאה
הודעות הן מדויקות, אבל הם גם

754
00:35:47,830 --> 00:35:48,620
די סתום.

755
00:35:48,620 --> 00:35:51,720
והשגיאה כאן, באדום, היא
"פונקצית ספרייה במרומז הכרזה

756
00:35:51,720 --> 00:35:57,660
printf סוג עם ", ואז זה מגילות
לשורה הבאה, "int const char *,

757
00:35:57,660 --> 00:36:00,220
... "זה פשוט מקבל באמת
מכריע במהירות.

758
00:36:00,220 --> 00:36:04,420
>> אבל מה שאתה צריך להתחיל לעשות, אם,
שוב, חדש לכל זה, הוא רק כדי

759
00:36:04,420 --> 00:36:06,010
מתחיל לחפש מילות מפתח.

760
00:36:06,010 --> 00:36:08,770
באופן ברור, אני לא יכול להבין מחצית
מהמילים שאני רואה כרגע.

761
00:36:08,770 --> 00:36:10,140
אתה, לעומת זאת, בפרק הזמן של שבוע.

762
00:36:10,140 --> 00:36:11,230
אבל אני רואה printf.

763
00:36:11,230 --> 00:36:14,310
וזה צריך להתחיל, לפני זמן רב, כדי
לרענן את זכרונך, בסדר, printf.

764
00:36:14,310 --> 00:36:15,210
משהו לא בסדר עם printf.

765
00:36:15,210 --> 00:36:16,580
האם אני מאיית את זה לא נכון?

766
00:36:16,580 --> 00:36:18,130
לא, זה לא נראה כמו - הו.

767
00:36:18,130 --> 00:36:21,350
אני לא יכול להשתמש בו, אלא אם כן אני מלמד
המהדר שהוא קיים.

768
00:36:21,350 --> 00:36:25,220
וכך, שוב, ללכת עם האינסטינקטים שלך,
גם אם אתה לא ממש מבין

769
00:36:25,220 --> 00:36:26,510
הודעות השגיאה בפועל.

770
00:36:26,510 --> 00:36:30,240
>> ואכן, הפתרון כאן הוא פשוט
לכלול אותו בחלק העליון של הקובץ

771
00:36:30,240 --> 00:36:34,340
ככה, resaving את התיק שלי עם
שליטה-S או בתפריט הקובץ.

772
00:36:34,340 --> 00:36:36,730
ואם עכשיו אני חוזר לכאן,
אני הולך לנקות את זה.

773
00:36:36,730 --> 00:36:39,150
שליטה L הוא פשוט דרך נחמדה
כדי לנקות את המסך.

774
00:36:39,150 --> 00:36:44,870
ולאחר מכן אני הולך להקליד "לעשות שלום
0 "Enter, ועכשיו אני עדיין רואה

775
00:36:44,870 --> 00:36:47,710
רצף מסתורי של סמלים, אבל
אנחנו נחזור לזה.

776
00:36:47,710 --> 00:36:49,230
זה מה שהוא עושה יעשה בשבילך.

777
00:36:49,230 --> 00:36:52,590
זה מיכון התהליך של לקיחה
הפקודה די מעצבן מעורבת

778
00:36:52,590 --> 00:36:54,050
קלאנג, המהדר בפועל.

779
00:36:54,050 --> 00:36:57,460
אבל העובדה שיש לי אין שגיאות אומרת
כי דבר זה אמור לעבוד.

780
00:36:57,460 --> 00:37:00,630
>> אז אני עכשיו הולך לעשות -
תנו לי להתקרב שוב -

781
00:37:00,630 --> 00:37:07,070
./hello-0 הזן, ואכן, אני רואה
"שלום, עולם". אז בואו עכשיו לשפר

782
00:37:07,070 --> 00:37:12,105
זה אי פעם כל כך מעט, רק כדי לשכפל
הצעדים שנועדנו.

783
00:37:12,105 --> 00:37:15,370
אני הולך לשנות את השם הזה עם
שמירה בשם לhello1.c.

784
00:37:15,370 --> 00:37:20,300
ועכשיו אני הולך להכריז על משתנה
קרא בהשם, ולכן שם מחרוזת

785
00:37:20,300 --> 00:37:23,420
ואני הולך לשים את זה
ערך של מרכאות

786
00:37:23,420 --> 00:37:27,030
D--V-I-D-ציטוט פסיק קרוב.

787
00:37:27,030 --> 00:37:31,150
ועכשיו אני הולך להחליף את "העולם"
עם מה שמציין מיקום עבור מחרוזת?

788
00:37:31,150 --> 00:37:32,200
% S.

789
00:37:32,200 --> 00:37:35,040
>> ועכשיו, כמה טיעונים צריכים
printf לקחת את הזמן הזה?

790
00:37:35,040 --> 00:37:35,700
אז שתיים.

791
00:37:35,700 --> 00:37:37,090
אז אני יוצא החוצה מהציטוטים.

792
00:37:37,090 --> 00:37:39,330
אני מקליד "שם" אחרי פסיק.

793
00:37:39,330 --> 00:37:41,550
אבל אני כבר עשיתי משהו
בעיה אחרת הפעם.

794
00:37:41,550 --> 00:37:43,940
אבל בואו נניח שאין לי
מבין את זה עדיין.

795
00:37:43,940 --> 00:37:44,910
עזוב אותי כאן.

796
00:37:44,910 --> 00:37:48,850
>> ושים לב, יותר מדי, אני מקבל קצת
משועמם של הקלדה "לעשות שלום 0" כל

797
00:37:48,850 --> 00:37:50,180
זמן, "לעשות" וכל זה.

798
00:37:50,180 --> 00:37:53,270
אז, כך מתברר, בינוס שאתה יכול
לעתים קרובות פגע בחץ למעלה עליך

799
00:37:53,270 --> 00:37:56,850
מקלדת, ולמעשה אתה יכול לגלול
דרך כל הפקודות שאני כבר

800
00:37:56,850 --> 00:37:58,830
להורג קודם לעכשיו.

801
00:37:58,830 --> 00:38:02,040
אז אם אני עושה את זה, למעלה, למעלה,
יש לעשות שלום 0.

802
00:38:02,040 --> 00:38:02,610
אני לא רוצה את זה.

803
00:38:02,610 --> 00:38:05,450
אני רק רוצה לשנות את זה כדי
שלום 1 הפעם, Enter.

804
00:38:05,450 --> 00:38:07,620
סופו של דבר, שיהיה
לחסוך לך קצת זמן.

805
00:38:07,620 --> 00:38:08,150
>> בסדר.

806
00:38:08,150 --> 00:38:09,520
למרבה הצער, אין הוא שגיאה.

807
00:38:09,520 --> 00:38:10,980
אז בואו לגלול אותי.

808
00:38:10,980 --> 00:38:13,120
זה נראה כמו שאני באמת
שחט תכנית זו.

809
00:38:13,120 --> 00:38:16,530
אני מתכוון, אלוהים שלי, זה שתי שורות של קוד,
ו 10 שורות של שגיאות.

810
00:38:16,530 --> 00:38:18,800
אבל תסתכל על אחד העליון ראשון.

811
00:38:18,800 --> 00:38:21,640
שימוש במחרוזת מזהה לא מוצהרת.

812
00:38:21,640 --> 00:38:23,270
האם אני מתכוון סטנדרטי אני n?

813
00:38:23,270 --> 00:38:23,930
לא, אני לא.

814
00:38:23,930 --> 00:38:24,940
התכוונתי למחרוזת.

815
00:38:24,940 --> 00:38:29,390
>> אבל איפה הוא משתנה המחרוזת
סוג הכריז, DD אנחנו אומרים?

816
00:38:29,390 --> 00:38:30,730
אז זה בCS50 הספרייה.

817
00:38:30,730 --> 00:38:33,740
כך שזה לא יספיק, באלה ראשון
כמה שבועות, רק כדי להשתמש

818
00:38:33,740 --> 00:38:34,860
מה שנותן לנו ג.

819
00:38:34,860 --> 00:38:38,120
אני גם הולך לעלות לכאן, ואני
אפשר לשים אותו מעל או מתחת, אבל אני יהיה

820
00:38:38,120 --> 00:38:40,340
רק לשמור את זה אלפביתי
כדי לשמור על דברים מסודרים.

821
00:38:40,340 --> 00:38:43,470
אני מתכוון לכלול cs50.h,
אשר הותקן מראש עבור

822
00:38:43,470 --> 00:38:44,900
לך על מכשיר CS50.

823
00:38:44,900 --> 00:38:47,640
וזה קוד פתוח, כך שגם אנשים
באינטרנט יכול להשתמש בו עליהם

824
00:38:47,640 --> 00:38:48,450
מחשבים משלו.

825
00:38:48,450 --> 00:38:50,700
אבל זה בא עם מכשיר CS50.

826
00:38:50,700 --> 00:38:55,320
>> אז עכשיו תן לי לחזור ולהדר מחדש
זה עם לעשות שלום 1.

827
00:38:55,320 --> 00:38:55,710
לעזאזל.

828
00:38:55,710 --> 00:38:57,240
ובכל זאת עוד שגיאה.

829
00:38:57,240 --> 00:38:59,370
בואו לגלול עד הראשון, אבל.

830
00:38:59,370 --> 00:39:00,630
זה אחד זה קצת מורכב.

831
00:39:00,630 --> 00:39:03,830
אופי רב אופי קבוע.

832
00:39:03,830 --> 00:39:04,890
זה לא עוזר לי.

833
00:39:04,890 --> 00:39:08,220
אבל שימו לב, קלאנג הוא לפחות קצת
קצת הגון, לפיה עם קצת

834
00:39:08,220 --> 00:39:11,890
תו ירוק סמל, הוא אומר
כאן מקום שבו אני דפוק.

835
00:39:11,890 --> 00:39:16,160
למה הוא מצביע, שעם קצת
חץ ירוק, לציטוט הבודד הבא

836
00:39:16,160 --> 00:39:18,290
לשם שלי?

837
00:39:18,290 --> 00:39:20,880
>> אז זה אחד מהדברים שאתה רק
להתרגל אליו, במיוחד אם אתה כבר

838
00:39:20,880 --> 00:39:23,980
תכנות בפייתון, או JavaScript,
או בשפות אחרות שבו פרט זה

839
00:39:23,980 --> 00:39:24,560
לא משנה.

840
00:39:24,560 --> 00:39:25,740
ב-C, זה כן משנה.

841
00:39:25,740 --> 00:39:29,520
אם אתה מכריז מחרוזת, שהוא
רצף של 0 או יותר תווים,

842
00:39:29,520 --> 00:39:32,280
אתה באמת חייב להשתמש במרכאות כפולות.

843
00:39:32,280 --> 00:39:36,670
אז בעצם אני צריך לשנות את זה בחזרה
כדי לפתוח הצעת מחיר, לסגור את הציטוט, עם

844
00:39:36,670 --> 00:39:37,800
מרכאות כפולות.

845
00:39:37,800 --> 00:39:41,610
לעשות יחיד ציטוטים יש להם מקום, אבל
רק כאשר אתה משתמש באדם

846
00:39:41,610 --> 00:39:44,100
תווים, אבל עוד על כך בפעם אחרת.

847
00:39:44,100 --> 00:39:46,550
לעת עתה, במרכאות הכפולות
הם הכרחיים.

848
00:39:46,550 --> 00:39:50,460
>> אז עכשיו, תן לי לחזור למסוף שלי
חלון, לעשות שלום 1.

849
00:39:50,460 --> 00:39:51,450
ומי בטוח?

850
00:39:51,450 --> 00:39:53,800
האם התכנית הזו עכשיו הולכת
כדי לקמפל בצורה נכונה?

851
00:39:53,800 --> 00:39:58,250

852
00:39:58,250 --> 00:39:58,540
אישור.

853
00:39:58,540 --> 00:39:59,780
אז שלושתנו חושבים שזה.

854
00:39:59,780 --> 00:40:00,280
בסדר.

855
00:40:00,280 --> 00:40:01,190
Enter.

856
00:40:01,190 --> 00:40:02,440
וזה באמת עשה.

857
00:40:02,440 --> 00:40:05,130
כך שאין טעויות בזמן הזה, אפילו
למרות שתכנית זו היא לפשוט קצת

858
00:40:05,130 --> 00:40:05,840
מורכב יותר.

859
00:40:05,840 --> 00:40:10,110
אם אני עכשיו עושה נקודת לוכסן שלום 1, הזן,
זה הולך להגיד "שלום, דוד".

860
00:40:10,110 --> 00:40:11,750
>> אבל בואו נעשה איטרציה השלישית
מזה, שבו

861
00:40:11,750 --> 00:40:13,380
התכנית היא דינמית באמת.

862
00:40:13,380 --> 00:40:16,770
תן לי ללכת קדימה ולשנות את הקובץ
שם, רק בשביל עקביות עם

863
00:40:16,770 --> 00:40:20,410
קבצים יהיה לך זמין
אחר כך לך באינטרנט.

864
00:40:20,410 --> 00:40:21,620
Enter.

865
00:40:21,620 --> 00:40:25,510
ועכשיו אני הולך להיכנס ולא
לאחסן "דוד" המקודדים קשה כאן.

866
00:40:25,510 --> 00:40:28,826
מה אני יכול לעשות כדי פשוט מאוד
לשפר את התכנית זו?

867
00:40:28,826 --> 00:40:30,520
>> אני יכול להתקשר getstring.

868
00:40:30,520 --> 00:40:33,240
זה יכול להיות זה מה שאינו מובן מאליי קטן
עומד לקרות, אז אני הולך

869
00:40:33,240 --> 00:40:38,470
לבעצם להוסיף קו נוסף, printf,
ולומר את השם, מעי גס, ציטוט קרוב, רק

870
00:40:38,470 --> 00:40:40,790
כדי לתת למשתמש מהיר
על המסך.

871
00:40:40,790 --> 00:40:42,980
ועכשיו אני הולך כאן, ואני
הולך להשתמש בקיצור המקשים שלי.

872
00:40:42,980 --> 00:40:47,680
אני הולך למעלה, למעלה, ולשנות
שלום 1 לשלום 2, Enter.

873
00:40:47,680 --> 00:40:49,260
ותודה לאל, אני עושה התקדמות.

874
00:40:49,260 --> 00:40:52,720
>> ועכשיו אני הולך לעלות
לנקודת לוכסן שלום ו

875
00:40:52,720 --> 00:40:54,690
לשנות את זה ל 2, Enter.

876
00:40:54,690 --> 00:40:55,650
ועכשיו התכנית שלי -

877
00:40:55,650 --> 00:40:57,700
אני להתקרב - הוא מקבל
קצת יותר יפה.

878
00:40:57,700 --> 00:41:02,190
שם הוא הולך להיות, נניח רוב
הפעם, הזן, הלו, רוב.

879
00:41:02,190 --> 00:41:03,260
אנחנו יכולים לעשות את זה שוב.

880
00:41:03,260 --> 00:41:05,360
שם, לורן, Enter.

881
00:41:05,360 --> 00:41:07,820
שם, יוסף, Enter.

882
00:41:07,820 --> 00:41:11,596
שם, בואו ננסה להיות
קשה, Enter.

883
00:41:11,596 --> 00:41:12,410
אה.

884
00:41:12,410 --> 00:41:14,680
זה לא באמת באג.

885
00:41:14,680 --> 00:41:16,090
אז זה רק קטן ומכוער.

886
00:41:16,090 --> 00:41:18,640
אז אולי אנחנו יכולים לפתור את זה
בעתיד, לא עכשיו.

887
00:41:18,640 --> 00:41:20,840
>> אבל איך היית אינסטינקטיבי
ללכת על טיפול

888
00:41:20,840 --> 00:41:21,990
אתגר מסוים הזה?

889
00:41:21,990 --> 00:41:23,710
זה פשוט נראה טיפשי.

890
00:41:23,710 --> 00:41:27,320
איך להימנע מדברים
מחפש טיפש?

891
00:41:27,320 --> 00:41:29,890
אז אנחנו יכולים לעשות, בסדר, שמעתי בני זוג
של דברים, ומצב לולאה.

892
00:41:29,890 --> 00:41:33,340
אנחנו יכולים להשתמש בו, אחד, מצבו, כדי לבדוק את
מה האורך של המחרוזת

893
00:41:33,340 --> 00:41:34,190
המשתמש נתן לנו?

894
00:41:34,190 --> 00:41:37,100
ואם זה 0, זה פשוט מירכאות,
הם פשוט על Enter, ולאחר מכן

895
00:41:37,100 --> 00:41:38,930
אולי כדאי לי לצעוק עליהם
ותנחה אותם שוב.

896
00:41:38,930 --> 00:41:39,970
אבל איך שתנחה אותם שוב?

897
00:41:39,970 --> 00:41:44,230
ובכן, גם אני שמעתי את הלולאה, ושאני יכול
לעשות את זה שוב ושוב ושוב

898
00:41:44,230 --> 00:41:47,010
להציג הודעה למשתמש על אותו הדבר.

899
00:41:47,010 --> 00:41:48,880
>> ובכן, בואו נעשינו את הדוגמא השנייה
שימוש שונה

900
00:41:48,880 --> 00:41:50,620
פונקציה בספריית CS50.

901
00:41:50,620 --> 00:41:52,330
תן לי לסגור את הקובץ הזה.

902
00:41:52,330 --> 00:41:53,510
תן לי ליצור אחד חדש.

903
00:41:53,510 --> 00:41:58,510
ואני אתקשר אליו adder.c, רק בגלל
זה קל לעשות חשבון פשוט,

904
00:41:58,510 --> 00:42:00,890
למרות שזה יהיה לגמרי
underwhelming עם מה שאתה יכול לעשות

905
00:42:00,890 --> 00:42:02,250
עם כל מחשב מודרני.

906
00:42:02,250 --> 00:42:03,750
>> אבל תן לי ללכת קדימה ועכשיו -

907
00:42:03,750 --> 00:42:10,680
אני למדתי את הלקח שלי בפעם האחרונה - כולל
cs50.h, להכליל את stdio.h, int

908
00:42:10,680 --> 00:42:14,170
החלל מרכזי, אשר, לעת עתה, אני רק
לקחת על אמונה עיוורת, אבל נניח

909
00:42:14,170 --> 00:42:16,380
שיבין מה
זה אומר שלפני זמן רב.

910
00:42:16,380 --> 00:42:21,030
ואני הולך להגיד משהו
כמו "תן לי int".

911
00:42:21,030 --> 00:42:22,140
>> ועכשיו, איך אני מגיע int?

912
00:42:22,140 --> 00:42:26,820
אני רוצה להכריז על סופו של דבר משתנה
בשם X מסוג int ו

913
00:42:26,820 --> 00:42:29,240
לאחסן אותו במספר שלם מהמשתמש.

914
00:42:29,240 --> 00:42:29,970
אז זה היה בפה מלא.

915
00:42:29,970 --> 00:42:35,680
אבל אם מישהו רוצה להציע, איך
אני מצהיר בשם X מספר שלם?

916
00:42:35,680 --> 00:42:36,310
x int.

917
00:42:36,310 --> 00:42:37,430
>> אז זה באמת פשוט ש.

918
00:42:37,430 --> 00:42:38,240
תן לי int.

919
00:42:38,240 --> 00:42:39,070
קוראים לזה x.

920
00:42:39,070 --> 00:42:40,580
עכשיו אני משתמש באופרטור ההשמה.

921
00:42:40,580 --> 00:42:43,400
ואיך אני יכול לאחסן מ
עזב את ערכו של המשתמש?

922
00:42:43,400 --> 00:42:47,310
אני לא רוצה לקרוא לgetstring,
כמובן, אלא getint.

923
00:42:47,310 --> 00:42:49,060
כל ויכוחים?

924
00:42:49,060 --> 00:42:49,350
לא.

925
00:42:49,350 --> 00:42:51,870
כך שזה פתוח פארן, קרוב paren
באופן מיידי, ולאחר מכן

926
00:42:51,870 --> 00:42:53,440
פסיק מסתיים הקו.

927
00:42:53,440 --> 00:42:54,930
>> עכשיו תן לי לעשות את זה שוב.

928
00:42:54,930 --> 00:42:57,070
תן לי int אחר.

929
00:42:57,070 --> 00:43:01,850
הפעם אני אעשה int, בואו
קורא לזה Y, שווה getint.

930
00:43:01,850 --> 00:43:05,060
ועכשיו תן לי לעשות משהו סופר פשוט
כמו קצת מתמטיקה.

931
00:43:05,060 --> 00:43:14,340
אז printf, הסכום של% d הוא
מציין מיקום עבור int.

932
00:43:14,340 --> 00:43:20,030
ו% ד, תקופה, קו נטוי-n.

933
00:43:20,030 --> 00:43:20,360
>> בסדר.

934
00:43:20,360 --> 00:43:21,670
אז זה לא ממש מתמטיקה.

935
00:43:21,670 --> 00:43:25,500
אבל אם אני רוצה להגיד את הסכום הזה
ערך בתוספת ערך זה שווה את זה

936
00:43:25,500 --> 00:43:29,320
ערך אחר, כמה טיעונים ל
אני סה"כ צריך לתת printf,

937
00:43:29,320 --> 00:43:30,520
סופו של דבר?

938
00:43:30,520 --> 00:43:31,420
אז ארבעה, נכון?

939
00:43:31,420 --> 00:43:33,790
מחרוזת זו ולאחר מכן את שלושה הערכים.

940
00:43:33,790 --> 00:43:37,560
אז X הוא הראשון שאני רוצה להיות
פקוק בראשון ל% d.

941
00:43:37,560 --> 00:43:39,270
Y הולך להיות הבאה.

942
00:43:39,270 --> 00:43:42,030
>> ועכשיו אני סוג של רוצה לומר
Z, אבל z לא קיים.

943
00:43:42,030 --> 00:43:43,190
אבל זה לא עניין גדול.

944
00:43:43,190 --> 00:43:45,440
כי מה שהיית עושה באופן אינסטינקטיבי,
במיוחד אם היה לך

945
00:43:45,440 --> 00:43:47,820
גרפים מחשבון, מה אתה מקליד?

946
00:43:47,820 --> 00:43:48,760
מה דעתך על X ועוד Y?

947
00:43:48,760 --> 00:43:50,200
אז זה לא משתנה בפועל.

948
00:43:50,200 --> 00:43:51,820
זה רק הסכום של שני
משתנים אחרים.

949
00:43:51,820 --> 00:43:53,170
וזה לגיטימי לחלוטין.

950
00:43:53,170 --> 00:43:56,630
C בהחלט מבין פשוט
חשבון כזה.

951
00:43:56,630 --> 00:43:58,450
>> פסיק, לשמור.

952
00:43:58,450 --> 00:44:02,080
עכשיו תן לי ללכת לכאן ו
הקלד להפוך אפעה, Enter.

953
00:44:02,080 --> 00:44:04,100
אין שגיאה, אז זה גם התקדמות.

954
00:44:04,100 --> 00:44:04,890
הקלד אפעה.

955
00:44:04,890 --> 00:44:07,100
וקיצור מקשים אחר,
אם אתה מתחיל להשתעמם

956
00:44:07,100 --> 00:44:08,760
עם כל פקודות -

957
00:44:08,760 --> 00:44:12,650
אם אתה מתחיל להקליד פקודה, כמו נקודה
לקצץ את המודעה, וזה מקום שבך

958
00:44:12,650 --> 00:44:16,020
שעמום בעיטות, אתה בדרך כלל יכול לפגוע
כרטיסייה למחשב יש לסיים את

959
00:44:16,020 --> 00:44:20,510
שאר הביטוי בשבילך אם זה לא
מה שלא ברור צריכים לבוא אחרי מודעה.

960
00:44:20,510 --> 00:44:23,950
>> אז תן לי ללכת קדימה עכשיו
ואתה לוחץ על Enter.

961
00:44:23,950 --> 00:44:27,490
תן לי int, 1, 2, ו
תודה לאל, שזה 3.

962
00:44:27,490 --> 00:44:29,900
אבל כמו תמיד, לבדיקת תוכניות
לא צריך להפחית ל

963
00:44:29,900 --> 00:44:30,820
רק מנסה את זה פעם אחת.

964
00:44:30,820 --> 00:44:35,560
תן לי לנסות מקרה פינה, כמו שלילי
1, תן לי 1, וכי אחד

965
00:44:35,560 --> 00:44:36,210
בודק את גם כן.

966
00:44:36,210 --> 00:44:38,870
ואני כנראה רוצה לעשות עוד קצת
בדיקות מחמירות, אבל אני די

967
00:44:38,870 --> 00:44:40,630
שבו בנוח עם זה בבית.

968
00:44:40,630 --> 00:44:43,110
>> ובכן, עכשיו בואו ננסה תכנית אחרת
שהפעם משתמש

969
00:44:43,110 --> 00:44:44,620
קצת תחביר אחר.

970
00:44:44,620 --> 00:44:46,100
תן לי ליצור קובץ חדש.

971
00:44:46,100 --> 00:44:51,050
אני אתקשר conditions0.c זו בשורה
עם כמה דוגמת קוד באינטרנט.

972
00:44:51,050 --> 00:44:55,550
ותן לי ללכת ולעשות
כולל cs50.h, כולל

973
00:44:55,550 --> 00:45:00,320
stdio.h, בחלל עיקרי -

974
00:45:00,320 --> 00:45:01,030
אישור.

975
00:45:01,030 --> 00:45:01,850
שם אנחנו הולכים.

976
00:45:01,850 --> 00:45:03,010
יש לנו מוכן מראש הרגיל שלנו.

977
00:45:03,010 --> 00:45:08,170
>> והפעם אני הולך לומר printf,
"הייתי רוצה int, בבקשה," רק כדי

978
00:45:08,170 --> 00:45:10,030
להפוך את הפקודה קטנה
ידידותי יותר.

979
00:45:10,030 --> 00:45:11,620
ועכשיו אני רוצה לקבל
int מהמשתמש.

980
00:45:11,620 --> 00:45:15,010
אני הולך לקרוא לזה n הפעם, רק
משום n נשמע כמו מספר.

981
00:45:15,010 --> 00:45:18,140
getint, ועכשיו, מה לעשות
אני רוצה לעשות עם זה?

982
00:45:18,140 --> 00:45:21,640
ובכן, אם n הוא - ואני להתקרב -

983
00:45:21,640 --> 00:45:25,930
אם n הוא גדול מ 0, אני רוצה
כדי לבצע את הפעולות הבאות -

984
00:45:25,930 --> 00:45:36,060
printf "אתה הרים מספר חיובי."
דבר אחר, אני הולך להקליד printf "אתה

985
00:45:36,060 --> 00:45:37,870
הרים שלילי

986
00:45:37,870 --> 00:45:39,650
מספר. "בסדר.

987
00:45:39,650 --> 00:45:44,410
אז התכנית הזאת, למרות שאני עשיתי את זה
מהיר, נראה נכונה מבחינה תחבירית.

988
00:45:44,410 --> 00:45:45,010
תן לי לנסות את זה.

989
00:45:45,010 --> 00:45:46,890
הפוך את מצבו 0.

990
00:45:46,890 --> 00:45:47,710
נראה לרוץ.

991
00:45:47,710 --> 00:45:49,230
מצב 0, להיכנס.

992
00:45:49,230 --> 00:45:51,910
בואו ניתן לו int של 50.

993
00:45:51,910 --> 00:45:53,160
הרמתי מספר חיובי.

994
00:45:53,160 --> 00:45:54,230
בואו ננסה את זה שוב.

995
00:45:54,230 --> 00:45:54,930
מצב 0.

996
00:45:54,930 --> 00:45:56,260
שלילי 50.

997
00:45:56,260 --> 00:45:57,290
הרמתי מספר שלילי.

998
00:45:57,290 --> 00:46:00,350
>> אבל עכשיו, תן לי לבחור את מה שאנחנו נשמור
קורא מקרה פינה, שהוא יותר

999
00:46:00,350 --> 00:46:04,702
מקרה מעניין שאתה חושב
אולי ייתן לך קצת בעיות, 0.

1000
00:46:04,702 --> 00:46:07,940
עכשיו, אני די בטוח שזה אחד
פינת מקרים שבהם הוא אפס

1001
00:46:07,940 --> 00:46:12,330
לא חיובי ולא שליליים, כך שלי
תכנית, אם כי בבחינה תחבירית

1002
00:46:12,330 --> 00:46:15,440
תיקון - זה הידור, הוא פועל -
לא הגיוני נכון.

1003
00:46:15,440 --> 00:46:21,050
אז מה התיקון פשוט כאן אם אני רוצה
כדי לזהות, אם אני רוצה להתמודד עם n

1004
00:46:21,050 --> 00:46:23,840
שווה 0 בנפרד?

1005
00:46:23,840 --> 00:46:32,980
>> אז אם n שווה 0, אז אני רוצה לומר
משהו כמו printf "אתה הרים 0".

1006
00:46:32,980 --> 00:46:33,990
תן לי לנסות את זה עכשיו.

1007
00:46:33,990 --> 00:46:38,320
תן לי לחזור לכאן, נקה
החלון שלי, והקומפילציה.

1008
00:46:38,320 --> 00:46:38,690
הממ.

1009
00:46:38,690 --> 00:46:39,770
ליצור שגיאה אחת.

1010
00:46:39,770 --> 00:46:41,630
אבל אני רוצה לבדוק אותך
אם n שווה 0.

1011
00:46:41,630 --> 00:46:44,230

1012
00:46:44,230 --> 00:46:47,720
>> אז שוב, עוד דבר טיפשי
להתרגל, סימן שוויון הוא

1013
00:46:47,720 --> 00:46:48,910
אופרטור ההשמה.

1014
00:46:48,910 --> 00:46:52,240
אז זה בעצם טעות בכך,
מבחינה טכנית, למרות שהמהדר

1015
00:46:52,240 --> 00:46:56,450
הגנה עליי מעצמי, הייתי
מבחינה טכנית ניתן להעתקת 0 N, אשר

1016
00:46:56,450 --> 00:46:57,590
זה לא מה שאני רוצה.

1017
00:46:57,590 --> 00:47:00,950
אני רוצה לבדוק לשוויון
עם שווה שווה.

1018
00:47:00,950 --> 00:47:03,390
וכך שעכשיו יכול להיות
הפתרון טוב יותר שלי.

1019
00:47:03,390 --> 00:47:07,810
>> תן לי לשמור מחדש למעשה זה כמו, יניח,
conditions1, להיות חדש ומשופר.

1020
00:47:07,810 --> 00:47:10,480
אז עכשיו אם אני הידור מחדש את זה,
זה יגרום תנאים -

1021
00:47:10,480 --> 00:47:16,960
אופס - להפוך conditions1 נקודת לוכסן
conditions1, הזן, "הייתי רוצה int,

1022
00:47:16,960 --> 00:47:18,760
בבקשה. "אני מתכוון ללכת
קדימה, הקלד 50.

1023
00:47:18,760 --> 00:47:19,660
זה עדיין טוב.

1024
00:47:19,660 --> 00:47:21,200
50 שלילי, עדיין טוב.

1025
00:47:21,200 --> 00:47:24,920
0, וזה, אכן, זוהה
שהרמתי 0.

1026
00:47:24,920 --> 00:47:28,200
>> אז מה יותר עכשיו אני יכול לעשות עם זה?

1027
00:47:28,200 --> 00:47:32,280
ובכן, אנחנו בהחלט יכולים לעשות יותר ויותר
דברים מורכבים.

1028
00:47:32,280 --> 00:47:37,240
אבל מה שאני רוצה להציע הוא
שאנחנו בסופו על הפתק הזה כאן.

1029
00:47:37,240 --> 00:47:41,680
אם אנחנו מושכים את זה, תראה, אולי,
סרט מצויר אהוב שלך

1030
00:47:41,680 --> 00:47:43,326
עד היום אתה יכול
מעולם לא הבין.

1031
00:47:43,326 --> 00:47:46,550

1032
00:47:46,550 --> 00:47:49,520
וזה בערך את האיכות של הצחוק
אתה צריך לקבל עם בדיחות CS.

1033
00:47:49,520 --> 00:47:51,060
אז זה בערך נכון.

1034
00:47:51,060 --> 00:47:54,900
>> אבל יותר משכנע, חשבתי שאני הייתי
לתת לנו טיזר קטן ליום השני.

1035
00:47:54,900 --> 00:47:56,430
אז אנחנו כבר התחלנו להשתמש במספרים שלמים.

1036
00:47:56,430 --> 00:47:57,510
אנחנו כבר התייחסנו למרחף.

1037
00:47:57,510 --> 00:48:00,120
אפילו אנחנו כבר התייחסנו לזוגות,
אשר, שוב, לתת לך מספרים

1038
00:48:00,120 --> 00:48:01,390
לאחר נקודות עשרוניות.

1039
00:48:01,390 --> 00:48:04,230
>> אבל מתברר שצף
זוגות, ובאמת, מחשבים,

1040
00:48:04,230 --> 00:48:08,470
ביסודו, לא יכול להביע את
כמה ערכים בדיוק.

1041
00:48:08,470 --> 00:48:12,840
אנחנו יודעים משיעורים במתמטיקה, כי אתה יכול
יש כל מספר של מספרים לאחר

1042
00:48:12,840 --> 00:48:13,510
נקודה עשרונית.

1043
00:48:13,510 --> 00:48:16,460
ואתה יכול גם לשים פס אנכי
לומר אלה יימשכו לנצח.

1044
00:48:16,460 --> 00:48:18,810
>> למרבה הצער, אתה לא יכול באמת
לעשות את זה במחשב.

1045
00:48:18,810 --> 00:48:20,400
וכך מתעוררים מקרים פינתיים.

1046
00:48:20,400 --> 00:48:23,120
לדוגמה, נניח שאתה
עושה משהו כלכלי.

1047
00:48:23,120 --> 00:48:25,700
אתה עושה מתמטיקה
עם האחוזים, ו

1048
00:48:25,700 --> 00:48:27,030
עם דולרים וסנטים.

1049
00:48:27,030 --> 00:48:29,230
והסנאט האלה לא
בהכרח שורה למעלה.

1050
00:48:29,230 --> 00:48:34,120
ובכן, מתברר שברים של
פרוטות יכולות להתחיל להוסיף עד מתי

1051
00:48:34,120 --> 00:48:37,250
דגם עם מערכת מחשב
בצורה כזאת, כי חכמה

1052
00:48:37,250 --> 00:48:39,100
בני אדם יכול לנצל.

1053
00:48:39,100 --> 00:48:42,650
>> ואלו מכם שלא ראו, היינו
רוצים לתת לך טיזר של 30 שניות של

1054
00:48:42,650 --> 00:48:48,290
סרט נפלא המכונה שטחי משרדים,
אשר לצייר תמונה של

1055
00:48:48,290 --> 00:48:51,205
בעיה שנתמודד איתה
הדבר ראשון ביום שני.

1056
00:48:51,205 --> 00:48:53,960
אם היינו יכול להעלות את עוצמת הקול
קצת, אני נותן לך 30

1057
00:48:53,960 --> 00:48:55,495
שניות של שטחי משרדים.

1058
00:48:55,495 --> 00:48:55,770
>> [השמעת וידאו]

1059
00:48:55,770 --> 00:48:59,000
>> , אני מתכוון, לך, לך לא היה מראה
ואתה מקבל כדי לשמור על העבודה שלך.

1060
00:48:59,000 --> 00:49:00,620
>> -למעשה, אני המקודם.

1061
00:49:00,620 --> 00:49:03,240
>> אני יכול לתכנת-וירוס שהייתי
לקרוע את המקום שבגדול.

1062
00:49:03,240 --> 00:49:04,430
>> -ובכן, איך זה עובד?

1063
00:49:04,430 --> 00:49:06,782
>> -כל פעם שיש עסקת בנק
שבו ריבית מחושבת, ויש

1064
00:49:06,782 --> 00:49:10,160
אלפי ביום, המחשב מסתיים
עם שברים של אחוזים אלה.

1065
00:49:10,160 --> 00:49:12,030
>> אבל, אני לא הולך ל
לעשות משהו לא חוקי.

1066
00:49:12,030 --> 00:49:12,660
>> -בלתי חוקי?

1067
00:49:12,660 --> 00:49:15,075
סמיר, זה אמריקה.

1068
00:49:15,075 --> 00:49:16,570
>> -אנחנו צריכים נשבעים באלוהים.

1069
00:49:16,570 --> 00:49:19,070
>> אם אף אחד לא יודע, על זה
אבל לנו, בסדר?

1070
00:49:19,070 --> 00:49:21,920
אין בני משפחה, אין
חברות, אף אחד.

1071
00:49:21,920 --> 00:49:22,700
>> -כמובן.

1072
00:49:22,700 --> 00:49:23,320
>> מוסכם.

1073
00:49:23,320 --> 00:49:24,280
>> , אל תדאג, גבר.

1074
00:49:24,280 --> 00:49:25,640
אני לא אספר לאף אחד או.

1075
00:49:25,640 --> 00:49:26,504
>> [השמעת וידאו הסוף]

1076
00:49:26,504 --> 00:49:30,030
>> דוד Malan: אז זה, אם כן, הוא CS50,
שהיה שטחי משרדים, וזה יהיה כל

1077
00:49:30,030 --> 00:49:31,465
הגיוני ביום שני.

1078
00:49:31,465 --> 00:49:33,940
לראות אותך אז.

1079
00:49:33,940 --> 00:49:37,880
>> קריין: בCS50 הבא, רוב
מתאים להיות את

1080
00:49:37,880 --> 00:49:39,130
תכנית ארוחת הרווארד.

1081
00:49:39,130 --> 00:49:56,160