1
00:00:00,000 --> 00:00:02,270
[Powered by Google Translate] [שבוע 2, המשך]

2
00:00:02,270 --> 00:00:04,220
[דוד י מלאן, אוניברסיטת הרווארד]

3
00:00:04,220 --> 00:00:06,880
[זה CS50. - CS50.TV]

4
00:00:06,880 --> 00:00:10,990
בסדר. זה CS50, וזה הסוף של שבוע 2.

5
00:00:10,990 --> 00:00:14,410
אם אתה מצפה שיהיה רעב בזמן הזה מחר,

6
00:00:14,410 --> 00:00:18,620
ידעתי שאנחנו הולכים לכינוס כקבוצה קטנה מחר, יום חמישי, 1:15 pm.

7
00:00:18,620 --> 00:00:21,360
יש URL זה כאן אם אתה רוצה לאשר השתתפות.

8
00:00:21,360 --> 00:00:26,740
מספר המקומות מוגבל, אז אנא סלח אם הטופס מתמלא עד שאתה למלא את הטופס.

9
00:00:26,740 --> 00:00:29,300
אתר אחר, לעומת זאת, שהיה בו עניין זה.

10
00:00:29,300 --> 00:00:32,369
כמעט בזמן של חודש, כמובן הולך להיות זמין

11
00:00:32,369 --> 00:00:36,890
כל באופן רחב יותר באמצעות edx, דרך שאנשים באינטרנט יוכלו לבצע יחד,

12
00:00:36,890 --> 00:00:39,380
לעסוק בקורס די פעיל, למעשה.

13
00:00:39,380 --> 00:00:42,270
הם ישתמשו CS50 Appliance וCS50 דיון

14
00:00:42,270 --> 00:00:45,490
ורוב כלי תוכנה השונים שאנו כבר משתמשים בסמסטר הזה.

15
00:00:45,490 --> 00:00:48,710
ואחת מהיוזמות שהיינו רוצה לקחת עליו כניסוי בשנה זו

16
00:00:48,710 --> 00:00:51,930
הוא לראות עד כמה תוכן שאנו יכולים לתרגם

17
00:00:51,930 --> 00:00:53,960
לשפות מדוברות וכתובה אחרות.

18
00:00:53,960 --> 00:00:57,500
אז אם אתה יכול להיות עניין בהשתתפות בפרויקט זה

19
00:00:57,500 --> 00:01:02,270
לפיו אנו נספק תמלילים וכתוביות באנגלית להרצאות של הקורס

20
00:01:02,270 --> 00:01:05,450
ומכנסיים קצרים ובסמינרים וחתכים וכדומה,

21
00:01:05,450 --> 00:01:08,200
אם אתה מדבר באופן שוטף או לכתוב ברהיטות שפה אחרת,

22
00:01:08,200 --> 00:01:12,290
נשמח לשתף אותך בפרויקט זה לפיו אתה לוקח על אחד או יותר מהסרטונים,

23
00:01:12,290 --> 00:01:15,200
לתרגם אותם לשפה שאתה יודע היטב.

24
00:01:15,200 --> 00:01:18,700
>> כדי לתת לך תחושה של הממשק, יש ממשק משתמש מבוסס אינטרנט זה

25
00:01:18,700 --> 00:01:22,090
כי יהיה לנו באמצעות שייצור ממשק משתמש כזה במהות.

26
00:01:22,090 --> 00:01:24,290
זה היה לי מלמד איזה ליל כל קדושים לפני

27
00:01:24,290 --> 00:01:27,390
ובצד הימני יש בשחור ליד חותמות זמן אלו,

28
00:01:27,390 --> 00:01:31,210
אתה תראה את הדברים השונים שיצאו מהפה שלי באותו היום,

29
00:01:31,210 --> 00:01:34,850
ואז מתחתיה תוכל לתרגם לשפה אחרת

30
00:01:34,850 --> 00:01:38,690
בדיוק מה הוא המיפוי בין, במקרה זה, באנגלית, ואומרת, ספרדית.

31
00:01:38,690 --> 00:01:40,440
אז זה בעצם כלי מאוד ידידותי למשתמש.

32
00:01:40,440 --> 00:01:43,370
אתה יכול להריץ אחורה וקדימה במהירות מאוד בקלות עם קיצורי מקלדת.

33
00:01:43,370 --> 00:01:47,490
אז אם אתם רוצים לקחת חלק בניסוי הזה ויש את המילים שלך ראו וקראו

34
00:01:47,490 --> 00:01:51,850
על ידי פוטנציאל אלף של אנשים בחוץ, אנא אל תהסס להשתתף.

35
00:01:51,850 --> 00:01:54,350
מילה אחת על החתלתול מיום השנייה.

36
00:01:54,350 --> 00:02:00,350
פן שלחנו הודעה מדי מפחידה, הבין ש, כשעתי משרד מציעות

37
00:02:00,350 --> 00:02:03,300
וכפי שמציעים חלקים, העיצוב של הקורס הוא מאוד

38
00:02:03,300 --> 00:02:07,360
לתלמידים משתפים פעולה ומדבר לעבוד דרך סטי בעיה

39
00:02:07,360 --> 00:02:11,260
ובעיות ביחד, ובאמת הקו פשוט מסתכם,

40
00:02:11,260 --> 00:02:16,010
שוב, העבודה שסופו של דבר להגיש צריכה להיות שלך.

41
00:02:16,010 --> 00:02:18,860
וכך בכנות, בשעתי עבודה במשרד זה נורמלי לחלוטין,

42
00:02:18,860 --> 00:02:22,240
זה לחלוטין צפוי גם, שמשוחח איתו כמה חבר לידך.

43
00:02:22,240 --> 00:02:24,370
>> אם הוא או היא מתמודד עם נושא מסוים ואתה כמו,

44
00:02:24,370 --> 00:02:27,940
"נו, טוב, בוא וניתן לך מבט חטוף על כמה משורת הקוד שכתבתי," זה בסדר,

45
00:02:27,940 --> 00:02:31,250
זה קורה, וזה מאוד מעודד, אני חושב, בתהליך של למידה.

46
00:02:31,250 --> 00:02:36,750
איפה הקו מקבל חצה הוא כאשר הראש מוטה הוא סוג של כאן לשניות רבות מדי

47
00:02:36,750 --> 00:02:41,160
או דקות שבאמת היו בדיוק הזדמנות הסבירה איך לחבר שלך,

48
00:02:41,160 --> 00:02:44,160
ובוודאי כאשר דברים מקבלים החליפו באמצעות דוא"ל וDropbox וכדומה,

49
00:02:44,160 --> 00:02:45,640
שם יש גם את הקו.

50
00:02:45,640 --> 00:02:48,620
אז בכל האמצעים להרגיש בנוח וחשים עידוד כדי לשוחח עם חברים

51
00:02:48,620 --> 00:02:52,810
וחבריו לכיתה על psets ועוד ופשוט מבינים שסופו של דבר מה שאתה להגיש

52
00:02:52,810 --> 00:02:57,340
באמת צריך להיות התוצר של יצירה ולא שלך למישהו אחר.

53
00:02:57,340 --> 00:03:00,490
וכך, אחת בעיות תחום הספציפיות לpset2,

54
00:03:00,490 --> 00:03:04,740
שיצא מחר בלילה מאוחר, הוא לצלול לתוך העולם של קריפטוגרפיה,

55
00:03:04,740 --> 00:03:08,970
שהוא האמנות של הצפנה או ערבול מידע,

56
00:03:08,970 --> 00:03:12,600
וזה סופו של דבר מתייחס לעולם של ביטחון.

57
00:03:12,600 --> 00:03:16,560
עכשיו, בטחון עבור רובנו מגיע בצורה של מנגנונים די שיגרתי.

58
00:03:16,560 --> 00:03:19,050
לכולנו יש שמות משתמש וסיסמות,

59
00:03:19,050 --> 00:03:23,450
ולכולנו יש שמות משתמש וסיסמות רעים מאוד, סביר להניח.

60
00:03:23,450 --> 00:03:28,240
>> אם הסיסמה שלך היא זהה במספר אתרי אינטרנט, זה כנראה לא הרעיון הטוב ביותר,

61
00:03:28,240 --> 00:03:30,070
כנדברנו לקראת סוף הסמסטר.

62
00:03:30,070 --> 00:03:34,720
אם הסיסמה שלך כתובה על פתק דביק - לא בדיחה - על הצג שלך,

63
00:03:34,720 --> 00:03:38,350
שגם הוא לא בהכרח הכי הטוב, אבל העיצוב די תופעה נפוצה.

64
00:03:38,350 --> 00:03:42,470
ואם אתה לא משתמש בהצפנה כדי להצפין את הסיסמות שלך,

65
00:03:42,470 --> 00:03:44,210
הם פגיעים במיוחד.

66
00:03:44,210 --> 00:03:47,270
אז אם אתה חושב שאתה סופר חכם על ידי בעל מסמך Word נסתר

67
00:03:47,270 --> 00:03:49,910
מקום בכונן הקשיח שלך, כי יש את כל הסיסמות שלך

68
00:03:49,910 --> 00:03:53,670
אבל זה בתיקייה שאף אחד לא הולך להיראות ב, שגם הוא לא מנגנון מאובטח מאוד.

69
00:03:53,670 --> 00:03:56,990
ואז מה יהיה להכניס pset2 הוא זו אמנות של קריפטוגרפיה

70
00:03:56,990 --> 00:04:02,010
וערבול מידע, כך שדברים כמו סיסמות הם כל מאובטחים יותר.

71
00:04:02,010 --> 00:04:05,790
ההקשר כאן הוא שעם נתונים מאובטחים

72
00:04:05,790 --> 00:04:07,930
מגיע הזדמנות להצפין אותו וכדי לטרוף אותו.

73
00:04:07,930 --> 00:04:11,470
וכך זה, למשל, הוא דוגמה להודעה מוצפנת.

74
00:04:11,470 --> 00:04:14,700
זה בעצם אומר משהו באנגלית, אבל ברור שזה לא לגמרי ברור.

75
00:04:14,700 --> 00:04:18,279
ואנחנו סגרנו מעגל היום להקניט בנפרד מה המסר הסודי הזה כאן הוא.

76
00:04:18,279 --> 00:04:23,490
אבל בעולם האמיתי של מחשבים, דברים אפילו לא נראים כמו שהם יכולים להיות משפטים באנגלית.

77
00:04:23,490 --> 00:04:28,430
לדוגמה, זה מה שאפשר למצוא על תקן לינוקס או מק או UNIX מחשב

78
00:04:28,430 --> 00:04:32,070
בקובץ שהיה פעם שם קובץ הסיסמות.

79
00:04:32,070 --> 00:04:34,200
>> בימינו זה כבר עבר למקומות אחרים.

80
00:04:34,200 --> 00:04:39,210
אבל אם אתה מסתכל במקום הנכון במערכת, תוכל לראות לא רק את שם המשתמש שלך

81
00:04:39,210 --> 00:04:43,400
או שאנשים אחרים במערכת, אבל תראה גרסה מוצפנת של הסיסמה שלהם.

82
00:04:43,400 --> 00:04:47,980
ואכן, המילה קריפטה יש טוענת כי הדברים שלהלן הם מוצפנים,

83
00:04:47,980 --> 00:04:52,680
וזו סדרה של אותיות אקראיות לכאורה ותווים ומספרים וכן הלאה

84
00:04:52,680 --> 00:04:56,480
יכול להיות מפוענח רק על ידי ידיעת סוד כלשהו בדרך כלל -

85
00:04:56,480 --> 00:04:58,840
מילה סודית, מספר סודי -

86
00:04:58,840 --> 00:05:03,160
וכך אכן, האמנות של הצפנה בסופו של דבר מסתכם במורד לסמוך כלשהי

87
00:05:03,160 --> 00:05:05,650
ולדעת משהו שמישהו אחר לא.

88
00:05:05,650 --> 00:05:10,090
כך יהיה לנו לחקור את זה בפירוט קצת יותר היום ובpset לבוא.

89
00:05:10,090 --> 00:05:12,200
ועכשיו מילה על עובר / נכשל.

90
00:05:12,200 --> 00:05:15,360
במיוחד כפי שחלקכם צלל לתוך pset1, Appliance,

91
00:05:15,360 --> 00:05:19,080
ועולם חדש מאוד לעצמך, להבין שתסכולים ובלבול

92
00:05:19,080 --> 00:05:21,700
ורק קשיים טכניים הם די צפויים,

93
00:05:21,700 --> 00:05:24,180
במיוחד עם pset הראשון, שבו יש פשוט כל כך הרבה דברים חדשים,

94
00:05:24,180 --> 00:05:27,730
פשוט מקבל את מכיר את LS וcd וכל הפקודות המסתוריות האלה

95
00:05:27,730 --> 00:05:33,050
וסביבה חדשה, וזה נפרד מהחומר בפועל ותכנות עצמו.

96
00:05:33,050 --> 00:05:36,940
אז הבין גם שיש בהחלט שעתי עבודה שקיימת כמבנה תמיכה.

97
00:05:36,940 --> 00:05:38,880
>> סעיפים מתחילים ביום ראשון הקרוב.

98
00:05:38,880 --> 00:05:42,960
אבל הכי חשוב, אם אתם מרגישים שזה לא העולם בשבילך,

99
00:05:42,960 --> 00:05:44,710
להבין שזה באמת פשוט ייקח זמן.

100
00:05:44,710 --> 00:05:48,600
ואם לא היה ההזדמנות הזאת לפני שנים בשבילי לקחת לעבור כיתה / נכשל,

101
00:05:48,600 --> 00:05:50,990
בכנות, לא הייתי אפילו כף רגלם בכיתה.

102
00:05:50,990 --> 00:05:53,690
ואתה יכול לשנות את זה עד, יניח, 5 היום השני של הקורס,

103
00:05:53,690 --> 00:05:58,280
כך שאם אתה בקצה עכשיו, מבין שלא בראש לכמה מים אחרים לגמרי,

104
00:05:58,280 --> 00:06:01,260
בהחלט תשקלו רק משנה לעובר / נכשל.

105
00:06:01,260 --> 00:06:04,570
שוב, אין באמת זו תרבות כאן ברווארד של לקיחת דברים עוברים / נכשל

106
00:06:04,570 --> 00:06:08,670
מאז כולם באמת רוצה להשיג או overachieve,

107
00:06:08,670 --> 00:06:11,130
אבל בכנות, זו היא דרך נפלאה של ניסה משהו

108
00:06:11,130 --> 00:06:16,720
כי לא יכול להיות מוכר לך, ותקבל בסופו של דבר לעשות, ברוב המקרים, אפילו בסדר גמור,

109
00:06:16,720 --> 00:06:18,210
אולי להפתעתך.

110
00:06:18,210 --> 00:06:20,980
ובמונחים קונקרטיים יותר, מה שאני חושב עובר / נכשלתי בדרך כלל עושה,

111
00:06:20,980 --> 00:06:22,940
במיוחד כפי שאולי חווה עם pset0,

112
00:06:22,940 --> 00:06:26,560
אם אתה מכניס 10 שעות, 15 שעות, 25 שעות לתוך pset חלק

113
00:06:26,560 --> 00:06:29,920
ואתה פשוט לדפוק את הראש בקיר וזה מתחיל להיות סופר מאוחר בלילה

114
00:06:29,920 --> 00:06:33,950
אבל אתה כבר לקחת 90% pset של הדרך ואתה פשוט לא יכול להבין דבר אחד,

115
00:06:33,950 --> 00:06:36,520
עובר / נכשל באמת לוקח את עוקצו של מעמד כזה,

116
00:06:36,520 --> 00:06:39,100
שבו אתה יכול למיין של שמחה אומר, "בסדר, אני יודע שזה לא מושלם,

117
00:06:39,100 --> 00:06:42,350
אבל עבדתי לי את התחת על זה, אני די מרוצה מזה שבו בסופו, "

118
00:06:42,350 --> 00:06:44,850
ושיעמוד בציפיות לעוברים / נכשל.

119
00:06:44,850 --> 00:06:47,540
אז אל תשמור את זה בחשבון. בסדר.

120
00:06:47,540 --> 00:06:50,520
>> אז אלו מכם שנאבקו להשתמש אוניברסיטת הרווארד Wi-Fi,

121
00:06:50,520 --> 00:06:54,780
יודע שיש CS50 SSID, חיבור Wi-Fi, מרחף

122
00:06:54,780 --> 00:06:56,490
שייתכן שתהיה לך מזל טוב ל.

123
00:06:56,490 --> 00:07:00,130
זה קצת אירוני שהסיסמה לזה, אם ברצונך לנסות להתחבר לזה

124
00:07:00,130 --> 00:07:08,350
למהירויות טובות יותר - ולהודיע ​​לנו אם זה לא היה טוב יותר - היא עד 8 12345, כל הדרך

125
00:07:08,350 --> 00:07:10,910
כי 8 הם בטוחים יותר מאשר 5.

126
00:07:10,910 --> 00:07:16,910
אז אם אתה צריך את הסיסמה לאינטרנט האלחוטי, חיבור לCS50 אלחוטי כאן, 12345678,

127
00:07:16,910 --> 00:07:20,380
והודעה על CS50 דיון אם עדיין יש לך בעיות קישוריות לסירוגין,

128
00:07:20,380 --> 00:07:25,420
ואנחנו ניידע את הכוחות שיהיה מכירים למרחב הזה. בסדר.

129
00:07:25,420 --> 00:07:32,230
אז טיזר מהיר, במיוחד עבור אלה מכם שהם בנים או בנות מאוורר של אפל כל הדברים.

130
00:07:32,230 --> 00:07:37,460
מה שחפרתי מלפני כמה שנים היה זה קובץ כאן, iUnlock.c,

131
00:07:37,460 --> 00:07:39,930
רק לסוג של להפוך למוחשי יותר ויותר מורכבים

132
00:07:39,930 --> 00:07:42,560
חלק מהתוכניות הבסיסיות יותר C אנחנו כבר כותבים.

133
00:07:42,560 --> 00:07:46,910
אז פתחתי את הקובץ הזה, iUnlock.c. זה זמין בדף ההרצאות להיום.

134
00:07:46,910 --> 00:07:49,810
בצד השמאל אתה רואה רשימה ארוכה של פונקציות.

135
00:07:49,810 --> 00:07:53,230
אז הבחור שכתב את הטקסט הזה כתב למעלה הרבה פונקציות, יותר מאשר רק ראשי.

136
00:07:53,230 --> 00:07:57,340
הוא השתמש בכל חבורה של ספריות לכאן, ואם אנחנו מתחילים לרפרף,

137
00:07:57,340 --> 00:08:04,890
מה שזה באמת הוא, אני מאמין, את הסדק הראשון לאייפון המקורי.

138
00:08:04,890 --> 00:08:09,830
>> כאשר אתה רוצה jailbreak iPhone המקורי, מה שאומר untether מ-AT & T

139
00:08:09,830 --> 00:08:13,710
ובאמת להתקין תוכנה מיוחדת עליו ולעשות דברים שאפל לא רוצה שאנשים יעשו,

140
00:08:13,710 --> 00:08:18,480
מישהו לקח את הזמן כדי להבין בדיוק איך הם יכולים לנצל פגמים בתוכנה,

141
00:08:18,480 --> 00:08:22,690
טעויות, באגים בתוכנה של אפל, וכך נולדו iUnlock.c--

142
00:08:22,690 --> 00:08:26,760
שאם חברת אותו במחשב שלך ולהתקין אותו על ה-iPhone

143
00:08:26,760 --> 00:08:29,430
שהיה מחובר למחשב באמצעות, למשל, כבל USB,

144
00:08:29,430 --> 00:08:32,450
זה ייתן לך הרשאות ניהול או שורש על iPhone

145
00:08:32,450 --> 00:08:34,620
וניתן לך לעשות פחות או יותר מה שאתה רוצה.

146
00:08:34,620 --> 00:08:36,400
ואז היה חתול זה מרתק ומשחק עכבר

147
00:08:36,400 --> 00:08:39,340
בין אפל ושאר העולם בפרט כפי שהם, כמו חברות רבות,

148
00:08:39,340 --> 00:08:43,350
תנסה לנעול את החומר שלהם כלפי מטה, כך שאתה יכול לעשות רק עם זה מה שהם מתכוונים.

149
00:08:43,350 --> 00:08:47,360
אבל הודות לאנשים כמו זה וההבנה של פרטים ברמה נמוכה -

150
00:08:47,360 --> 00:08:50,830
ובמקרה זה תכנות C - והרבה מהמבנים המוכרים

151
00:08:50,830 --> 00:08:55,280
שאנחנו כבר התחלנו לשחק איתו, אתה יכול באמת למנף את החומרה

152
00:08:55,280 --> 00:08:59,250
באופן שאתה רואה לנכון ולא בהכרח חלק התאגיד.

153
00:08:59,250 --> 00:09:01,600
כך למשל, אין לי מושג מה כל זה עושה,

154
00:09:01,600 --> 00:09:03,580
אבל GetVersion נשמע די פשוט,

155
00:09:03,580 --> 00:09:05,710
וזה נראה כאילו זה הוא פונקציה שהאדם הזה כתב.

156
00:09:05,710 --> 00:09:09,250
זה לוקח קצת סוג של מספר שלם כויכוח, לא מחזיר שום דבר,

157
00:09:09,250 --> 00:09:13,710
אבל נראה שלולאה בלולאה לכאן ואם מצב, אם מצב הפסקה,

158
00:09:13,710 --> 00:09:16,770
ואיכשהו מתייחס למספרי גרסות אם לגלול למטה,

159
00:09:16,770 --> 00:09:19,650
למרות שהרבה מילות מפתח אלו הולכים להיות חדשים.

160
00:09:19,650 --> 00:09:22,590
ויש המון פונקציות בכאן שלא ראו ואי אפשר שלא נראה

161
00:09:22,590 --> 00:09:24,350
במהלך הסמסטר.

162
00:09:24,350 --> 00:09:29,160
>> בסופו של היום, זה כפוף לאותם חוקים והיגיון שאנחנו כבר משחקים עם עד כה.

163
00:09:29,160 --> 00:09:34,340
אז זה זקן מכדי לפצח -3 iPhone או 4s או מייד 5s בימים אלה,

164
00:09:34,340 --> 00:09:38,830
אבל יודע שזה נובע במידה רבה מכל העולם הזה שאנחנו כבר צללנו לתוך.

165
00:09:38,830 --> 00:09:42,280
בואו נסתכל על דוגמה קטנה ופשוטה יותר:

166
00:09:42,280 --> 00:09:46,260
את זה, רק כדי להתחמם קצת עם תחביר וגם איזה סוג נתונים אחרים

167
00:09:46,260 --> 00:09:48,910
שדברנו עליו אבל לא באמת ראינו בג

168
00:09:48,910 --> 00:09:53,670
זה קובץ שנקרא positive1.c, ולפי תגובות בראש,

169
00:09:53,670 --> 00:09:56,070
זה פשוט דורש שמשתמש לספק מספר חיובי.

170
00:09:56,070 --> 00:09:59,910
אז זה דוגמה לעשה תוך לולאה, וזה נחמד לתוכניות משתמש אינטראקטיביות

171
00:09:59,910 --> 00:10:02,070
שבו אתה צריך להגיד למשתמש לעשות משהו,

172
00:10:02,070 --> 00:10:05,530
ואם הם לא ישתפו פעולה אתה צועק עליהם או לדחות את הקלט שלהם.

173
00:10:05,530 --> 00:10:10,480
מקרה לדוגמה: אני הולך לעשות קווים 19 עד 24

174
00:10:10,480 --> 00:10:14,620
כל עוד המשתמש לא נתן לי מספר חיובי.

175
00:10:14,620 --> 00:10:21,340
פרט זה כאן בקו 18, למה אני מצהיר מעל כל n looping זה לבנות

176
00:10:21,340 --> 00:10:26,870
בניגוד לימין ליד קו 22 שבו אני ממש אכפת לקבל n? כן.

177
00:10:26,870 --> 00:10:29,330
[תלמיד] סקופ. >> כן, אז בעיה זו של היקף.

178
00:10:29,330 --> 00:10:31,770
ובמונחים של הדיוטות, מה היקף מתייחס?

179
00:10:34,880 --> 00:10:41,560
כן. >> [תגובת תלמיד לא נשמעה] >> אתה יכול לדבר קצת יותר חזק?

180
00:10:41,560 --> 00:10:45,440
[תלמיד] איפה אתה יכול לגשת למשתנה זה. >> מושלם.

181
00:10:45,440 --> 00:10:47,610
איפה אתה יכול לגשת למשתנה מסוימת.

182
00:10:47,610 --> 00:10:50,990
ובאופן כללי, כלל האצבע עד כה היה כי ההיקף משתנה כלשהו

183
00:10:50,990 --> 00:10:56,140
מוגדר על ידי הסוגריים המסולסלים האחרונים שראיתם.

184
00:10:56,140 --> 00:11:03,070
>> ולכן במקרה זה, אם אני עשיתי את הטעות של הכרזת n ב 22 לקו, קו שיעבוד.

185
00:11:03,070 --> 00:11:10,840
הייתי מקבל int, ואני היה מנסח את זה n משתנה בקו 22,

186
00:11:10,840 --> 00:11:17,060
אך שורת הקוד יהיה עכשיו אין לי מושג על מה אני מדבר? >> [תלמיד] 25.

187
00:11:17,060 --> 00:11:23,840
[מלאן] 25, ומתברר גם כי 24 במקרה זה נופל מחוץ לסוגריים המסולסלים.

188
00:11:23,840 --> 00:11:28,550
אז פשוט קצת מפריע, אבל פתר בקלות פשוט על ידי הכרזה על משתנה

189
00:11:28,550 --> 00:11:30,700
מחוץ לתפקיד עצמו.

190
00:11:30,700 --> 00:11:32,760
נראים בהמשך היום אתה יכול ללכת צעד אחד קדימה

191
00:11:32,760 --> 00:11:34,940
ואפילו אתה יכול לקבל קצת עצלן.

192
00:11:34,940 --> 00:11:39,660
וזה לא כדי להיות מומלץ באופן כללי, אבל אתה יכול גם לעצלנים

193
00:11:39,660 --> 00:11:44,150
והכניס את משתנה גלובלית, אם אפשר לומר כך, לא פנימי של פונקציה, לא בתוך לולאה,

194
00:11:44,150 --> 00:11:49,800
אבל בקובץ עצמו, מחוץ לכל הפונקציות שכתבת, כפי שעשיתי כאן ב 15 לקו.

195
00:11:49,800 --> 00:11:55,220
זה בדרך כלל זה בעין יפה, אבל מבין שזה פתרון לפעמים לבעיות אחרות,

196
00:11:55,220 --> 00:11:56,910
כפי שסופו של דבר יראה.

197
00:11:56,910 --> 00:11:59,500
אז לעת עתה נשאיר את זה ככה, אבל בואו נראה אם ​​אנחנו יכולים לכתוב את זה מחדש

198
00:11:59,500 --> 00:12:02,360
רק כדי להתחיל לבטא את עצמנו באופן מעט שונה.

199
00:12:02,360 --> 00:12:05,550
תכנית זו, רק שיהיה ברור, היא positive1.

200
00:12:05,550 --> 00:12:11,980
תן לי ללכת קדימה כאן ובחלון מסופי לעשות positive1, Enter.

201
00:12:11,980 --> 00:12:15,080
הידור בסדר. אני הולך לרוץ positive1, על Enter.

202
00:12:15,080 --> 00:12:19,250
אני דורש ממך לתת לי מספר חיובי. אני אגיד -1. זה לא עבד.

203
00:12:19,250 --> 00:12:22,340
0, 99. נדמה שזה עובד.

204
00:12:22,340 --> 00:12:25,310
אולי לא במבחן הקפדני ביותר, אבל לפחות זה צק של שפיות נחמדה

205
00:12:25,310 --> 00:12:27,100
שאנחנו על המסלול הנכון.

206
00:12:27,100 --> 00:12:29,570
>> אז עכשיו תן לי ללכת קדימה ולפתוח את הגרסה 2 של זה,

207
00:12:29,570 --> 00:12:32,800
ומה שונה כבר?

208
00:12:32,800 --> 00:12:39,030
היא מיישמת את אותו דבר, אבל מה שקופץ החוצה ברגע בבירור שונים הפעם?

209
00:12:40,790 --> 00:12:47,090
זה bool בירוק. זה מסומן בירוק, מילת מפתח זו המכונית bool, שהוא סוג נתונים.

210
00:12:47,090 --> 00:12:50,510
זה לא באו מובנה לכל הגרסות של ג

211
00:12:50,510 --> 00:12:52,650
אתה צריך לכלול ספרייה ספציפית.

212
00:12:52,650 --> 00:12:56,460
במקרה שלנו, אני כלל CS50 הספרייה, כך שיש לנו גישה לbool.

213
00:12:56,460 --> 00:12:59,860
אבל בקו 18, שנראה שיש ערך בוליאני כאן נקרא אסיר תודה.

214
00:12:59,860 --> 00:13:02,190
הייתי יכול בשם כל הדבר הזה, אבל אני קראתי אותו תודה

215
00:13:02,190 --> 00:13:04,750
רק לסוג של להעביר כמה משמעות סמנטית.

216
00:13:04,750 --> 00:13:07,700
אז בהתחלה בקו 18, אני כנראה לא תודה

217
00:13:07,700 --> 00:13:12,230
מכיוון שהערך מודה וליאני מאותחל לכוזב בקו 18.

218
00:13:12,230 --> 00:13:16,500
ואז זה נראה מה שעשיתי כאן בקווים 21 עד 23

219
00:13:16,500 --> 00:13:19,200
אני פשוט סוג של שוכתב ההיגיון שלי.

220
00:13:19,200 --> 00:13:26,100
אז לא פונקציונלי שונה, אבל בקו 22 עכשיו אני בודק אם int המשתמש ספק

221
00:13:26,100 --> 00:13:31,360
גדול מ 0, אז אני פשוט לשנות את ערכו של אסיר תודה לאמיתית.

222
00:13:31,360 --> 00:13:35,590
ולמה אני עושה את זה? כי בקו 25, כנראה אני הולך לבדוק מצב.

223
00:13:35,590 --> 00:13:39,760
האם זה לולאה בזמן אסירי תודה הם שקרי.

224
00:13:39,760 --> 00:13:42,960
אז הצעתי את זה כאלטרנטיבה לגרסת 1

225
00:13:42,960 --> 00:13:47,050
כי זה לפחות קצת יותר אינטואיטיבי, אולי, זה קצת יותר מעוגן באנגלית.

226
00:13:47,050 --> 00:13:51,980
אז בצע את הפעולות הבאות בזמן שאתה לא מודה או בעת אסירי תודה הוא שקרי.

227
00:13:51,980 --> 00:13:56,220
וגם הפעם אני כנראה לא רוצה לזכור את מה שהמשתמש הקליד ב

228
00:13:56,220 --> 00:14:00,050
בגלל הודעה שאין n משתנה, ולכן למעשה, שקר לבן קטן שם.

229
00:14:00,050 --> 00:14:03,290
>> מבחינה פונקציונלית, התכנית היא קצת שונה הרגע שנגיע לתחתית שלה

230
00:14:03,290 --> 00:14:04,960
כי אני לא זוכר מה הוא n.

231
00:14:04,960 --> 00:14:09,120
אבל רציתי להדגים גם כאן שלמרות שאנחנו ראינו GetInt

232
00:14:09,120 --> 00:14:13,780
וGetString בשימוש בצד הימני של סימן השוויון עד כה

233
00:14:13,780 --> 00:14:17,310
כך שאנו זוכרים את הערך, מבחינה הטכנית, זה לא הכרחי.

234
00:14:17,310 --> 00:14:20,290
אם מסיבה כלשהי אתם פשוט לא אכפת לך לשמור את הערך,

235
00:14:20,290 --> 00:14:25,540
אתה רק רוצה לבדוק את הערך, שים לב שאנחנו יכולים פשוט לכתוב את זה כGetInt,

236
00:14:25,540 --> 00:14:27,320
פתוח סוגריים, paren הקרוב.

237
00:14:27,320 --> 00:14:30,570
פונקציה שהוא הולך להחזיר ערך, כפי שאנו טוענים.

238
00:14:30,570 --> 00:14:32,220
זה הולך לתת לך בחזרה int.

239
00:14:32,220 --> 00:14:34,460
ולכן אם אתם חושבים נפשיים שזה יקרה,

240
00:14:34,460 --> 00:14:38,190
כשאני מקליד ב99, GetInt מחזיר את המספר 99,

241
00:14:38,190 --> 00:14:41,840
ולכן רעיוני, שזה כאילו הקוד שלי היה למעשה זה.

242
00:14:41,840 --> 00:14:45,950
אז אם 99 הם אכן גדול מ 0, אז תודה הופכת אמיתית,

243
00:14:45,950 --> 00:14:50,810
אז קו 25 מבין אווה, סיים כי אני עכשיו אסירת תודה,

244
00:14:50,810 --> 00:14:53,970
ובקו 26, אנחנו פשוט אומרים, "תודה על המספר החיובי!"

245
00:14:53,970 --> 00:14:55,960
כל זה קרה להיות.

246
00:14:55,960 --> 00:14:59,140
עכשיו בואו נעשה סוכר תחבירי קל כאן, כביכול.

247
00:14:59,140 --> 00:15:04,670
בואו נראה אם ​​אנחנו יכולים לנקות את קו 25 זה עם גרסה שלישית ואחרונה זה בpositive3.

248
00:15:04,670 --> 00:15:13,600
>> שים לב ההבדל היחיד כרגע הוא מה שורת הקוד? >> [תלמיד] 25. >> [מלאן] כן, 25.

249
00:15:13,600 --> 00:15:17,680
ואנחנו כבר לא ממש ראינו את הטריק הזה עדיין, אבל אנחנו לא רואים את סימן הקריאה ביום שני,

250
00:15:17,680 --> 00:15:21,070
אשר מציין מה? >> [תלמיד] לא. לא >> או שלילה.

251
00:15:21,070 --> 00:15:23,510
אז קח את הערך בוליאני ולהעיף את הערך שלו.

252
00:15:23,510 --> 00:15:25,810
האמת הופכת להיות שקר, שקר הופך להיות אמת.

253
00:15:25,810 --> 00:15:30,420
אז כך, אני הייתי מציע, היא אפילו קצת יותר אינטואיטיבית דרך של כתיבת הקוד

254
00:15:30,420 --> 00:15:33,430
כי אני עדיין לאתחל מודה לשקר, אני עדיין עושה את הדברים הבאים,

255
00:15:33,430 --> 00:15:36,010
אני מודה לנכון לקבוע בבוא העת,

256
00:15:36,010 --> 00:15:40,880
אבל עכשיו אתה יכול באמת רק לתרגם את הקוד הזה השאיר מילולי לימין,

257
00:15:40,880 --> 00:15:45,630
בזמן (תודה!); בגלל נקודת מפץ או קריאה מציינת את הרעיון של לא,

258
00:15:45,630 --> 00:15:47,580
זאת תוך לא אסיר תודה.

259
00:15:47,580 --> 00:15:49,900
אז שוב, אנו לא הצגנו כל מושגים חדשים כשלעצמה.

260
00:15:49,900 --> 00:15:53,730
דברנו על Booleans אחורי כששחקנו עם שריטה,

261
00:15:53,730 --> 00:15:56,720
אבל עכשיו אני מבין שאנחנו פשוט יכולים להתחיל לכתוב את הקוד שלנו בדרכים רבות ושונות.

262
00:15:56,720 --> 00:16:01,060
אז במיוחד בpset1 אם אתה סוג של נאבק כדי להבין את הדרך לכתוב איזה תכנית,

263
00:16:01,060 --> 00:16:04,340
סיכויים הם לך מזל, כי לא יכול להיות כל מספר של פתרונות

264
00:16:04,340 --> 00:16:06,110
שיכול לקרות בעת.

265
00:16:06,110 --> 00:16:10,500
לדוגמה, זה רק 3 לאפילו הפשוט ביותר של תוכניות. בסדר.

266
00:16:10,500 --> 00:16:14,200
ועכשיו נזכר ביום שני יצאנו בנימה זו עם ערכים לחזור.

267
00:16:14,200 --> 00:16:18,450
אז בפעם הראשונה שכתבנו תכנית שלא רק לי עיקרי;

268
00:16:18,450 --> 00:16:22,550
יש לו גם פונקציה מותאמת אישית משלה שכתבתי כאן.

269
00:16:22,550 --> 00:16:26,810
אז בקו 31 דרך 34 שהתקנתי את פונקצית קובייה.

270
00:16:26,810 --> 00:16:30,240
זה לא מורכב. זה פשוט * * במקרה זה.

271
00:16:30,240 --> 00:16:34,750
אבל מה חשוב בזה הוא שאני לוקח את הקלט בצורה של

272
00:16:34,750 --> 00:16:39,180
ואני מחזיר פלט בצורה של * *.

273
00:16:39,180 --> 00:16:43,560
אז עכשיו יש לי את היכולת, הרבה כמו שהייתי עם prinf לבד,

274
00:16:43,560 --> 00:16:47,240
לקרוא לפונקציה זו על ידי קריאה לפונקצית הקובייה.

275
00:16:47,240 --> 00:16:51,970
>> ופונקצית הקובייה לוקחת קצת קלט, ופונקצית הקובייה מחזירה חלק פלט.

276
00:16:51,970 --> 00:16:56,960
לעומת זאת, printf פשוט עשה משהו.

277
00:16:56,960 --> 00:17:00,840
זה לא החזיר דבר שחשובים ל, למרות שכפי שצד זה להחזיר ערך;

278
00:17:00,840 --> 00:17:03,110
בדרך כלל אתה פשוט להתעלם ממנו.

279
00:17:03,110 --> 00:17:06,510
Printf פשוט עשה משהו. זה היה תופעת לוואי של הדפסה על גבי המסך.

280
00:17:06,510 --> 00:17:11,770
לעומת זאת כאן, יש לנו את פונקצית הקובייה, שלמעשה מחזירה משהו.

281
00:17:11,770 --> 00:17:15,520
אז למי שמכיר את זה, שזה רעיון פשוט למדי.

282
00:17:15,520 --> 00:17:19,640
אבל עבור אלה פחות מכירים את הרעיון הזה של העברה בתשומות ותפוקות מקבלות בחזרה,

283
00:17:19,640 --> 00:17:21,950
בואו ננסה פשוט פשוט סופר משהו.

284
00:17:21,950 --> 00:17:25,490
האם מישהו בנוח לבוא לבמה לזמן קצר?

285
00:17:25,490 --> 00:17:28,040
אתה צריך להיות נוח עם מצלמה עליך גם. כן? אוקיי.

286
00:17:28,040 --> 00:17:31,240
מה שמך? >> [תלמיד] קן. >> קן. בסדר. קן, יעלה למעלה.

287
00:17:31,240 --> 00:17:35,050
קן הולך להיות פונקציה של מיני סוגים.

288
00:17:35,050 --> 00:17:38,720
בואו נלך קדימה ולעשות את זה. בואו תחביב קטן.

289
00:17:38,720 --> 00:17:42,260
נע מאוד. ברוכים באים למרכז במה. בסדר.

290
00:17:42,260 --> 00:17:46,640
בואו נכנסתי ללחצן זה כאן. בסדר.

291
00:17:46,640 --> 00:17:49,820
אז הנה יש לך לוח מודרני,

292
00:17:49,820 --> 00:17:53,470
ומה שאני הוא הפונקציה העיקרית, למשל,

293
00:17:53,470 --> 00:17:56,460
ואין לי אייפד ביד שלי.

294
00:17:56,460 --> 00:17:59,710
>> אני לא ממש זוכר איך - ובכן, אני לא יכול להגיד את זה.

295
00:17:59,710 --> 00:18:02,480
אני לא באמת צריך את כתב יד טוב,

296
00:18:02,480 --> 00:18:05,520
וכל כך ולכן אני רוצה שלהדפיס משהו על המסך שלי.

297
00:18:05,520 --> 00:18:12,040
אני מתנהג בתכנית הראשית, ואני הולך יש לך להגיד את זה

298
00:18:12,040 --> 00:18:16,720
על ידי כתיבתו בהתחלת עופי ואז עובר לך קלט.

299
00:18:16,720 --> 00:18:20,400
אז אווילי ככל שהתרגיל הזה הוא, הרעיון של פונקציות וקוראים לפונקציה

300
00:18:20,400 --> 00:18:22,400
וחוזר לתפקד באמת מסתכם זו.

301
00:18:22,400 --> 00:18:26,260
אני עיקרי, יש לי רק כתבתי משהו printf, במרכאות על המסך,

302
00:18:26,260 --> 00:18:29,110
אני מפעיל תכנית זו, וברגע שprintf מקבל נקרא,

303
00:18:29,110 --> 00:18:32,880
זה לוקח טיעון אחד או פרמטר אחד לפעמים בין מרכאות כפולות.

304
00:18:32,880 --> 00:18:35,880
הנה הטיעון הזה. אני מעביר אותו לקן.

305
00:18:35,880 --> 00:18:39,020
הוא קופסה שחורה כתבה חלק לפני מספר שנים

306
00:18:39,020 --> 00:18:41,510
כנראה שרק יודע כיצד להדפיס דברים על המסך.

307
00:18:41,510 --> 00:18:43,150
אז לבצע.

308
00:18:49,280 --> 00:18:51,280
זה לא רע. טוב מאוד.

309
00:18:51,280 --> 00:18:55,510
אז עכשיו קן נעשה ביצוע. האם הוא צריך למסור לי משהו בחזרה?

310
00:18:55,510 --> 00:18:57,470
לא שראינו עד כה.

311
00:18:57,470 --> 00:19:00,460
שוב, printf אין בעצם להחזיר מספר, אבל אנחנו הולכים להתעלם כי לעת עתה

312
00:19:00,460 --> 00:19:03,470
כי אנחנו אף פעם לא השתמשנו בו. אז זהו זה לקן.

313
00:19:03,470 --> 00:19:08,580
ואז עכשיו ראשי לוקח על שליטה בתכנית שוב

314
00:19:08,580 --> 00:19:11,060
כי קו זה של קוד, printf, נעשה ביצוע.

315
00:19:11,060 --> 00:19:14,050
ואנחנו הולכים על הדרך שלנו, ביצוע כל קווים אחרים נמצאים שם.

316
00:19:14,050 --> 00:19:17,320
אז עכשיו בואו ננסה דוגמה קצת שונה.

317
00:19:17,320 --> 00:19:24,940
הפעם כאן בואו לנקות את המסך ראשון, והפעם אנחנו נעשה את הפונקציה עקוב,

318
00:19:24,940 --> 00:19:27,080
אבל הפעם, אני מצפה ערך תפוקה.

319
00:19:27,080 --> 00:19:29,180
>> אז בואו נלך ותעשה את זה.

320
00:19:29,180 --> 00:19:35,790
עכשיו יש לי שורת הקוד שאומרת x מקבל קובייה של x.

321
00:19:41,370 --> 00:19:46,370
שורת הקוד, כזכור, נראית כך: x = קובייה (x);

322
00:19:46,370 --> 00:19:50,930
אז איך זה הולך לעבוד? בואו נלך קדימה ולתת לך מסך לבן שוב.

323
00:19:50,930 --> 00:19:54,070
אני מתכוון לכתוב עכשיו את הערך של x,

324
00:19:54,070 --> 00:20:01,400
אשר ברגע זה בזמן קורה להיות, יניח, 2 לשמור את זה פשוט.

325
00:20:01,400 --> 00:20:06,150
שכתבתי על פיסת נייר הערך של 2, שהוא x הערך שלי.

326
00:20:06,150 --> 00:20:10,920
אני מעביר אותו לקן. >> ואני רק כותב את התשובה? >> כן, בואו פשוט נכתוב את התשובה.

327
00:20:12,760 --> 00:20:18,940
אוקיי. ועכשיו הוא צריך להחזיר לי משהו. מושלם. נחמד רצף.

328
00:20:18,940 --> 00:20:23,120
אז עכשיו הוא מחזיר לי את הערך של 8 במקרה זה, ומה אני עושה עם זה?

329
00:20:23,120 --> 00:20:28,250
למעשה - בואו לראות, לקבל זכות זו. מה אני הולך לעשות עם זה?

330
00:20:28,250 --> 00:20:33,440
עכשיו אני הולך לקחת את הערך הזה ובעצם לאחסן אותו באותם הקטעים האלה בזיכרון.

331
00:20:33,440 --> 00:20:35,170
אבל תשים לב שאני סוג של נאבק כאן.

332
00:20:35,170 --> 00:20:38,210
אני קצת מבולבל כי לאן אני בעצם לכתוב את הערך של x,

333
00:20:38,210 --> 00:20:43,150
כי מה בדיוק עשיתי הוא קן יד פיזית פיסת נייר שהיה לו ערך 2,

334
00:20:43,150 --> 00:20:46,590
שהיה x, ואכן, זה בדיוק מה שקרה.

335
00:20:46,590 --> 00:20:50,210
אז מתברר שכשאתה קורא לפונקציה ואתה עובר בויכוח

336
00:20:50,210 --> 00:20:53,290
כמו שלום, עולם או שאתה עובר בטיעון כמו 2,

337
00:20:53,290 --> 00:20:57,110
בדרך כלל, אתה עובר בעותק של ויכוח.

338
00:20:57,110 --> 00:21:00,730
וכך בדיוק כפי שכתבתי את המספר 2 כאן ומסרתי אותו לקן,

339
00:21:00,730 --> 00:21:04,720
שיש אומר שעדיין יש לי עותק של הערך 2 במקום

340
00:21:04,720 --> 00:21:08,890
כי אכן, עכשיו אחרי שקבלתי בחזרה את הערך 8, אני צריך לחזור בזכרון RAM

341
00:21:08,890 --> 00:21:12,130
ובעצם לכתוב ירידה של 8 שבו היה לי פעם המספר 2.

342
00:21:12,130 --> 00:21:16,950
אז מבחינה ויזואלית, זוכר את המושג הזה של עובר ב, פשוטו כמשמעו, עותק של הערך.

343
00:21:16,950 --> 00:21:20,780
>> קן עושה את הדבר שלו, מחזיר לי משהו - במקרה זה ערך כמו 8 -

344
00:21:20,780 --> 00:21:24,980
ואז אני חייב לעשות משהו עם זה ערך אם אני רוצה לשמור על הסביבה.

345
00:21:24,980 --> 00:21:29,650
אז כל זה יחזור להיות מוכר מדי לפני זמן רב.

346
00:21:29,650 --> 00:21:34,920
תודה רבה לך על זה הדגמה כאן, קן. [מחיאות כפות]

347
00:21:34,920 --> 00:21:36,920
עשה טוב מאוד.

348
00:21:36,920 --> 00:21:42,690
בואו לראות איך שסופו של דבר מתייחס לחלק מהפונקציה קוראה שאנחנו עושים כאן.

349
00:21:42,690 --> 00:21:47,910
תן לי ללכת קדימה ולהחזיר אותנו לדוגמא עקוב כאן.

350
00:21:47,910 --> 00:21:53,300
שים לב שאם אנחנו רוצים באמת להתחיל לקחת את זה עוד יותר,

351
00:21:53,300 --> 00:21:57,570
אנחנו הולכים צריכים להיות מודעים לעובדה שהמספר x המועבר כאן

352
00:21:57,570 --> 00:22:01,530
שונה ממה באמת מועבר לפונקציה.

353
00:22:01,530 --> 00:22:05,880
אז שוב, זה לעבור על עותק הוא הולך להיות די שייך ברגע.

354
00:22:05,880 --> 00:22:09,580
בואו נסתכל על משהו שלא ממש עובד נכון עדיין.

355
00:22:09,580 --> 00:22:13,250
אני הולך קדימה, לפתוח למשל מרכבה שלישית, שלוקה בטבע,

356
00:22:13,250 --> 00:22:18,550
וזה נקרא buggy3 והוא מיישם פונקצית החלפה.

357
00:22:18,550 --> 00:22:25,110
כאן יש לנו פונקציה עיקרית שx ו-y מאותחלים באופן שרירותי 1 ו 2, בהתאמה.

358
00:22:25,110 --> 00:22:27,700
אנחנו יכולים להשתמש בGetInt, אבל אנחנו פשוט צריכים תרגיל פשוט,

359
00:22:27,700 --> 00:22:30,170
אז זה קידוד קשיח כמו 1 ו 2.

360
00:22:30,170 --> 00:22:35,340
בקווי 21 ו 22, אנחנו כנראה להדפיס את X ו-Y, 1 בכל שורה.

361
00:22:35,340 --> 00:22:39,720
ואז ב 23 לקו, אני טוען שאני מחליף את הערכים הללו, נקודה, נקודה, נקודה.

362
00:22:39,720 --> 00:22:44,170
כנראה שאני קורא לפונקציה בקו 24 שנקראה החלפה לוקחת 2 טענות.

363
00:22:44,170 --> 00:22:48,300
זה חוקי לחלוטין לפונקציות לקחת 2 טיעונים. ראינו printf לעשות את זה כבר.

364
00:22:48,300 --> 00:22:51,830
>> אז ההחלפה כנראה לוקחת X ו-Y, וכפי שהשם מרמז,

365
00:22:51,830 --> 00:22:54,670
אני מקווה שזה הולך להחליף 2 ערכים אלה.

366
00:22:54,670 --> 00:23:00,090
אז אני טוען שעל קו 25 "החליפו!" ואני להדפיס מחדש את x ו-y

367
00:23:00,090 --> 00:23:03,070
בהנחה שהם אכן הוחלפו.

368
00:23:03,070 --> 00:23:06,080
אבל אם אני באמת להפעיל תכנית זו - תן לי לפתוח את חלון מסוף,

369
00:23:06,080 --> 00:23:09,860
תנו לי לעשות buggy3 - כפי שהשם מרמז, זה לא הולך להסתיים בטוב

370
00:23:09,860 --> 00:23:15,770
כי כשאני על Enter, תבחין כי x הוא 1, y הוא 2,

371
00:23:15,770 --> 00:23:19,420
ובכל זאת בסוף התכנית, הם עדיין, למעשה, את אותו הדבר.

372
00:23:19,420 --> 00:23:22,960
זאת בהתבסס על ההפגנה רק עכשיו עם קן, מה בעצם קורה?

373
00:23:22,960 --> 00:23:28,710
בואו לצלול לתוך פונקצית עסקה זו. זה סופר קצר. זה רק כמה שורות של קוד ארוך.

374
00:23:28,710 --> 00:23:34,520
אבל מה הבעיה הבסיסית המבוססת על הסיפור פשוט ספר כאן עם קן?

375
00:23:34,520 --> 00:23:36,670
למה החלפה שבורה?

376
00:23:36,670 --> 00:23:39,660
[תלמיד] אתה אחסון להעתקה, לא משתנה.

377
00:23:39,660 --> 00:23:43,980
בדיוק. אנחנו אחסון להעתקה, לא משתנים עצמו.

378
00:23:43,980 --> 00:23:47,170
במילים אחרות, ככל הנראה ההחלפה לוקחת 2 טענות, int,

379
00:23:47,170 --> 00:23:49,370
וזה נקרא באופן שרירותי וב,

380
00:23:49,370 --> 00:23:54,420
וכאן אני כבר עברתי בX ו-Y, שהם 1 ו 2 בהתאמה,

381
00:23:54,420 --> 00:23:58,770
אבל אני לא ממש עובר בx, אני לא ממש עובר בy,

382
00:23:58,770 --> 00:24:01,450
אני מעביר עותק של x ו עותק של Y.

383
00:24:01,450 --> 00:24:04,510
זה כמעט כאילו אתה להעתיק ולהדביק לתוך ההחלפה

384
00:24:04,510 --> 00:24:07,810
את הערכים שאתה רוצה שזה בעצם מניפולציה.

385
00:24:07,810 --> 00:24:14,480
אז אם זה מצב, אז כאשר אני תחילת תכנית ביצוע קו 35 36,

386
00:24:14,480 --> 00:24:18,650
כשאני מגיע לקו 37, בנקודה זו בסיפור, מהו הערך של a?

387
00:24:21,040 --> 00:24:25,050
בנקודה זו בסיפור, קו 37, מהו הערך של בנקודה זו? >> [תלמיד] 1.

388
00:24:25,050 --> 00:24:29,280
[מלאן] זה פשוט צריך להיות 1, נכון, כי x היה מועבר כטענה הראשונה,

389
00:24:29,280 --> 00:24:33,080
ופונקציה זו רק באופן שרירותי קוראה הטיעון הראשון שלה.

390
00:24:33,080 --> 00:24:38,200
כמו כן הוא y הטענה השנייה, וזה רק באופן שרירותי מתקשר ב הטענה השנייה.

391
00:24:38,200 --> 00:24:40,990
>> דיכוטומיה זו היא למעשה די פשוט הסבירה. תחשוב על זה.

392
00:24:40,990 --> 00:24:43,320
אף אחד מאתנו לא פגש האדם שכתב printf,

393
00:24:43,320 --> 00:24:50,770
כך בוודאי, הוא או שאין לה מושג מה משתנינו 30 שנים מאוחר יותר הם הולכים להיות שם.

394
00:24:50,770 --> 00:24:56,650
אז צריך להיות הבחנה בין מה שאתם קוראים משתנים בפונקציות שאתה כותב

395
00:24:56,650 --> 00:25:02,080
ומה שאתה מכנה משתנים בפונקציות שקוראים או משתמשים.

396
00:25:02,080 --> 00:25:05,340
אז במילים אחרות, שכתבתי משתנים שלי בתור X ו-Y,

397
00:25:05,340 --> 00:25:08,890
אבל אם מישהו אחר כתב את פונקצית ההחלפה, הוא או היא בהחלט לא הייתי יודע

398
00:25:08,890 --> 00:25:10,690
מה המשתנים שלי הולכים להיקרא,

399
00:25:10,690 --> 00:25:13,830
כל כך מבין שזו הסיבה שיש לך דואליות זו של שמות.

400
00:25:13,830 --> 00:25:16,750
מבחינה טכנית, אני יכול לעשות את זה במקרה,

401
00:25:16,750 --> 00:25:20,080
אבל הם עדיין יהיו מועברים כהעתקים.

402
00:25:20,080 --> 00:25:23,650
זו תהיה סתם צירוף מקרים טהור מבחינה אסתטית, אם כי מי שכתב החלפה

403
00:25:23,650 --> 00:25:26,150
השתמש באותם שמות.

404
00:25:26,150 --> 00:25:32,370
לכן בשלב זה בסיפור, קו 37, הוא 1, b הוא 2, ועכשיו אני ממשיך להחליף אותם.

405
00:25:32,370 --> 00:25:34,900
קודם כל, תן לי לעשות את זה דווקא הרבה יותר פשוט.

406
00:25:34,900 --> 00:25:36,690
אני לא יודע מה 3 הקווים האלה של קוד עושים.

407
00:25:36,690 --> 00:25:41,210
תן לי רק לעשות את זה: ב =; = b; עשה.

408
00:25:41,210 --> 00:25:44,690
למה זה שבור, באופן הגיוני?

409
00:25:46,490 --> 00:25:48,900
זה סוג של דבר אינטואיטיבי, נכון?

410
00:25:48,900 --> 00:25:52,560
אז הופך b ו b הופך,

411
00:25:52,560 --> 00:25:57,730
אבל הבעיה היא שברגע שמבצע קו 37, מה הערך של A ו-B?

412
00:25:57,730 --> 00:26:03,410
אותו הדבר, 1, בגלל שיש לך דפוק, אם אפשר לומר כך, ששינית ב שווה.

413
00:26:03,410 --> 00:26:08,890
אז ברגע הקו 37 בצע, זה נהדר, עכשיו יש לך 2 עותקים של המספר 1

414
00:26:08,890 --> 00:26:13,350
בתוך פונקציה זו, אז כשאתה אומר בקו 38 = b,

415
00:26:13,350 --> 00:26:17,640
סוג של אתה נדפק בגלל שאתה רק הקצאת 1 על 1.

416
00:26:17,640 --> 00:26:20,580
סוג שלך אבד את הערך שאכפת לך.

417
00:26:20,580 --> 00:26:23,220
אז בגרסה המקורית של זה, שים לב למה שעשיתי.

418
00:26:23,220 --> 00:26:26,850
במקום זאת נאלצה שורה שלישית של קוד שנראית כמו זה.

419
00:26:26,850 --> 00:26:28,580
אני מצהיר משתנה זמני.

420
00:26:28,580 --> 00:26:32,170
>> Tmp הוא שם נפוצים מאוד למשתנה זמנית, וזה int

421
00:26:32,170 --> 00:26:34,580
כי יש לו להשתוות למה שאני רוצה לעשות עותק של.

422
00:26:34,580 --> 00:26:39,770
אני לאחסן עותק של חלק פנימי של tmp, לכן ברגע קו 37 בצע,

423
00:26:39,770 --> 00:26:45,860
הערך שלו - סימון שפיות מהירה - 1, את הערך של b הוא 2,

424
00:26:45,860 --> 00:26:48,970
והערך של tmp הוא גם 1.

425
00:26:48,970 --> 00:26:52,060
אז עכשיו אני מבצע את הקו 38.

426
00:26:52,060 --> 00:27:00,540
ברגע קו 38 מבצע, מקבל את הערך של b. והייתה ב 2, אז עכשיו הוא 2.

427
00:27:00,540 --> 00:27:05,210
לכן בשלב זה בסיפור, הם 2, b הוא 2, וtmp הוא 1,

428
00:27:05,210 --> 00:27:11,060
אז עכשיו מבחינה לוגית, אנחנו יכולים רק הערך של tmp פלופ לb ואנחנו נעשינו.

429
00:27:11,060 --> 00:27:12,800
אז ככה פתר את הבעיה.

430
00:27:12,800 --> 00:27:17,720
למרבה הצער, כאשר אני מפעיל את התכנית בצורה הזאת, זה לא ממש להחליף את כל ערכים.

431
00:27:17,720 --> 00:27:20,100
אבל שיהיו ברור, למה?

432
00:27:23,660 --> 00:27:26,450
אני תקנתי את הבעיה הלוגית מרק לפני רגע,

433
00:27:26,450 --> 00:27:31,020
אבל שוב, אם אני מפעיל תכנית זו, x ו-y יישארו ללא שינוי

434
00:27:31,020 --> 00:27:33,310
בסוף הביצוע של התכנית.

435
00:27:33,310 --> 00:27:37,220
[הערת תלמיד לא נשמעה] >> יש לנו לא חזרתי שום דבר, אז זה נכון.

436
00:27:37,220 --> 00:27:39,670
אבל מתברר שיש קצת בעיה כאן כי עד כה,

437
00:27:39,670 --> 00:27:44,170
הדבר היחיד שהצלחנו לחזור זה דבר אחד, וזה הוא הגבלה של ג

438
00:27:44,170 --> 00:27:49,070
אתה יכול לחזור רק באמת ערך אחד, ובמקרה זה אני די תקוע כאן

439
00:27:49,070 --> 00:27:53,310
כי אני יכול להחזיר את הערך החדש של X או שאני יכול להחזיר את הערך החדש של Y,

440
00:27:53,310 --> 00:27:55,190
אבל אני רוצה את שניהם בחזרה.

441
00:27:55,190 --> 00:27:58,650
אז חזר לא פתרון פשוט כאן.

442
00:27:58,650 --> 00:28:01,710
אבל הבעיה מהותית היא למה? מה אנחנו בעצם להתחלף?

443
00:28:01,710 --> 00:28:04,190
[תלמיד] וכן ב. >> ב.

444
00:28:04,190 --> 00:28:08,230
אבל וb הם עותקים של X ו-Y, מה שאומר שאנחנו רק עשינו את כל העבודה הזו,

445
00:28:08,230 --> 00:28:11,650
אנחנו פשוט בילינו 3 דקות מדברים על הפונקציה וההחלפה כל 3 מהמשתנים הללו,

446
00:28:11,650 --> 00:28:15,420
וזה נהדר, תקין לגמרי בבידוד,

447
00:28:15,420 --> 00:28:20,740
אבל ההיקף של b ורק בשורות אלה כאן.

448
00:28:20,740 --> 00:28:24,790
>> אז בדיוק כמו ללולאה, אם תכריז שלם אני בתוך ללולאה,

449
00:28:24,790 --> 00:28:28,760
באופן דומה, אם אתה מצהיר וב פנימי של פונקציה שכתבת,

450
00:28:28,760 --> 00:28:33,320
הם כבר בפנים תקפים רק שבתפקיד, מה שאומר ברגע שההחלפה נעשית ביצוע

451
00:28:33,320 --> 00:28:38,470
ואנחנו הולכים מקו 24-25 קו, x ו-y לא השתנו בכלל.

452
00:28:38,470 --> 00:28:42,790
אתה פשוט בזבזת המון זמן בחילופי עותקים של משתנים.

453
00:28:42,790 --> 00:28:47,010
אז מתברר שהפתרון לזה הוא למעשה אינו ברור.

454
00:28:47,010 --> 00:28:50,670
זה לא ממש מספיק כדי להחזיר ערכים כי אנחנו יכולים להחזיר ערך 1 בלבד,

455
00:28:50,670 --> 00:28:53,470
ואני באמת רוצה להחליף גם x ו-y באותו הזמן,

456
00:28:53,470 --> 00:28:55,210
אז אנחנו הולכים לעשות כדי לחזור לזה.

457
00:28:55,210 --> 00:29:01,020
אבל לעת עתה, מבין שהבעיה נובעת ביסודו מהעובדה ושb הם עותקים

458
00:29:01,020 --> 00:29:03,630
והם בהיקפם.

459
00:29:03,630 --> 00:29:05,050
בואו ננסה לפתור את זה בדרך כלשהי.

460
00:29:05,050 --> 00:29:11,250
תן לי לחזור לכאן בעצם לגלול ולפתוח, יניח, גרסה רביעית של זה, buggy4.

461
00:29:11,250 --> 00:29:13,370
מה עם זה?

462
00:29:13,370 --> 00:29:17,810
זו בעיה דומה אך פשוטה יותר להסתכל לפני שאנחנו לוקחים דקירה בפתרונו.

463
00:29:17,810 --> 00:29:24,190
תכנית זו נקראת תוספת, וכנראה שזה מאתחל שלם x עד 1 בקו 18.

464
00:29:24,190 --> 00:29:28,150
אז אני טוען x הוא 1, אז אני טוען "הגדלה ..."

465
00:29:28,150 --> 00:29:33,730
אז אני קורא לתוספת, אבל אז בקווי 22 ו 23, אני טוען את זה כבר בהפרש קבוע,

466
00:29:33,730 --> 00:29:40,220
אני טוען x הוא עכשיו מה שזה - 2, ככל הנראה - אך תכנית זו היא כרכרה.

467
00:29:40,220 --> 00:29:42,610
מה הבעיה?

468
00:29:43,440 --> 00:29:50,160
כן. >> [תגובת תלמיד לא נשמעה] >> בדיוק.

469
00:29:50,160 --> 00:29:52,490
אז x הוכרז, כמובן, בקו 18.

470
00:29:52,490 --> 00:29:54,700
כלומר בתוך סוגריים המסולסלים של העיקרית.

471
00:29:54,700 --> 00:29:58,440
אז התשובה הפשוטה היא, שכל עוד x קיים כאן,

472
00:29:58,440 --> 00:30:03,930
זה לא קיים בקו 32, ולכן תכנית זו תהיה למעשה אפילו לא לקמפל.

473
00:30:03,930 --> 00:30:07,940
המהדר כשאני מנסה הידור קוד זה הולך לצעוק עליי

474
00:30:07,940 --> 00:30:14,100
על איזה מזהה או משהו דומה לזה לא מוצהר. למעשה, בואו ננסה.

475
00:30:14,100 --> 00:30:18,470
זה עושה buggy4. זה מה שיש.

476
00:30:18,470 --> 00:30:22,110
שימוש ב" x "מזהה לא מוצהר בקו 32.

477
00:30:22,110 --> 00:30:25,580
ובעצם, בואו אהיה יותר מפורש כאן היום כדי שזה שימושי

478
00:30:25,580 --> 00:30:27,580
בשעתי עבודה ובבית.

479
00:30:27,580 --> 00:30:29,300
>> שים לב שזה קצת כתוב ולא פרש.

480
00:30:29,300 --> 00:30:37,270
אבל העובדה שיש קלאנג צעקה עלינו ואומר buggy4.c: 32:5, היא באמת שימושי.

481
00:30:37,270 --> 00:30:42,050
זה אומר שהטעות היא בקו 32 בעמדת הדמות 5.

482
00:30:42,050 --> 00:30:46,700
אז 1, 2, 3, 4, 5. זה, למעשה, שבו הבעיה היא.

483
00:30:46,700 --> 00:30:49,790
וגם, מדי, יש לזכור בשעתי עבודה ובבית, יש לי מזל כאן.

484
00:30:49,790 --> 00:30:52,990
יש לי טעות אחת. זה הולך להיות קל יחסית לתיקון.

485
00:30:52,990 --> 00:30:55,990
אבל אם אתה מקבל את כל מסך מלא בהודעות שגיאה מכריעות,

486
00:30:55,990 --> 00:31:00,330
שוב להבין שאחד התחתון יכול להיות רק סימפטום לאחד העליון ביותר.

487
00:31:00,330 --> 00:31:03,450
אז תמיד לרדוף אחרי הבאגים שלכם מלמעלה למטה

488
00:31:03,450 --> 00:31:05,820
משום שיש יכול להיות רק השפעת שרשרת דייזי

489
00:31:05,820 --> 00:31:09,240
כי הוא טוען שיש לך את הדרך לבעיות יותר מאשר אתה באמת כן.

490
00:31:09,240 --> 00:31:15,150
אז איך אפשר לתקן את זה אם המטרה שלי היא להגדיל x? >> [תלמיד] הפוך x הגלובלי.

491
00:31:15,150 --> 00:31:17,060
אוקיי, אז אנחנו יכולים לעשות את x הגלובלי.

492
00:31:17,060 --> 00:31:20,480
בואו ניקח את קיצור הדרך שעליו קודם לכן הזהיר, אבל לעזאזל, אנחנו רק צריכים פתרון מהיר,

493
00:31:20,480 --> 00:31:25,730
אז בואו רק נאמר x int עד כאן. זה הופך את x הגלובלי.

494
00:31:25,730 --> 00:31:31,800
אז עכשיו ראשי יש גישה אליו ויש תוספת גישה אליו,

495
00:31:31,800 --> 00:31:34,110
ואז תן לי להמשיך ולעבד את זה עכשיו.

496
00:31:34,110 --> 00:31:37,630
הפוך buggy4, Enter. נראה לקמפל עכשיו.

497
00:31:37,630 --> 00:31:41,230
בואו לרוץ buggy4. ונראה ממש לעבוד.

498
00:31:41,230 --> 00:31:45,150
זה אחד מהדברים האלה שיעשו כמו שאני אומר, לא כמוני,

499
00:31:45,150 --> 00:31:47,010
כמו שרק שעשיתי כאן, כי באופן כללי,

500
00:31:47,010 --> 00:31:50,440
התוכניות שלנו הולכות לקבל הרבה יותר מעניין והרבה יותר מזה,

501
00:31:50,440 --> 00:31:56,390
אם הפתרון שלך לבעיות של החיים הוא פשוט לשים את כל המשתנים בחלק העליון של הקובץ שלך ו,

502
00:31:56,390 --> 00:31:59,690
מהר מאוד תוכניות מקבלות איום קשות לניהול.

503
00:31:59,690 --> 00:32:02,190
זה נהיה קשה יותר לחשוב על שמות משתנים חדשים,

504
00:32:02,190 --> 00:32:05,240
זה נהיה קשה יותר להבין מה משתנה עושה מה,

505
00:32:05,240 --> 00:32:08,460
וכך באופן כללי, זה לא פתרון טוב.

506
00:32:08,460 --> 00:32:10,030
אז בואו נעשה את זה טוב יותר.

507
00:32:10,030 --> 00:32:12,160
אנחנו לא רוצים להשתמש במשתנה גלובלית כאן.

508
00:32:12,160 --> 00:32:16,240
>> אני רוצה להגדיל x, כך שיכולתי כמובן -

509
00:32:16,240 --> 00:32:18,670
בסופו של היום, זה סוג של סיפור טיפשי כי אנחנו פשוט לעשות את זה -

510
00:32:18,670 --> 00:32:24,450
אבל אם אני לא ידעתי על שהמפעיל או שאני לא נתתי לי לשנות אותו בראשי עצמו,

511
00:32:24,450 --> 00:32:30,730
איך עוד אני יכול ליישם קן לכאן הפעם לא קובייה אבל כדי להגדיל?

512
00:32:31,380 --> 00:32:33,190
איך אני משנה את זה כאן? כן.

513
00:32:33,190 --> 00:32:38,480
[תלמיד] Pass בx ואז לחזור [לא ברור] >> אוקיי, טוב.

514
00:32:38,480 --> 00:32:41,900
אז למה שאני לא אעבור בx ולאחר מכן ולא להחזיר אותו,

515
00:32:41,900 --> 00:32:44,870
למה שאני לא פשוט לחזור X + 1.

516
00:32:44,870 --> 00:32:47,710
עוד כמה דברים צריכים להשתנות פה. אני על המסלול הנכון.

517
00:32:47,710 --> 00:32:49,770
מה עוד אני צריך לצבוט? מישהו אחר. כן.

518
00:32:49,770 --> 00:32:51,740
[תגובת תלמיד לא נשמעה]

519
00:32:51,740 --> 00:32:54,730
אני צריך לשנות את סוג ההחזרה של תוספת, כי זה לא לבטל.

520
00:32:54,730 --> 00:32:57,780
אין לה כל החלל מוחזר, אבל ברור שעכשיו זה הוא,

521
00:32:57,780 --> 00:32:59,830
כך זה צריך לשנות ל-- >> [תלמיד] int.

522
00:32:59,830 --> 00:33:02,740
int להיות בקנה אחד עם מה שאני מחזיר למעשה.

523
00:33:02,740 --> 00:33:05,180
עכשיו משהו אחר עדיין כרכרה כאן. כן.

524
00:33:05,180 --> 00:33:08,400
[תגובת תלמיד לא נשמעה] >> [מלאן] אז אני צריך להגדיל x?

525
00:33:08,400 --> 00:33:12,080
[תגובת תלמיד לא נשמעה] >> [מלאן] אה, אז אני צריך לעבור x.

526
00:33:12,080 --> 00:33:16,660
אז אני צריך לעשות את זה כאן. >> [הערת תלמיד לא נשמעה]

527
00:33:16,660 --> 00:33:20,050
[מלאן] אז אב הטיפוס, אני צריך לשנות את זה כאן.

528
00:33:20,050 --> 00:33:22,930
אז זה צריך להיות int, זה חייב להיות -

529
00:33:22,930 --> 00:33:25,620
הממ, יש לי בעצם באג כאן למטה. בואו לתקן את זה ראשון.

530
00:33:25,620 --> 00:33:29,590
מה זה צריך להיות למעשה? זה חייב להיות משהו int.

531
00:33:29,590 --> 00:33:32,700
זה יכול להיות x, אבל בכנות, אם אתה מתחיל לקרוא את כל המשתנים x שלך,

532
00:33:32,700 --> 00:33:35,390
זה הולך לקבל פחות ופחות ברור מי הוא מי.

533
00:33:35,390 --> 00:33:39,560
>> אז בואו רק באופן שרירותי לבחור יום אמנה שונה עבור פונקציות העוזר שלי,

534
00:33:39,560 --> 00:33:41,940
את הפונקציות שאני כותב. אנחנו קוראים לזה, או שאנו יכולים לקרוא לזה -

535
00:33:41,940 --> 00:33:45,010
בואו נקרא לזה מספר להיות אפילו יותר מפורש.

536
00:33:45,010 --> 00:33:47,560
אז יש לי לחזור מה הוא המספר 1 ובנוסף,

537
00:33:47,560 --> 00:33:50,740
ועכשיו אני צריך לשנות שום דבר אחר 1 עד כאן ועוד דבר אחד כאן.

538
00:33:50,740 --> 00:33:54,350
מה יש לי לשינוי בקו 21 בפעם הראשונה? >> [תגובת תלמיד לא נשמעה]

539
00:33:54,350 --> 00:33:57,610
[מלאן] אני צריך להקצות אותו x. אני לא יכול פשוט לקרוא תוספת (x).

540
00:33:57,610 --> 00:34:01,960
אני צריך לזכור את התשובה על ידי שינוי הערך של x בצד השמאלי.

541
00:34:01,960 --> 00:34:04,680
ואף על פי x הוא עכשיו על ימין ועל שמאל, זה לגמרי בסדר

542
00:34:04,680 --> 00:34:08,860
משום שצד ימין מקבל להורג ראשון ואז מקבל נשר לתוך הדבר השמאלי -

543
00:34:08,860 --> 00:34:10,600
x במקרה זה.

544
00:34:10,600 --> 00:34:12,159
ואז לבסוף, זה קל לתקן עכשיו.

545
00:34:12,159 --> 00:34:17,230
זה פשוט צריך להתאים את מה שנמצא שם למטה, מספר int.

546
00:34:17,230 --> 00:34:20,570
אז כל חבורה של שינויים לתפקוד ממש טיפש

547
00:34:20,570 --> 00:34:24,420
אבל נציג שלנו יותר ויותר דברים שאתה רוצה לעשות.

548
00:34:24,420 --> 00:34:27,090
אז להפוך buggy4. כבר פשלתי איפשהו.

549
00:34:27,090 --> 00:34:30,139
הו, אלוהים שלי. חמש טעויות בתכנית 6-קו.

550
00:34:30,139 --> 00:34:35,690
אז מה רע בקו 18, דמות 5?

551
00:34:35,690 --> 00:34:39,610
אז יש לי להצהיר, int זה.

552
00:34:39,610 --> 00:34:41,920
בואו נראים. יש קבוצה שלמה של טעויות אחרות.

553
00:34:41,920 --> 00:34:47,010
הו, אלוהים שלי - 19, 18, 21 - אך שוב, בוא פשוט לנקות את המסך, L בקרה כאן,

554
00:34:47,010 --> 00:34:49,380
ושידור חוזר קלאנג.

555
00:34:49,380 --> 00:34:51,340
אז 5 בעיות הן שלמעשה רק 1.

556
00:34:51,340 --> 00:34:57,520
אז עכשיו בואו תרוצו buggy4, Enter. אוף, X כבר מוגדל בצורה נכונה.

557
00:34:57,520 --> 00:35:02,720
בסדר. כל שאלות על איך להגדיל מספרים? כן.

558
00:35:02,720 --> 00:35:09,870
[שאלת תלמיד לא נשמעה] >> שאלה טובה.

559
00:35:09,870 --> 00:35:14,220
איך זה שאני יכול פשוט לשנות את x למספר ואת התכנית תהיה לדעת באופן מיידי?

560
00:35:14,220 --> 00:35:16,200
>> שוב, לחשוב על זה כהפשטה זו.

561
00:35:16,200 --> 00:35:21,600
אז אם אני ראשי וקן הוא תוספת, בכנות, לא אכפת לי מה שקורא קן iPad שלו.

562
00:35:21,600 --> 00:35:26,570
לא אכפת לי מה שהוא מכנה כל דבר שיש לעשות עם יישומו של פונקציונליות זו.

563
00:35:26,570 --> 00:35:33,340
זה פירוט יישום שאני, ראשי, לא צריך אכפת.

564
00:35:33,340 --> 00:35:38,250
וכך פשוט לשנות אותו בעקביות הפנימית של הפונקציה - מספר כאן ומספר כאן -

565
00:35:38,250 --> 00:35:40,960
כל זה לוקח כל כך הרבה זמן כמו שההידור מחדש.

566
00:35:40,960 --> 00:35:44,180
זה קצת כמו שאם אתה חושב על רבים מאיתנו, אלה מכם עם רישיונות הנהיגה

567
00:35:44,180 --> 00:35:46,770
שמונע או אם אפילו שהוסעת במכונית,

568
00:35:46,770 --> 00:35:50,950
רובנו אין לי מושג איך עובדת מכונית מתחת למכסת המנוע.

569
00:35:50,950 --> 00:35:54,970
ופשוטו כמשמעו, אם אתה פותח את מכסה מנוע, רובנו - כולל אותי -

570
00:35:54,970 --> 00:35:56,940
לא הולך באמת לדעת מה אנחנו מסתכלים,

571
00:35:56,940 --> 00:35:59,220
כמו סוג של אתה עלול להרגיש דברים כאלה עם זה עכשיו.

572
00:35:59,220 --> 00:36:01,480
אבל אנחנו לא באמת צריכים לדאוג איך המכונית עובדת,

573
00:36:01,480 --> 00:36:05,970
אין לנו לשים לב למה כל המוטות ובוכנות והכבלים הפנימיים של המכונית

574
00:36:05,970 --> 00:36:08,160
למעשה הם עושים.

575
00:36:08,160 --> 00:36:12,770
אז משהו כמו מה שאתם קוראים את הבוכנה לא משנה כאן, במקרה זה. אותו הרעיון.

576
00:36:12,770 --> 00:36:25,300
כן. >> [שאלת תלמיד לא נשמעה]

577
00:36:25,300 --> 00:36:29,180
אם יש יותר שימושים של רגע xa משתנה לפני,

578
00:36:29,180 --> 00:36:32,150
אתה, המתכנת, הייתי צריכה לשנות אותם בכל מקום.

579
00:36:32,150 --> 00:36:36,600
או שאתה ממש יכול לעשות את הקובץ, תפריט ולאחר מכן מצא, חלף - משהו כזה -

580
00:36:36,600 --> 00:36:39,170
אבל אתה תצטרך לבצע שינויים אלה בעצמך.

581
00:36:39,170 --> 00:36:47,450
אתה צריך להיות עקבי. >> [תלמיד] אם יש משתנים רבים [לא ברור]

582
00:36:47,450 --> 00:36:53,100
סדר מסוים כמו כאן, אם זה היה int מספר אחר? >> [תלמיד] נכון.

583
00:36:53,100 --> 00:36:56,590
[מלאן] כן. סדר חשוב כאשר אתה קורא את הפונקציה.

584
00:36:56,590 --> 00:37:00,050
>> אז אם אני היה קורא תוספת כאן עם משהו פסיק משהו,

585
00:37:00,050 --> 00:37:01,680
יש מיפוי ישיר.

586
00:37:01,680 --> 00:37:05,690
המשתנה הראשון, איך שלא קוראים, הוא עשה עותק של הטיעון הראשון כאן.

587
00:37:05,690 --> 00:37:07,760
סליחה. זה לא אמור להיות מוסגר.

588
00:37:07,760 --> 00:37:11,490
בשורות השניות הטיעון עם עד השנייה אחת. אז בסדר, כן, עניינים. בסדר.

589
00:37:11,490 --> 00:37:17,020
סליחה. לקחתי את הדרך הארוכה כדי להגיע לשם. שאלות אחרות? בסדר.

590
00:37:17,020 --> 00:37:20,610
אז בואו נראה אם ​​אנחנו לא יכולים לצייר תמונה של מה שבאמת מתרחש כאן

591
00:37:20,610 --> 00:37:23,090
מתחת למכסת המנוע, אם אפשר לומר כך.

592
00:37:23,090 --> 00:37:26,640
זה מלבן שעשוי לייצג את הזיכרון של המחשב.

593
00:37:26,640 --> 00:37:30,970
גם אם אין לך מושג איך עובד זיכרון RAM או איך עובד,

594
00:37:30,970 --> 00:37:33,940
לפחות להניח שיש לך צרורות שלו בימים אלה.

595
00:37:33,940 --> 00:37:36,280
יש לך מגה בייט שלו, יש לך ג'יגה בייט שלו,

596
00:37:36,280 --> 00:37:40,870
ואנחנו יודעים משבוע 0 שבתים הם רק מה? >> [תלמיד] 8 סיביים.

597
00:37:40,870 --> 00:37:42,950
8 סיביים, נכון? כן 8 אפסים ו1.

598
00:37:42,950 --> 00:37:45,880
אז אם המחשב שלך יש חלטורה של RAM, 2 GB של זכרון RAM בימים אלה,

599
00:37:45,880 --> 00:37:55,030
יש לך מיליארדים או 2 מליארד בתים של זיכרון או בערך 8000000000 או 16 מליארד ביטים

600
00:37:55,030 --> 00:37:56,890
הפנימי של המחשב שלך.

601
00:37:56,890 --> 00:38:00,590
בניגוד לדוגמא הקטנה Wooly וילי, זה לא חלקיקים מגנטיים בדרך כלל יותר.

602
00:38:00,590 --> 00:38:04,450
יותר ויותר - במחשבים ניידים לפחות - זה כונני מצב מוצק, כונני SSD,

603
00:38:04,450 --> 00:38:08,580
כי פשוט אין להם חלקים נעים. הכל האלקטרוני. הכול מבוסס חשמל.

604
00:38:08,580 --> 00:38:14,060
אז תחשוב על זה כמלבן פשוט מייצג את 1 או 2 ג'יגה בייט של זיכרון שיש לך.

605
00:38:14,060 --> 00:38:16,020
>> אז זה נתח של זיכרון.

606
00:38:16,020 --> 00:38:19,830
סוג של עולם מדע מחשב המחיצות

607
00:38:19,830 --> 00:38:22,950
נתחי הזיכרון לעשות דברים שונים.

608
00:38:22,950 --> 00:38:27,190
לדוגמה, אם זה זכרון RAM של המחשב שלך, כפי שהוצע על ידי המלבן שם,

609
00:38:27,190 --> 00:38:31,130
מתברר שלפי אמנה, בחלק העליון של זכרון RAM שלך, אם אפשר לומר כך,

610
00:38:31,130 --> 00:38:33,660
בדרך כלל מה שנקרא קטע טקסט.

611
00:38:33,660 --> 00:38:36,740
אלה הם 0s ו 1s שיש לך הידור.

612
00:38:36,740 --> 00:38:39,020
לכן, כאשר אנחנו בדקנו מתחת למכסת המנוע במה a.out הוא,

613
00:38:39,020 --> 00:38:41,980
כל אלה 0s ו 1s, כשאתה מפעיל את תכנית,

614
00:38:41,980 --> 00:38:46,290
אלה 0s ו 1s נטענים מהכונן הקשיח למשהו שנקרא הזיכרון RAM,

615
00:38:46,290 --> 00:38:49,320
ובזכרון RAM הם שמו בראש.

616
00:38:49,320 --> 00:38:52,770
בינתיים, יש לך דברים אחרים: לאתחל נתונים, לבטל את אתחול נתונים.

617
00:38:52,770 --> 00:38:57,510
אלה 2 אגודות של זיכרון מתייחסות למשתנים הגלובליים, שאתה לא משתמש לעתים קרובות

618
00:38:57,510 --> 00:39:00,760
אבל לפעמים אם אתה עושה, הם בסוף לשם גם כן.

619
00:39:00,760 --> 00:39:04,260
אז יש כמה דברים אחרים: משתני סביבה, שאנחנו לא מבלים זמן רב ב,

620
00:39:04,260 --> 00:39:06,860
אבל אז 2 דברים חשובים שיחזרו לאורך כל הסמסטר,

621
00:39:06,860 --> 00:39:08,550
מחסנית וערימה.

622
00:39:08,550 --> 00:39:12,210
אז רוב זכרון המחשב שלך שמורה בעת הפעלת תכנית

623
00:39:12,210 --> 00:39:15,370
למשהו שנקרא המחסנית ומשהו שנקרא ערימה.

624
00:39:15,370 --> 00:39:18,840
אנחנו לא הולכים לדבר על הערימה היום, אבל אנחנו מדברים על המחסנית.

625
00:39:18,840 --> 00:39:24,600
המחסנית נועדה להעלות באוב חזותי ממגשי הארוחות בחדר האוכל בבית מאת'ר

626
00:39:24,600 --> 00:39:28,110
או כל מקום שלא יהיה בה צוות חדר האוכל לנקות אותם כל יום,

627
00:39:28,110 --> 00:39:30,180
הם עורמים אותם מרצפה ומעלה,

628
00:39:30,180 --> 00:39:34,550
ובאופן דומה, בזיכרון, יש את הרעיון הזה של לשים משהו במחסנית,

629
00:39:34,550 --> 00:39:36,860
לשים משהו במחסנית, לשים משהו במחסנית.

630
00:39:36,860 --> 00:39:38,240
ומה אנחנו מתכוונים בזה?

631
00:39:38,240 --> 00:39:41,860
>> בואו זום על רק על החצי התחתון של התמונה הזאת, זכרון RAM של המחשב שלך,

632
00:39:41,860 --> 00:39:44,330
להציע את הפעולות הבאות.

633
00:39:44,330 --> 00:39:48,170
מתברר כי בעת הפעלת תכנית כמו a.out או שלום -

634
00:39:48,170 --> 00:39:50,100
כל התכנית היא שאתה כתבת -

635
00:39:50,100 --> 00:39:54,020
שוב, אלה 0s ו 1s נטענים מהכונן הקשיח שלך, שהוא אחסון לטווח ארוך,

636
00:39:54,020 --> 00:39:57,230
נשאר שם גם כשאתה מושך את התקע, נטען לזכרון RAM.

637
00:39:57,230 --> 00:40:00,610
זכרון RAM הוא מהיר יותר מכוננים קשיחים - זה קטן יותר מאשר כוננים קשיחים -

638
00:40:00,610 --> 00:40:03,300
אבל זה מקום שבו תוכניות לחיות בזמן שאתה מפעיל אותם.

639
00:40:03,300 --> 00:40:08,230
אז תלחץ פעמים על תכנית במקינטוש או PC, זה נטען מכונן קשיח לזכרון RAM.

640
00:40:08,230 --> 00:40:11,520
ברגע שזה טעון לזכרון RAM, ללכת 0s ו 1s בראש הדרך,

641
00:40:11,520 --> 00:40:16,610
קטע הטקסט שנקרא, אבל אז ברגע שהתכנית שלך בעצם מתחילה לרוץ,

642
00:40:16,610 --> 00:40:21,360
הפונקציה העיקרית נקראת, ועיקרי, כפי שראינו, לעתים קרובות יש משתנים מקומיים,

643
00:40:21,360 --> 00:40:24,870
ויש לה ints ומחרוזות ותווים וכדומה.

644
00:40:24,870 --> 00:40:29,180
אז אם התכנית שלך שאתה כתבת או את התכנית שיש לך לחיצה כפולה

645
00:40:29,180 --> 00:40:32,970
השתמשתי כמה משתנים בתוך מראשי,

646
00:40:32,970 --> 00:40:37,240
הם בסופו בתחתית הערימה של זיכרון שלך, אם אפשר לומר כך.

647
00:40:37,240 --> 00:40:39,410
באופן קונקרטי יותר, מה זה בעצם אומר?

648
00:40:39,410 --> 00:40:48,450
זה רק אומר שאם אנחנו הולכים למספר הבתים בזיכרון RAM במחשב שלך,

649
00:40:48,450 --> 00:40:55,750
שם לב שזה יכול להיות מספר בתי 0, זה עשוי להיות מספר בתי 1, 2, 3, 4, 5, 6,

650
00:40:55,750 --> 00:41:01,480
כל הדרך עד 2 מליארד תהיה כל הדרך עד לשם בראש.

651
00:41:01,480 --> 00:41:05,880
אז במילים אחרות, כאשר אנו מדברים על זכרון RAM או זיכרון במונחים של בתים,

652
00:41:05,880 --> 00:41:11,500
זה רק אומר שמישהו החליט מה למספר כל אחד מהגושים האלה של זיכרון.

653
00:41:11,500 --> 00:41:16,650
לכן, כאשר אתה צריך 32 ביטים עבור int או שאתה צריך 8 ביטים לchar,

654
00:41:16,650 --> 00:41:18,840
שם הם בסופו של זיכרון?

655
00:41:18,840 --> 00:41:22,350
>> מבחינה מושגית, הם פשוט בסופו בחלק התחתון של הדבר הזה שנקרא המחסנית.

656
00:41:22,350 --> 00:41:25,870
אבל מה שמעניין עכשיו הוא כאשר עיקרי קורא לפונקציה -

657
00:41:25,870 --> 00:41:28,750
מניח פונקציה בשם foo, רק שם שרירותיים -

658
00:41:28,750 --> 00:41:32,330
מה שקורה הוא עיקרי הוא בתחתית ערימה זו של זיכרון;

659
00:41:32,330 --> 00:41:35,680
foo עכשיו הוא לשים על גבי עיקרי בזיכרון.

660
00:41:35,680 --> 00:41:40,990
אז כל משתנים מקומיים שהפך בסופו של foo סוג של מושגית מעל אלה בראשיים.

661
00:41:40,990 --> 00:41:47,070
אם foo קורא פונקציה אחרת בשם בר, המשתנים האלה הגיעו לכאן.

662
00:41:47,070 --> 00:41:50,120
אם בר קורא משהו אחר, כאן, כאן, כאן.

663
00:41:50,120 --> 00:41:53,830
אז מה שמעניין בהפעלת תכנית הוא שככל שאתה קורא פונקציות

664
00:41:53,830 --> 00:41:57,750
כפונקציות אלה לקרוא לפונקציות ופונקציות אלה לקרוא לפונקציות ו,

665
00:41:57,750 --> 00:42:01,470
אתה בונה את ערימה זו של פונקציות בזיכרון.

666
00:42:01,470 --> 00:42:06,890
ורק פעם בתשואות פונקציה אתה מתחיל לקבל זיכרון שיחזור.

667
00:42:06,890 --> 00:42:10,860
לכן אחת הדרכים הקלות ביותר להפעלה מתוך זיכרון בתכנית מחשב

668
00:42:10,860 --> 00:42:14,360
הוא לכתוב פונקציות שלא לחזור לעולם.

669
00:42:14,360 --> 00:42:18,900
כך למשל, בואו להפגין כמה שיותר בתכנית במכוון כרכרה.

670
00:42:18,900 --> 00:42:22,230
תן לי ללכת קדימה ואל # כוללים <stdio.h>,

671
00:42:22,230 --> 00:42:25,000
int הראשי (ריק),

672
00:42:25,000 --> 00:42:32,940
ואני הולך לעשות בזמן (2> 1), שכנראה לא ישתנו לעולם עלינו,

673
00:42:32,940 --> 00:42:37,560
ותנו לי ללכת קדימה עכשיו ולעשות printf.

674
00:42:37,560 --> 00:42:40,700
למעשה, זה הולך להיות פחות מעניין מבחינה ויזואלית. בואו נעשה את זה.

675
00:42:40,700 --> 00:42:50,240
לint i = 0; i> 0 - בואו נעשה את הטעות הזאת - אני + +.

676
00:42:50,240 --> 00:42:52,720
ובואו לא printf כאן. בואו להתאמן על מה שאני מטיף.

677
00:42:52,720 --> 00:43:00,190
בואו שיטה כאן, מקהלת חלל, ואנחנו נגיד אני int,

678
00:43:00,190 --> 00:43:06,830
ואז אני הולך לומר printf - לא, בואו נעשה את זה יותר מעניין.

679
00:43:06,830 --> 00:43:15,790
בואו ממש לא להדפיס כל דבר. בואו פשוט נעשה את זה פזמון: (i).

680
00:43:15,790 --> 00:43:20,390
בסדר. אז זה עגלה כי למה?

681
00:43:20,390 --> 00:43:23,380
אני עושה את זה כמו שאני הולך, כי התכנית לא ממש עושה משהו מעניין.

682
00:43:23,380 --> 00:43:25,320
>> אבל זה לא המטרה.

683
00:43:25,320 --> 00:43:29,630
המטרה היא לכתוב תכנית שתפקידה העיקרי עושה מה, כנראה?

684
00:43:30,720 --> 00:43:32,860
שיחה עוצמה. ובעצם, אנחנו לא צריכים את הלולאה.

685
00:43:32,860 --> 00:43:37,200
בואו אפילו לפשט זאת רק כדי לא לאבד את הראייה של ממש באג הבסיסי.

686
00:43:37,200 --> 00:43:39,640
שיחות עיקריות מקהלה תשיר במקהלה,

687
00:43:39,640 --> 00:43:41,440
אז עשיתי משהו טיפשי ולא היה לי שיחת מקהלת מקהלה

688
00:43:41,440 --> 00:43:43,760
משום שהנחית שמישהו אחר היה הולך ליישם את זה אולי,

689
00:43:43,760 --> 00:43:47,210
ועכשיו זה לא הולך לקמפל עדיין. אני צריך לעשות את מה?

690
00:43:47,210 --> 00:43:49,970
אני צריך את אב טיפוס, לזכור.

691
00:43:49,970 --> 00:43:56,110
אז אני צריך להיות כאן מקהלת הריק (int i);

692
00:43:56,110 --> 00:43:59,210
אז עכשיו אם אני יורד כאן - בעצם, בואו להשתמש בחלון הגדול יותר.

693
00:43:59,210 --> 00:44:01,980
בואו נלך קדימה ולהפוך את המקהלה.

694
00:44:01,980 --> 00:44:06,490
בואו נלך קדימה ולהפוך את המקהלה.

695
00:44:06,490 --> 00:44:08,370
שימוש במזהה לא המוצהרת.

696
00:44:08,370 --> 00:44:12,500
אה, זה היה טיפשי. אנחנו לא צריכים את הוויכוח. בואו פשוט נעשה את זה.

697
00:44:12,500 --> 00:44:16,370
חבל שלא התחילו בדרך הזאת. זה היה יכול להיות תכנית הרבה יותר קלה לכתוב.

698
00:44:16,370 --> 00:44:25,590
יש. עכשיו בואו ניגשנו לחלון מסופי, שידור חוזר קלאנג, והנה זה בא.

699
00:44:25,590 --> 00:44:28,460
זה היה ממש מהר.

700
00:44:28,460 --> 00:44:31,150
מה בעצם פשוט אבל קרה?

701
00:44:31,150 --> 00:44:33,730
ובכן, עכשיו אני אוסיף שורת ההדפסה כדי שנוכל לראות.

702
00:44:33,730 --> 00:44:43,490
הרשה לי לומר printf ("אני פה") - לא משתנה. אנחנו נשאיר את זה ככה.

703
00:44:43,490 --> 00:44:47,480
תן לי לעשות שידור חוזר. תן לי שידור חוזר מקהלה.

704
00:44:47,480 --> 00:44:57,380
ו ... בחייך. תמשיך.

705
00:44:57,380 --> 00:44:59,930
במאמר מוסגר, מדוע הוא עדיין לא התרסק?

706
00:44:59,930 --> 00:45:02,080
אשמת הפילוח קרתה לפני סופר מהיר.

707
00:45:02,080 --> 00:45:06,570
[תגובת תלמיד לא נשמעה] >> בדיוק. אז זה לוקח זמן כדי להדפיס, נכון?

708
00:45:06,570 --> 00:45:08,610
זה פשוט לוקח יותר עבודה על החלק של המחשב.

709
00:45:08,610 --> 00:45:10,620
וזה מה שיש: אשמת פילוח.

710
00:45:10,620 --> 00:45:12,340
>> אז שם לב עד כמה תוכניות לרוץ מהר.

711
00:45:12,340 --> 00:45:14,130
אם אתם לא מדפיסים כל דבר, סופר מהיר.

712
00:45:14,130 --> 00:45:18,770
אבל יש לנו עדיין אשמת פילוח זה בגלל מה שקורה?

713
00:45:18,770 --> 00:45:21,210
אם אתה חושב על איך הזיכרון של המחשב שלך הוא לפריסתו,

714
00:45:21,210 --> 00:45:28,740
זה קורה להיות ראשי, אבל כאן בוא פשוט נקרא הפזמון הזה, ובואו נקראים לפזמון הזה.

715
00:45:28,740 --> 00:45:34,550
ועכשיו אם אני עושה את האסתטיקה שלי נכון, זה היה רק ​​זה שאומר מקהלה, מקהלה, מקהלת,

716
00:45:34,550 --> 00:45:40,550
מקהלה, מקהלה, מקהלה, מקהלת, עד זרא, וסופו של דבר, מה יקרה?

717
00:45:40,550 --> 00:45:45,630
אם התמונה הגדולה, תר משמע, היא זו, מה בדיוק קורית רעיוני?

718
00:45:46,520 --> 00:45:48,630
את צפות ערימת הערימה.

719
00:45:48,630 --> 00:45:51,940
או, גרוע מכך, אתה פשוט מוצף הכל, כולל קטע הטקסט,

720
00:45:51,940 --> 00:45:54,590
אשר 0s ו 1s שמייצג את התכנית שלך.

721
00:45:54,590 --> 00:45:57,080
בקיצור, זה פשוט סופר, סופר רע.

722
00:45:57,080 --> 00:45:58,830
התכנית שלך יצאה מכלל שליטה.

723
00:45:58,830 --> 00:46:01,220
אתה משתמש בדרך יותר זיכרון ממה שהתכוונת

724
00:46:01,220 --> 00:46:03,960
והכל בגלל טעות טיפשית במקרה הזה,

725
00:46:03,960 --> 00:46:08,040
או במקרה זה פונקציה נעשתה במכוון מאוד מכנה עצמו.

726
00:46:08,040 --> 00:46:09,500
עכשיו, זה לא רע כל כך.

727
00:46:09,500 --> 00:46:13,800
פונקציות קוראות לעצמם דווקא יש לו כוח גדול כאשר אתה משתמש בו בצורה נכונה.

728
00:46:13,800 --> 00:46:15,800
אני לא השתמשתי בו בצורה נכונה כאן.

729
00:46:15,800 --> 00:46:19,780
אז זה לא רע בכלל, אבל העובדה שאני אף פעם לא באמת להפסיק לקרוא את עצמי

730
00:46:19,780 --> 00:46:23,520
היא חולשה בסיסית כאן של תכנית זו.

731
00:46:23,520 --> 00:46:26,400
אז לאן אנחנו הולכים עם כל זה? מה באמת קורה?

732
00:46:26,400 --> 00:46:30,340
כשאני קורא את פונקצית תוספת כמו שאנחנו עושים בדוגמות הללו,

733
00:46:30,340 --> 00:46:33,420
יש לי ערך כמו 1 שאני עובר פנימה

734
00:46:33,420 --> 00:46:37,570
אני עובר בעותק של המספר 1, אז הבא שקורה.

735
00:46:37,570 --> 00:46:44,240
בואו נלך לדוגמא תוספת, הבחור הזה ממש כאן.

736
00:46:44,240 --> 00:46:46,870
הנה מה שבאמת קורה.

737
00:46:46,870 --> 00:46:53,400
כאשר אני קורא את התוספת ואני עובר בx, ציורי, מה שקורה כאן הוא זה.

738
00:46:53,400 --> 00:46:59,520
>> אם יש לי ערך של 1 מאוחסן כאן ואני באמת קורא לתוספת,

739
00:46:59,520 --> 00:47:04,330
כיום שמתי מקהלה - iPad הוא לזרוק אותי מכאן.

740
00:47:04,330 --> 00:47:09,760
בואו לקרוא תוספת זו, ואנחנו לא יודעים מה הפונקציה הבאה זה הולכת להיות.

741
00:47:09,760 --> 00:47:14,840
אז מה בעצם קורה כאן הוא אי שם בעיקרי שיש לי נתח של זיכרון

742
00:47:14,840 --> 00:47:17,000
האחסון המספר 1.

743
00:47:17,000 --> 00:47:19,380
כאשר אני קורא את תוספת, אני משתמש בנתח נוסף של זיכרון,

744
00:47:19,380 --> 00:47:21,230
אבל עכשיו יש לי עותק של 1.

745
00:47:21,230 --> 00:47:26,660
כשאני להגדיל את הערך, זה הופך להיות 2,

746
00:47:26,660 --> 00:47:30,560
אבל אז מה שקורה ברגע שחוזר תוספת?

747
00:47:30,560 --> 00:47:33,630
זיכרון זה פשוט מקבל להחזיר למערכת ההפעלה,

748
00:47:33,630 --> 00:47:37,450
מה שאומר שכל מה שעשית הוא שום דבר מועיל.

749
00:47:37,450 --> 00:47:43,120
1 שהיה כלול במקור בשינה העיקרית הוא עדיין שם באמת.

750
00:47:43,120 --> 00:47:44,890
אז לאן אנחנו הולכים עם זה?

751
00:47:44,890 --> 00:47:49,770
מתברר כי בזיכרון יש לך רצף גב אל גב זה של בתים

752
00:47:49,770 --> 00:47:53,050
כי אתה יכול לשים את דברים ב, ומתברר שכבר ראו משהו

753
00:47:53,050 --> 00:47:55,390
שכרוך מחזיר את הדברים לגב אל הגב אל גב.

754
00:47:55,390 --> 00:47:59,860
מהו המבוסס על מחרוזת 1 שבוע ועכשיו שבוע 2?

755
00:48:00,020 --> 00:48:01,980
זה פשוט אוסף של תווים.

756
00:48:01,980 --> 00:48:04,310
אז מתברר שבדיוק כמו שאתה יכול לשים את המספרים בזיכרון,

757
00:48:04,310 --> 00:48:06,990
באופן דומה אתה יכול לשים את תווים בזיכרון.

758
00:48:06,990 --> 00:48:10,530
וברגע שאנחנו מתחילים לשים תווים בזכרון גב אל גב אל גב אל גב,

759
00:48:10,530 --> 00:48:13,620
מתברר ששימוש הפשוט ביותר של דברים כמו ללולאה או לולאה בזמן,

760
00:48:13,620 --> 00:48:17,170
אנחנו יכולים לחזר משמאל לימין על התווים במחרוזת

761
00:48:17,170 --> 00:48:20,600
ולהתחיל לעסות אותם לדמויות שונות לגמרי -

762
00:48:20,600 --> 00:48:23,370
יכול להיות B, B יכול להיות ג -

763
00:48:23,370 --> 00:48:27,780
כך שסופו של דבר, אנחנו יכולים לקחת את המשפט באנגלית שממש הגיונית

764
00:48:27,780 --> 00:48:30,310
ולהמיר כל אחד מהמכתבים האלה 1 בכל פעם

765
00:48:30,310 --> 00:48:34,400
הליכה בתוך הזיכרון של המחשב שלנו משמאל לימין דווקא כדי להצפין.

766
00:48:34,400 --> 00:48:35,810
אז בואו לקחת ההפסקה של חמש הדקות שלנו כאן,

767
00:48:35,810 --> 00:48:40,730
וכשנחזור, נתחיל את התהליך הזה של ערבול מידע.

768
00:48:42,020 --> 00:48:43,520
>> בסדר.

769
00:48:43,520 --> 00:48:48,070
לפני שנצלול לתוך כמה אנוסים והדברים האלה נקראים מערכים,

770
00:48:48,070 --> 00:48:51,470
תן לי לעצור לשאלות כי אני מרגיש שאני באמת סוג של מבולבל

771
00:48:51,470 --> 00:48:54,080
חלק מנושאים אלו. אז בואו נתקן עכשיו אם אנחנו יכולים.

772
00:48:54,080 --> 00:48:58,700
רק דברנו על ערכים לחזור, דברו על ויכוחים,

773
00:48:58,700 --> 00:49:03,250
ודברנו על הרעיון הזה, שאנחנו נחזור לשבועות הקרובים,

774
00:49:03,250 --> 00:49:08,720
לצפייה בזיכרון כחבורה שלמה של המגשים העמוסים האלה, אם אפשר לומר כך,

775
00:49:08,720 --> 00:49:12,660
מלמטה למעלה, כך שכל מגש שמקבל לשים על הערימה

776
00:49:12,660 --> 00:49:16,530
מייצג פונקציה שכרגע זה נקרא.

777
00:49:17,900 --> 00:49:20,260
יש שאלות?

778
00:49:20,260 --> 00:49:22,640
תן לי לשאול שאלה כאן.

779
00:49:22,640 --> 00:49:27,890
בואו תפשטו אותי בחזרה זה למה שהוא היה לפני כמה ש הקודם שלנו & A.

780
00:49:27,890 --> 00:49:35,570
העובדה שיש תוספת סוגריים פתוחים, מספר int, סגורה סוגריים -

781
00:49:35,570 --> 00:49:39,110
מה מספר int מייצג?

782
00:49:39,110 --> 00:49:42,790
[תלמיד] ויכוח. >> ויכוח. אוקיי. אבל מה ויכוח?

783
00:49:42,790 --> 00:49:46,370
[תגובת תלמיד לא נשמע] >> מה זה? >> [תלמיד] משהו שתוכל לעבור פנימה

784
00:49:46,370 --> 00:49:49,940
אוקיי, אז משהו שתוכל לעבור בו ואופן כללי יותר, זה רק הקלט.

785
00:49:49,940 --> 00:49:52,450
אם היית כותב את הפונקציה ומטרה של אותו תפקיד בחיים

786
00:49:52,450 --> 00:49:55,770
הוא לעשות משהו קצת שונה בכל פעם שאתה משתמש בו,

787
00:49:55,770 --> 00:50:00,110
אז הדרך היחידה שזה יקרה באמת הייתה נראית לספק לו הזנה

788
00:50:00,110 --> 00:50:03,510
כך שהוא יכול לעשות משהו אחר עם שקלט בכל פעם.

789
00:50:03,510 --> 00:50:06,650
>> אז אתה צריך לציין שני דברים כאשר הפונקציה מקבלת קלט.

790
00:50:06,650 --> 00:50:09,590
אתה צריך לציין את השם שאתה רוצה לתת לזה קלט

791
00:50:09,590 --> 00:50:12,700
אך ורק לנוחות שלך, כך שאתה יכול להתייחס אליו

792
00:50:12,700 --> 00:50:16,540
בפונקציה שאתה עצמך כותב, כפי שעשיתי כאן בקו 32.

793
00:50:16,540 --> 00:50:20,800
אבל אתה גם צריך לציין את הסוג שלו, כי C היא שפת תכנות

794
00:50:20,800 --> 00:50:25,940
זה פשוט דורש שאם אתה רוצה משתנה, יש לך לומר למחשב מה סוג נתונים שהוא,

795
00:50:25,940 --> 00:50:30,200
בחלק גדול, כך שהוא יודע כמה ביטים שיוקצו לאותו משתנה

796
00:50:30,200 --> 00:50:33,020
כי זה יכול להיות 6 - מצטער, זה לא יהיה 6.

797
00:50:33,020 --> 00:50:37,080
זה יכול להיות 16, זה יכול להיות 8, זה יכול להיות 32, אפילו 64,

798
00:50:37,080 --> 00:50:39,130
אבל המחשב צריך לדעת.

799
00:50:39,130 --> 00:50:43,180
עכשיו, int בצד השמאלי מייצג את מה, לעומת זאת?

800
00:50:46,350 --> 00:50:48,850
[תגובת תלמיד לא נשמע] >> מה זה? >> [תלמיד] סוג של פונקציה.

801
00:50:48,850 --> 00:50:53,610
הסוג של פונקציה, ולייתר דיוק, בסוג הפלט שלה. נכון.

802
00:50:53,610 --> 00:50:57,380
אז אילו דבר בסוגריים מייצג את הקלט שלה, אם בכלל,

803
00:50:57,380 --> 00:50:59,660
הדבר לשמאל מייצג את התפוקה שלה.

804
00:50:59,660 --> 00:51:03,530
ובמקרה הזה, כנראה תוספת מחזירה int,

805
00:51:03,530 --> 00:51:07,690
וכך int הוא סוג ההחזרה של פונקציה זו.

806
00:51:07,690 --> 00:51:09,340
מה זה אומר לחזור?

807
00:51:09,340 --> 00:51:15,090
פשוטו כמשמעו, אתה משתמש במילת מפתח שיבה ואז אם מה שאתה חוזר

808
00:51:15,090 --> 00:51:18,600
מימין למילת המפתח הוא מספר שלם,

809
00:51:18,600 --> 00:51:21,660
אז זה אכן עולה בקנה אחד עם מה שהבטחנו.

810
00:51:21,660 --> 00:51:26,410
אתה לא יכול לעשות משהו כזה - שלום, עולם - כי זה מחרוזת.

811
00:51:26,410 --> 00:51:28,860
>> ברור, זה לא שלם.

812
00:51:28,860 --> 00:51:33,140
אז בקיצור, הניטל הוא באמת עלינו, המתכנת, להיות ספציפית

813
00:51:33,140 --> 00:51:37,770
על מה שאנחנו חוזרים ואז באמת ללכת על החזרתו.

814
00:51:37,770 --> 00:51:43,440
ההקשר כאן עכשיו הוא שהזיכרון של המחשב שלך הוא ג'יגה, 2 ג'יגה -

815
00:51:43,440 --> 00:51:45,920
מה - אולי זה יותר, אולי זה פחות,

816
00:51:45,920 --> 00:51:49,050
אבל מחשב רואה אותו כבעל מקטעים שונים.

817
00:51:49,050 --> 00:51:51,200
משהו הולך שם למטה, משהו אחר הולך לשם,

818
00:51:51,200 --> 00:51:54,290
חומר אחר הולך באמצע, והיום אנחנו רק מתחילים לספר את הסיפור,

819
00:51:54,290 --> 00:51:56,340
אבל אנחנו נחזור לזמן על זה.

820
00:51:56,340 --> 00:51:59,980
לעת עתה, פיסת הזיכרון היחידה שבאמת אכפת לי היא קטע הטקסט

821
00:51:59,980 --> 00:52:03,360
משום שרק מייצג שקלאנג 0s ו 1s יש outputted.

822
00:52:03,360 --> 00:52:06,050
אז כשאתה מפעיל את פקודה במקלדת כמו a.out

823
00:52:06,050 --> 00:52:09,110
או הלחיצה כפולה על סמל ב-Mac OS או Windows,

824
00:52:09,110 --> 00:52:11,880
התכנית שלך היא טעונה מהכונן הקשיח לזכרון RAM

825
00:52:11,880 --> 00:52:16,330
ומטיל אותה בחלק העליון של זכרון RAM של המחשב שלך, אם אפשר לומר כך.

826
00:52:16,330 --> 00:52:20,450
בינתיים, כפי שהתכנית שלך מתחילה לרוץ ועיקרי מקבל נקרא

827
00:52:20,450 --> 00:52:23,640
בתכנית שכתבת או התכנית של Microsoft או Apple כתב,

828
00:52:23,640 --> 00:52:27,860
כל אחד מהמשתנים המקומיים שלה בסופו שם למטה בחלק התחתון של זכרון המחשב שלך.

829
00:52:27,860 --> 00:52:33,230
אבל אם שיחות עיקריות פונקציה אחרת שעצמו יש משתנים או ויכוחים, הם בסופו מעליו.

830
00:52:33,230 --> 00:52:36,680
ואם הפונקציה שקוראה משהו, הם בסופו מעליו, מעליו, מעליו.

831
00:52:36,680 --> 00:52:41,460
>> ורק פעם אחת פונקציה נעשתה ביצוע אין את ערימת המגשים, כביכול,

832
00:52:41,460 --> 00:52:43,240
מתחיל לקבל יותר ויותר.

833
00:52:43,240 --> 00:52:48,250
וזה מה שאז, בקליפת האגוז, מסביר מדוע כאשר אתה קורא קובייה

834
00:52:48,250 --> 00:52:51,550
או שאתה קורא לתוספת, אתה עובר בעותק של הערך.

835
00:52:51,550 --> 00:52:55,520
ומה זה אומר ציורי הוא שאתה ממש כותב את המספר 1

836
00:52:55,520 --> 00:53:00,460
בחלק אחר של זיכרון, שינוי ש1-2 במקרה של תוספת

837
00:53:00,460 --> 00:53:04,820
או 8 במקרה של קובייה, ואז לזרוק זיכרון זה

838
00:53:04,820 --> 00:53:09,140
ברגע שהתוספת או את תשואות פונקציית הקובייה. שאלה.

839
00:53:09,140 --> 00:53:12,900
[תלמיד] איפה מאוחסנים משתנים גלובליים?

840
00:53:12,900 --> 00:53:18,100
משתנים גלובליים מאוחסנים במה שנקרא כעת את הנתונים אותחלו או הנתונים מאותחלים,

841
00:53:18,100 --> 00:53:21,920
ההבדל הוא שאם יש לך משתנה גלובלי ותקצה אותה מייד ערך

842
00:53:21,920 --> 00:53:24,640
בסימן שוויון, זה בסופו בראש שם,

843
00:53:24,640 --> 00:53:29,200
ואם אתה רק אומר x int; ללא ערך, זה בסופו מעט נמוך יותר בזכרון RAM

844
00:53:29,200 --> 00:53:31,710
פשוט על ידי ועידה.

845
00:53:31,710 --> 00:53:34,940
שאלות אחרות? בסדר.

846
00:53:34,940 --> 00:53:37,340
אז התמונה הזאת תחזור כפי שאנו מקבלים יותר חזקים

847
00:53:37,340 --> 00:53:39,170
עם מה אנחנו יכולים לעשות עם המחשב,

848
00:53:39,170 --> 00:53:42,720
אך לעת עתה, בואו יש מבוא קצר לקריפטוגרפיה,

849
00:53:42,720 --> 00:53:46,080
סוג מסוים של הצפנה שלא יפתור את כל הבעיות בעולם

850
00:53:46,080 --> 00:53:47,720
אבל פותר חלק מהם.

851
00:53:47,720 --> 00:53:51,700
במקרה זה כאן, יש לנו משהו שנקרא הצפנת סוד מפתח.

852
00:53:51,700 --> 00:53:56,410
קריפטוגרפיה סוד מפתח, כפי שהשם מרמז, נובעת מהביטחון שלה בסוד.

853
00:53:56,410 --> 00:54:00,690
>> לדוגמה, אם היית בבית הספר יסודי ועברתם מכתב אהבת סוד קטן

854
00:54:00,690 --> 00:54:04,850
לילד או הילדה שהיית מוחץ, אם אתה רוצה לעבור את הלב שעבר בקהל,

855
00:54:04,850 --> 00:54:08,380
אתה כנראה לא לכתוב פתק כזה באנגלית או כל השפה האם שלך היא.

856
00:54:08,380 --> 00:54:13,340
במקום זאת, אתה יכול להצפין אותו או שאתה יכול פשוט לשלוח להם הודעת טקסט בימים אלה.

857
00:54:13,340 --> 00:54:15,460
אבל אולי בעצם אתה מעביר להם פתק בכל הכיתה.

858
00:54:15,460 --> 00:54:18,700
וכדי לעשות את זה באופן מאובטח בצורה כזו שהחברים שלך והמורה

859
00:54:18,700 --> 00:54:22,650
לא יודע מה שאתה כותב, אתה יכול לבוא עם אלגוריתם פשוט למדי,

860
00:54:22,650 --> 00:54:25,920
צעיר למרות שאתה יכול להיות, רק כדי לטרוף את המילים.

861
00:54:25,920 --> 00:54:28,130
אז במקום לכתוב אתה יכול לכתוב ב,

862
00:54:28,130 --> 00:54:30,220
במקום שאפשר לכתוב ב ג,

863
00:54:30,220 --> 00:54:32,140
במקום שאפשר לכתוב ג ד, וכן הלאה.

864
00:54:32,140 --> 00:54:34,360
או שאתה יכול לבוא עם תרגום מתוחכם יותר

865
00:54:34,360 --> 00:54:36,720
מכתבים לאותיות שונות.

866
00:54:36,720 --> 00:54:39,740
אבל המלכוד הוא ילד או ילדה למי אתה שולח את המכתב הזה

867
00:54:39,740 --> 00:54:45,020
צריכים לדעת משהו, וזה מה ש, ברור? >> [תלמיד] מה אתה שולח.

868
00:54:45,020 --> 00:54:49,720
מה הסוד שלך, כמו מה שהמיפוי בין של וציונים הטובים ושל ושל ד '.

869
00:54:49,720 --> 00:54:54,650
האם זה רק מוסיף 1 לכל אחד מהמכתבים ללכת מנקודת א ', ב' לג'?

870
00:54:54,650 --> 00:54:56,670
האם זה מורכב יותר מזה?

871
00:54:56,670 --> 00:55:01,540
>> אז אתה ומושא אהבתך צריך להיות מידע הסודי הזה,

872
00:55:01,540 --> 00:55:03,190
אבל יש סוג של מלכוד-22 כאן.

873
00:55:03,190 --> 00:55:06,830
אם זו הפעם הראשונה שאתה שולח מכתב אהבה זה באמצעות הכיתה,

874
00:55:06,830 --> 00:55:10,720
איך נער או הנערה שהולך יודע מה הסוד גם הוא?

875
00:55:10,720 --> 00:55:13,930
אנוסים כך סודי מפתח לא יפתרו את כל הבעיות בעולם,

876
00:55:13,930 --> 00:55:16,320
ויש בעצם כאן מערכת יחסים שאנחנו נחזור ללקראת סופו של הסמסטר.

877
00:55:16,320 --> 00:55:25,110
כמו כן אין רובנו לא מכירים מישהו שעובד, למשל, בAmazon.com,

878
00:55:25,110 --> 00:55:28,190
ובכל זאת רבים מאיתנו כנראה קנו את הדברים ב-Amazon.com,

879
00:55:28,190 --> 00:55:31,990
ולמד אותנו להניח שעסקות אלו מסחר אלקטרוני מאובטחות.

880
00:55:31,990 --> 00:55:36,470
כתובת האתר כנראה אומרת https, יש אולי סמל של מנעול קטן וטיפשי במקום כלשהו,

881
00:55:36,470 --> 00:55:39,930
יש איזה סוג של הצפנת אבטחת פרטי כרטיס האשראי שלך

882
00:55:39,930 --> 00:55:42,160
בינך וAmazon.com.

883
00:55:42,160 --> 00:55:45,430
ובכל זאת, אם קריפטוגרפיה הכרוכה לדעת איזה סוד

884
00:55:45,430 --> 00:55:48,620
ובכל זאת אני לא מכיר אף אחד באמזון ואני בהחלט לא סדרתי כל סוג של הסוד

885
00:55:48,620 --> 00:55:52,710
עם מישהו באמזון, איך המחשב שלי או הדפדפן שלי עושה את זה?

886
00:55:52,710 --> 00:55:55,720
מסתבר שיש סוגים אחרים של הצפנה לגמרי שיפתרו את הבעיה.

887
00:55:55,720 --> 00:55:57,670
אבל להיום, אנו נתמקד באחת הפשוט

888
00:55:57,670 --> 00:56:00,290
שבו אתה יכול לארגן מראש לדעת איזה סוד

889
00:56:00,290 --> 00:56:03,760
כמו +1 או מיפוי בין חלק של ושל ב.

890
00:56:03,760 --> 00:56:05,840
והתהליך של הצפנה בדרך כלל כרוך זה.

891
00:56:05,840 --> 00:56:08,620
יש לך קצת טקסט רגיל, מתואר כאן בצד שמאל,

892
00:56:08,620 --> 00:56:12,930
אתה מפעיל את זה דרך איזה אלגוריתם או הליך להצפנתו -

893
00:56:12,930 --> 00:56:15,100
אולי זה רק הופך B, B יהפוך ג -

894
00:56:15,100 --> 00:56:17,490
ואז אתה בסופו של טקסט מוצפן.

895
00:56:17,490 --> 00:56:20,380
בינתיים, לאחר שהמושא אהבתך מקבל הפתק הסודי הזה,

896
00:56:20,380 --> 00:56:24,200
הוא או היא צריכה לפענח ואז זה בדרך כלל על ידי היפוך האלגוריתם ה

897
00:56:24,200 --> 00:56:27,190
כדי לקבל בחזרה את הטקסט הרגיל.

898
00:56:27,190 --> 00:56:28,960
יש גלגולים פיסיים של זה.

899
00:56:28,960 --> 00:56:31,680
>> לדוגמה, זה טבעת מפענח סוד קטנה,

900
00:56:31,680 --> 00:56:35,110
וזו היא טבעת במובן זה שיש כאן שתי חוגות.

901
00:56:35,110 --> 00:56:38,490
בפריפריה מחוץ לדבר הזה, יש אותיות A עד Z,

902
00:56:38,490 --> 00:56:40,340
על אף שהן בסדר אקראיות,

903
00:56:40,340 --> 00:56:42,880
ומבפנים, יש בעצם כמה מספרים

904
00:56:42,880 --> 00:56:46,620
כזה שבטבעת זו תוכלי סוג של להפוך מבחוץ אבל לא מבפנים

905
00:56:46,620 --> 00:56:49,140
כדי ליישר קו עם מספרי אותיות.

906
00:56:49,140 --> 00:56:53,020
מסרט שנקרא סיפור חג המולד, אתה תראה שראלפי הקטן

907
00:56:53,020 --> 00:56:58,000
היה כל כך להוט להבין מה המסר הסודי של היתומה הקטנה אנני היה לו

908
00:56:58,000 --> 00:57:02,570
שתקשר, אני חושב, בצורה של מסרים מספריים בקופסא דגנים

909
00:57:02,570 --> 00:57:07,220
והיה לך לצבור את כל הקלפים הקטנים שבאו בקופסא דגני הבוקר,

910
00:57:07,220 --> 00:57:09,770
היה לך לשלוח אותם, היה לך כדי לקבל בחזרה את טבעת מפענח הסוד

911
00:57:09,770 --> 00:57:13,910
כך שאתה יכול סוף סוף להבין מה הוא המיפוי בין אותיות ומספרים

912
00:57:13,910 --> 00:57:15,550
או אותיות וספרות.

913
00:57:15,550 --> 00:57:19,520
איך במחשב שאנחנו יכולים ללכת על יישום או מייצגים דברים כאלה?

914
00:57:19,520 --> 00:57:22,560
אנחנו צריכים דרך להביע את עצם קצת יותר גמישות

915
00:57:22,560 --> 00:57:25,080
מהמשתנים שלנו עד כה מותרים.

916
00:57:25,080 --> 00:57:29,000
היו לנו ints, היה לנו תווים, היה לנו צפתי וזוגות ועוד כמה,

917
00:57:29,000 --> 00:57:34,200
אבל אלה הם יצירות בודדות של זיכרון שלא באמת מאפשרות לנו לבטא את הדברים

918
00:57:34,200 --> 00:57:36,440
כמו מילים ומשפטים וביטויים.

919
00:57:36,440 --> 00:57:38,630
ואכן, יש לנו בשם מחרוזות דברים כאלה,

920
00:57:38,630 --> 00:57:42,660
אבל אנחנו מבטיחים שזה באמת רק בפישוט CS50 הספרייה

921
00:57:42,660 --> 00:57:45,540
שאנחנו מתכוונים לקלף.

922
00:57:45,540 --> 00:57:47,500
ואז הבה תתחיל לעשות את זה כאן.

923
00:57:47,500 --> 00:57:49,840
תן לי ללכת קדימה, לפתוח את קובץ -

924
00:57:49,840 --> 00:57:54,100
כל הקבצים הללו זמינים, כרגיל, באינטרנט - שנקרא array.c

925
00:57:54,100 --> 00:57:58,960
כדי לפתור בעיה שאינם קשורה למייתרים אבל זה מצייר תמונה כאן

926
00:57:58,960 --> 00:58:01,520
של איך אנחנו יכולים להשתמש במשהו שנקרא מערך.

927
00:58:01,520 --> 00:58:04,050
>> מערך הוא סוג נתונים.

928
00:58:04,050 --> 00:58:10,730
זה סוג משתנה של מיני שיש סוגי נתונים קטנים מרובים שבתוכה

929
00:58:10,730 --> 00:58:12,680
גב אל גב אל הגב אל גב.

930
00:58:12,680 --> 00:58:16,980
כך למשל, אם הייתי רוצה לכתוב תוכנה קטנה שנותנת לך ממוצעת החידון שלך

931
00:58:16,980 --> 00:58:19,780
לקורס כמו 50 שיש לה 2 חידונים,

932
00:58:19,780 --> 00:58:23,450
מאוד בקלות אתה יכול לכתוב תכנית זו מתבססת גם על חלק מהחומר של השבוע שעבר

933
00:58:23,450 --> 00:58:28,830
באמצעות GetInt וכמה משתנה: int quiz1, int quiz2.

934
00:58:28,830 --> 00:58:30,550
וזה די פשוט.

935
00:58:30,550 --> 00:58:33,500
זה אולי 10, 20 שורות קוד מקסימום כדי ליישם תכנית

936
00:58:33,500 --> 00:58:38,940
ששואל את המשתמש עבור 2 ציוני בחנים ואז מחשב הממוצע שלהם

937
00:58:38,940 --> 00:58:42,020
על ידי הוספה אותם יחד, חלוקה ידי 2, ולאחר מכן להדפיס את התוצאות.

938
00:58:42,020 --> 00:58:46,400
אנחנו ודאי יכולים לעשות את זה די בקלות עכשיו אחרי מספר מסוים של דקות.

939
00:58:46,400 --> 00:58:49,450
אבל הבעיה היא שמניח כי 50 היו 3 בחנים או 4.

940
00:58:49,450 --> 00:58:52,830
תניח שאתה רוצה להשתמש באותה התכנית לכיתה שהייתה שבועי חידונים.

941
00:58:52,830 --> 00:58:55,100
תחשוב על כיתה שיש חידונים שבועיים.

942
00:58:55,100 --> 00:58:58,840
אם יש 16 או כך שבועות בסמסטר, עכשיו יש לך 16 משתנים:

943
00:58:58,840 --> 00:59:03,030
int quiz1, int quiz2, int quiz3, quiz4 int.

944
00:59:03,030 --> 00:59:06,870
ברגע שאתה מתחיל לראות יתירות זה, זה העתקה והדבקה של קוד,

945
00:59:06,870 --> 00:59:09,810
זה צריך להתחיל לעשות רצונך הייתה דרך טובה יותר.

946
00:59:09,810 --> 00:59:13,610
ותודה לאל, כי מערכים שיש. אז בואו לעשות את זה.

947
00:59:13,610 --> 00:59:16,700
ראשית, הרשה לי להציג את דבר פשוט מאוד שאנחנו כבר לא בשימוש עד כה,

948
00:59:16,700 --> 00:59:18,820
אבל אתה רואה אותו מדי פעם בקוד.

949
00:59:18,820 --> 00:59:21,270
>> זה מה שנקרא באופן כללי קבועה.

950
00:59:21,270 --> 00:59:24,410
אז זה קבוע במובן זה שערך זה לא משנה.

951
00:59:24,410 --> 00:59:26,450
הכנס האנושי בעת יצירה מתמדת

952
00:59:26,450 --> 00:59:30,420
הוא להשתמש בכל האותיות, רק כדי שזה באמת בולט בקוד שלך,

953
00:59:30,420 --> 00:59:34,270
ומילת מפתח המיוחדת שאתה משתמש ב-C # היא להגדיר.

954
00:59:34,270 --> 00:59:39,970
אז אנחנו אומרים # להגדיר, לאחר מכן רווח, ואז את המילה שברצונך להשתמש לשם של הקבוע

955
00:59:39,970 --> 00:59:41,730
ואז הערך של הקבוע.

956
00:59:41,730 --> 00:59:44,710
שים לב זה שונה מהקצאת משהו משתנה.

957
00:59:44,710 --> 00:59:46,430
אין שום סימן שוויון, אין פסיק.

958
00:59:46,430 --> 00:59:49,140
זה מה שידוע בדרך כלל כהוראת preprocessor,

959
00:59:49,140 --> 00:59:50,840
אבל עוד על כך בפעם אחרת.

960
00:59:50,840 --> 00:59:56,350
לעת עתה, זה יוצר ערך בלתי משתנה נקרא חידונים

961
00:59:56,350 --> 00:59:58,290
הערך המספרי שבפועל הוא 2.

962
00:59:58,290 --> 01:00:02,180
אז בכל מקום שאתה רואה חידונים, שעשועונים, חידונים לאורך קובץ זה,

963
01:00:02,180 --> 01:00:04,230
זה רק המספר 2.

964
01:00:04,230 --> 01:00:06,550
אם אני מסתכל עיקרי עכשיו, בואו נראה איך זה עובד.

965
01:00:06,550 --> 01:00:09,770
בהתחלה זה נראה לא ברור מספיק, אבל זה כל הדברים משבוע 1.

966
01:00:09,770 --> 01:00:12,210
בקש מהמשתמש לכיתות. איך עושים את זה?

967
01:00:12,210 --> 01:00:17,350
בקו 22 - זה באמת החלק העסיסי - אני מצהיר לצוף

968
01:00:17,350 --> 01:00:23,240
אבל לא רק לצוף אחת. הריני מצהיר, אלא מערך ערכי נקודה צפה.

969
01:00:23,240 --> 01:00:27,700
זה משתנה הולך להיקרא ציונים, כפי שנרמז כאן,

970
01:00:27,700 --> 01:00:31,420
אבל רק לקטע של תחביר חדש אז הם הסוגריים מרובעים האלה.

971
01:00:31,420 --> 01:00:37,280
העובדה שאני כבר אמרתי את ציונים לצוף ואז סוגריים פתוחים ולאחר מכן מספר -

972
01:00:37,280 --> 01:00:40,980
תבחין אם זה קבוע זה בדיוק כמו שעשינו את זה -

973
01:00:40,980 --> 01:00:46,840
זה אומר, "היי מחשב, תן לי 2 צף ובואו ביחד קוראים להם ציונים".

974
01:00:46,840 --> 01:00:51,780
>> זאת בניגוד להרבה יותר משעמם תהליך כזה: מצוף grade1;

975
01:00:51,780 --> 01:00:54,580
לצוף grade2, וכך הלאה.

976
01:00:54,580 --> 01:00:58,310
אז מערך מאפשר לנו ליישם את הרעיון הזה, אבל הרבה פחות מבולגן,

977
01:00:58,310 --> 01:01:04,560
באופן כזה שאנחנו יכולים לכתוב קו 1 של קוד במקום, תניח, 16 לסמסטר 16-שבוע.

978
01:01:04,560 --> 01:01:09,060
אני לא רוצה קוד קשיח-2 משום שאם אתה חושב על זה עכשיו באופן הגיוני,

979
01:01:09,060 --> 01:01:12,560
מניח בשנה הבאה CS50 שינויי 3 בחנים במקום

980
01:01:12,560 --> 01:01:15,010
והיה לי את המספר 2 כאן, היה לי המספר 2 כאן,

981
01:01:15,010 --> 01:01:17,210
היה לי את המספר 2 לכאן, המספר 2 כאן.

982
01:01:17,210 --> 01:01:19,890
זה הופך להיות מאוד משעמם וקל מאוד לפשל

983
01:01:19,890 --> 01:01:26,550
ולשנות בטעות הערך 1-3 ומתגעגע ערך אחר של 2.

984
01:01:26,550 --> 01:01:30,660
אז אני הולך לשם במקום מופשט זה ולהשתמש בזה קבוע ש,

985
01:01:30,660 --> 01:01:32,520
כפי שהשם מרמז, לא משתנה לעולם.

986
01:01:32,520 --> 01:01:35,870
ועכשיו, לא משנה אם יש לנו אחר בחנים או השנה הבאה,

987
01:01:35,870 --> 01:01:39,380
אני רק צריך לשנות אותו במקום אחד כאן בראש.

988
01:01:39,380 --> 01:01:41,230
אז זה כל מה שקבוע הוא.

989
01:01:41,230 --> 01:01:47,100
בינתיים, התכונה הרעיונית החדשה היא זה של מערך.

990
01:01:47,100 --> 01:01:55,030
אז הסוגריים המרובעים ינתנו לי הרבה זה צף ומאפשר לי לקרוא להם ציונים קולקטיביים כאן.

991
01:01:55,030 --> 01:01:56,720
אז עכשיו בואו נראה מה אני הולך לעשות.

992
01:01:56,720 --> 01:01:59,220
כאן, בקו 24 היא תחילתו של ללולאה.

993
01:01:59,220 --> 01:02:03,380
>> זה באמת שום דבר מהודר. זה פשוט באמצעות חידונים במקום מספר קבוע בקוד.

994
01:02:03,380 --> 01:02:06,740
אבל אין שום דבר שונה מבחינה אינטלקטואלית לשם בשבוע שעבר.

995
01:02:06,740 --> 01:02:11,650
זה רק printf, אז printf ("החידון ד #% מ% ד:")

996
01:02:11,650 --> 01:02:16,670
כי אני פשוט רוצה להדפיס לי חידון מספר 1 מתוך 2 ולאחר מכן 2 מתוך 2.

997
01:02:16,670 --> 01:02:18,480
אז זה דבר אסתטי.

998
01:02:18,480 --> 01:02:21,000
אבל חלק המעניין כרגע הוא בקו 27.

999
01:02:21,000 --> 01:02:27,840
כדי למלא באחת משני מצייני המיקום עם ערך נקודה צפה,

1000
01:02:27,840 --> 01:02:29,640
שוב להשתמש בסוגריים מרובעים.

1001
01:02:29,640 --> 01:02:35,170
במקרה זה, אני משתמש בזה בשבילי, כי לולאה החל עם אני שווה איזה ערך, כנראה?

1002
01:02:35,170 --> 01:02:36,670
[תלמיד] 0. >> [מלאן] 0.

1003
01:02:36,670 --> 01:02:40,990
אז באיטרציה הראשונה של לולאה זה, זה כאילו אני כתבתי את זה בקוד,

1004
01:02:40,990 --> 01:02:46,310
אבל באיטרציה השנייה של הלולאה הזו, זה כאילו אני כתבתי את זה בקוד שלי.

1005
01:02:46,310 --> 01:02:49,970
אבל העובדה שאני משתמש במשתנה היא מושלמת, כי, כפי שהשם מרמז,

1006
01:02:49,970 --> 01:02:52,600
זה משתנה את הערך שלו בכל איטרציה,

1007
01:02:52,600 --> 01:02:55,900
אז אני ממלא מערך זה נקודה אחת בכל פעם.

1008
01:02:55,900 --> 01:02:57,380
מה מערך זה נראה לך?

1009
01:02:57,380 --> 01:03:01,570
הסיבה ציירתי מלבן פשוט סופר על המסך כאן לפני הייתה מסיבה זו.

1010
01:03:01,570 --> 01:03:05,590
מערך הוא פשוט גוש של זיכרון ואחריו עוד נתח של זיכרון

1011
01:03:05,590 --> 01:03:08,570
אחריו עוד נתח של זיכרון וכן הלאה.

1012
01:03:08,570 --> 01:03:13,120
אז אם המערך שלי הוא בגודל 2 במקרה זה כאן, כל מה שאני היה עושה

1013
01:03:13,120 --> 01:03:20,200
על ידי הקלדת ציוני הבחנים שלי כמו כאן - יש לי 100 על זה ואז יש לי 99 על זה -

1014
01:03:20,200 --> 01:03:24,970
אז הזיכרון הזה לא יכול גם לשמש כי אני כבר שאלתי את המחשב רק

1015
01:03:24,970 --> 01:03:26,840
עבור מערך בגודל 2.

1016
01:03:26,840 --> 01:03:28,600
הריבועים האלה עדיין נמצאים שם, נכון?

1017
01:03:28,600 --> 01:03:32,670
עדיין יש לך 2 ג'יגה זכרון RAM גם אם אתה רק מבקש 2 מצופים.

1018
01:03:32,670 --> 01:03:36,840
אז הרעיון מאחורי מערכים הוא שהמחשב פשוט לוקח נתח של זיכרון

1019
01:03:36,840 --> 01:03:41,340
ולאחר מכן מקצה בחתיכות קטנות יותר גב אל גב אל הגב אל גב.

1020
01:03:41,340 --> 01:03:43,310
ואז זה כל מערך הוא.

1021
01:03:43,310 --> 01:03:47,350
>> זה נתח רציף בתוך זיכרון שלו אתה יכול לשים את הדברים.

1022
01:03:47,350 --> 01:03:50,700
זה קורה אז לעשות בדיוק כמה חישובים משעממים.

1023
01:03:50,700 --> 01:03:54,640
אם אני לגלול למטה כאן, זה מקום שבי אז לחזר על המערך.

1024
01:03:54,640 --> 01:03:58,020
אני בא עם הסיכום של כל הערכים במערך,

1025
01:03:58,020 --> 01:04:02,470
ואז להשתמש בפונקצית הסיבוב כאן למעשה לעשות סכום מחולק בחידונים.

1026
01:04:02,470 --> 01:04:06,320
אבל תן לי להניף את היד שלי שבכל סוג של חשבון מספיק לעת עתה.

1027
01:04:06,320 --> 01:04:08,370
אבל כל מה שהוא עושה עבורי בסופו החישוב ממוצע.

1028
01:04:08,370 --> 01:04:13,580
אז חידון 1 חידון בתוספת 2 חלקי 2 ולאחר מכן להדפיס את זה כמו int.

1029
01:04:13,580 --> 01:04:17,280
אבל בואו עכשיו מעבר לדוגמה אחרת הנקראת string1,

1030
01:04:17,280 --> 01:04:20,700
אשר מצייר תמונה דומה אבל מייתרי שימוש.

1031
01:04:20,700 --> 01:04:23,940
תן לי ללכת קדימה ולפשט את זה לרגע.

1032
01:04:23,940 --> 01:04:27,090
סלח לי על הכניסה לעת עתה.

1033
01:04:27,090 --> 01:04:30,870
הודעה בקו 19 של דוגמה זו, אני מקבל מחרוזת מהמשתמש.

1034
01:04:30,870 --> 01:04:34,640
אבל שים לב למה שאני עושה בא בשורות 22 ואילך.

1035
01:04:34,640 --> 01:04:41,250
בעצם אני iterating מעד - וזה טריק חדש - strlen, אורך מחרוזת.

1036
01:04:41,250 --> 01:04:44,880
זוהי פונקציה שמגיעה עם C שאם אתה עובר אותו חוט,

1037
01:04:44,880 --> 01:04:47,730
זה אומר לך כמה תווים שבמחרוזת. זה הכל.

1038
01:04:47,730 --> 01:04:51,550
והעובדה שזה strlen במקום אורך מחרוזת היא רק בגלל שזה תמציתי יותר.

1039
01:04:51,550 --> 01:04:55,100
לפני שלושים שנה, אנשים אוהבים לכתוב דברים באופן תמציתי ככל האפשר,

1040
01:04:55,100 --> 01:04:57,630
אז אנחנו כבר המשכנו את כנס זה כאן.

1041
01:04:57,630 --> 01:05:00,660
אני + + רק אומר להגדיל i בכל איטרציה.

1042
01:05:00,660 --> 01:05:02,990
ועכשיו שם לב זה, וזה באמת מעניין.

1043
01:05:02,990 --> 01:05:09,180
בקו 24, אני אומר, "מחשב, תן לי אופי, 8 ביטים, וקורא לו ג."

1044
01:05:09,180 --> 01:05:12,630
אבל מה זה בצד ימין אומר?

1045
01:05:13,490 --> 01:05:16,530
באנגלית, מה זה מייצג?

1046
01:05:16,530 --> 01:05:18,730
[תלמיד] התו הראשון במערך.

1047
01:05:18,730 --> 01:05:20,790
בדיוק. תן לי את התו הראשון במערך.

1048
01:05:20,790 --> 01:05:24,090
או, באופן כללי יותר, תן לי את תו ה-i במערך.

1049
01:05:24,090 --> 01:05:26,100
ומבין שזה חשוב עכשיו שכמדעני מחשב,

1050
01:05:26,100 --> 01:05:27,890
אנחנו למעשה לספור מ 0.

1051
01:05:27,890 --> 01:05:29,720
>> אין לך שיקול דעת עכשיו להתחיל לעשות את זה.

1052
01:05:29,720 --> 01:05:34,160
עכשיו אתה צריך להתנהג בהתאם לציפיות של המחשב ולספור מ 0

1053
01:05:34,160 --> 01:05:38,180
כי [0] הולך להיות התו הראשון במחרוזת,

1054
01:05:38,180 --> 01:05:42,150
[1] הוא הולך להיות שני, [2] הולך להיות שלישי, וכך הלאה.

1055
01:05:42,150 --> 01:05:49,720
אז התכנית הזאת, אם אני לקמפל את זה, זה שוב string1, אז לעשות את string1,

1056
01:05:49,720 --> 01:05:54,670
ועכשיו נגמרתי לי string1 בחלון המסוף שלי.

1057
01:05:54,670 --> 01:05:58,330
הוא מחכה לקלט, אז אני הולך להקלדה בדוד, זן,

1058
01:05:58,330 --> 01:06:02,540
ועכשיו הוא מדפיס את כל דוד על קווים שונים, בגלל הודעה מה שאני עושה.

1059
01:06:02,540 --> 01:06:05,820
אני מדפיס תו אחד בכל פעם.

1060
01:06:05,820 --> 01:06:10,100
אנחנו לא נכנסנו לפרטי פרטים היום על זה, אבל אני מחקתי לפני רגע סימון זו כאן.

1061
01:06:10,100 --> 01:06:15,480
מסתבר שאם המשתמש אינו מתנהג כשורה, יריבות, או סתם מבולבל,

1062
01:06:15,480 --> 01:06:20,210
אתה בעצם יכול להיכשל לתת מחרוזת באורך מסוים.

1063
01:06:20,210 --> 01:06:22,860
אם אתה מכה על המקש הלא הנכון במקלדת, ייתכן שלא לתת מחרוזת בכלל,

1064
01:06:22,860 --> 01:06:26,950
או אם אתה זדוני, ייתכן שתנסה להדביק בשווי של ג'יגה של מאמר

1065
01:06:26,950 --> 01:06:29,290
כדי למלא את הערך הזה, ואם המחשב פועל מתוך זיכרון,

1066
01:06:29,290 --> 01:06:32,710
מתבררים שאנחנו הולכים לקבל בחזרה הערך המיוחד הזה שנקרא NULL.

1067
01:06:32,710 --> 01:06:35,580
אז לעת עתה, רק יודע שיש הערך המיוחד הזה שנקרא NULL

1068
01:06:35,580 --> 01:06:39,580
שיאפשר לנו לבדוק כאשר אנחנו יוצאים מזיכרון, בין השאר.

1069
01:06:39,580 --> 01:06:45,630
אבל אם אני פותח עכשיו string2, תבחין בהבדל אחד כאן.

1070
01:06:45,630 --> 01:06:48,210
שים לב הבדל אחד כאן עם string2.

1071
01:06:48,210 --> 01:06:51,340
עם string2, זה ללולאה הוא קצת שונה.

1072
01:06:51,340 --> 01:06:55,010
>> תן לי למחוק את ערכי null כדי שנוכל לדבר על הדברים האלה בפעם אחרת.

1073
01:06:55,010 --> 01:06:57,800
מה שונה ללולאת הזמן הזה?

1074
01:06:59,620 --> 01:07:01,670
אני יכול לחזור לדוגמה הקודמת.

1075
01:07:01,670 --> 01:07:08,580
אז זה גרסה 2, זו היא גרסה 1. 1, 2.

1076
01:07:08,580 --> 01:07:11,980
1, 2.

1077
01:07:13,520 --> 01:07:16,660
Strlen השיחה היא איפה?

1078
01:07:16,660 --> 01:07:18,860
זה בחלקו הראשון של ללולאה.

1079
01:07:18,860 --> 01:07:21,830
כל מחשבות, מדוע אני עושה את זה? כן.

1080
01:07:21,830 --> 01:07:24,560
[תלמיד] אז אתה לא קורא לפונקציה בכל פעם אחת.

1081
01:07:24,560 --> 01:07:26,440
[מלאן] אז אנחנו לא קוראים לפונקציה בכל פעם אחת. בדיוק.

1082
01:07:26,440 --> 01:07:28,300
היזכר ללולאות שהם פשוט סופר

1083
01:07:28,300 --> 01:07:31,770
ברגע שאתה סוג של להבין שזה אתחול, התנאי והעדכון.

1084
01:07:31,770 --> 01:07:34,750
הבעיה היא שהמצב שקורה בכל איטרציה של הלולאה.

1085
01:07:34,750 --> 01:07:40,010
וכך בדוגמה זו כאן, מה רע בעובדה שמדובר במצב שלי?

1086
01:07:40,010 --> 01:07:41,830
[תלמיד] אתה קורא strlen.

1087
01:07:41,830 --> 01:07:44,340
[מלאן] אתה קורא strlen שוב ושוב ושוב.

1088
01:07:44,340 --> 01:07:47,410
אבל ברגע שהקלדתי בדוד, שאורך המחרוזת הוא 5,

1089
01:07:47,410 --> 01:07:49,650
וזה לא הולך להשתנות בכל איטרציה של הלולאה

1090
01:07:49,650 --> 01:07:51,670
כי המחרוזת היא עדיין D--V-i-ד.

1091
01:07:51,670 --> 01:07:55,320
אז זה רמז למה שהולך להיות יותר ויותר חשוב רעיון

1092
01:07:55,320 --> 01:08:00,410
מכונה עיצוב החלטה בי פשוט לא להפוך את המחשב לעשות עבודה מיותרת.

1093
01:08:00,410 --> 01:08:03,920
>> בדיוק כמו צצה מקדימה של pset2, pset2 במהדורה הסטנדרטית

1094
01:08:03,920 --> 01:08:07,030
הוא הולך לאתגר אותך למעשה ליישם חלק המספר של צופן,

1095
01:08:07,030 --> 01:08:10,410
חלק מספר אלגוריתמי הצפנה, כך שאתה יכול גם להצפין

1096
01:08:10,410 --> 01:08:13,840
ומסרים סודיים לפענח הרבה כמו ראלפי אחד יש פוענח.

1097
01:08:13,840 --> 01:08:16,810
במהדורה של האקר pset2, אנחנו הולכים ללכת עוד קצת.

1098
01:08:16,810 --> 01:08:19,649
אנחנו הולכים למסור לך קובץ ממערכת מחשב בפועל

1099
01:08:19,649 --> 01:08:23,479
המכיל כל חבורה של שמות משתמש וסיסמות מוצפנות בפועל,

1100
01:08:23,479 --> 01:08:26,939
והאתגר עבור מהדורת ההאקר הולך להיות לפיצוח הסיסמות האלה

1101
01:08:26,939 --> 01:08:33,200
ולהבין מה קריפטוגרפיה או מה הסוד שמש בפועל ליצירת הסיסמות האלה.

1102
01:08:33,200 --> 01:08:36,109
ואנחנו הולכים לעשות את זה על ידי שימוש בתכונה חדשה של C כאן

1103
01:08:36,109 --> 01:08:40,630
שאני אתן לך רק הדגמה של המכונית טיעוני שורת פקודה.

1104
01:08:40,630 --> 01:08:44,229
מתברר, כפי שחלקכם אולי ראה בסעיף או בספרי לימוד,

1105
01:08:44,229 --> 01:08:48,260
עיקרי לא תמיד צריך להיות מבוטל בסוגריים.

1106
01:08:48,260 --> 01:08:52,430
מתברר שראשי יכול גם להיות כתוב ככה, בשני טיעונים,

1107
01:08:52,430 --> 01:08:56,870
argc וargv, שם argc הוא מספר המילים

1108
01:08:56,870 --> 01:09:00,020
לאחר שהקלדת את שמה של התכנית בשורת הפקודה שלך

1109
01:09:00,020 --> 01:09:03,420
וargv הוא את המילים עצמן.

1110
01:09:03,420 --> 01:09:07,540
וכמו הסוגריים המרובעים שם מציעים, argv הוא כנראה מערך.

1111
01:09:07,540 --> 01:09:12,210
זה הולך להיות מחרוזת אחרי מחרוזת אחרי מחרוזת בזיכרון.

1112
01:09:12,210 --> 01:09:16,010
>> אז מה אנחנו הולכים להיות מסוגלים לעשות את החלנו בpset 2 הוא משהו כזה.

1113
01:09:16,010 --> 01:09:21,350
אם אני עושה argv1, שהוא דוגמה תוכל לחזור אליו ביום שני, ולהפעיל אותו,

1114
01:09:21,350 --> 01:09:23,370
שם לב שהוא לא מצליח לעשות שום דבר עדיין.

1115
01:09:23,370 --> 01:09:25,490
זה פשוט מדפיס את שמו שלו.

1116
01:09:25,490 --> 01:09:31,479
אבל אם אומר שמעמד פרידה, שימו לב שתכנית זו כנראה סובב

1117
01:09:31,479 --> 01:09:35,479
על כל אחת מהמילים שהוקלדו בשורת הפקודה.

1118
01:09:35,479 --> 01:09:41,630
ואת האמצעי שבעזרתו אנו מקבלים גישה למילים שהמשתמש הקליד בשורת הפקודה

1119
01:09:41,630 --> 01:09:49,160
היא על ידי השינוי העיקרי החל מסוף השבוע הזה int הראשי (ריק) לint ראשי (argc, argv)

1120
01:09:49,160 --> 01:09:52,050
וכך יהיה נולד טיעוני שורת פקודה.

1121
01:09:52,050 --> 01:09:57,100
וברגע שאתה מקבל באמת מתוחכם בזה, תוכל לכתוב תוכניות ממש trippy

1122
01:09:57,100 --> 01:09:59,610
כמו זו כאן, שהולכת מעל ומעבר

1123
01:09:59,610 --> 01:10:03,940
חלק מהפונקציונליות שעשינו עד כה, אבל כולם די חזק.

1124
01:10:03,940 --> 01:10:08,950
>> אז אשאיר את זה עם זה על המסך, ואנו רואים אותך ביום שני.

1125
01:10:17,570 --> 01:10:20,000
>> [CS50.TV]