1
00:00:00,000 --> 00:00:10,103

2
00:00:10,103 --> 00:00:11,270
>> ZAMYLA צ'אן: מזל טוב
בגמר שלך

3
00:00:11,270 --> 00:00:13,200
כמה תוכניות C הראשון.

4
00:00:13,200 --> 00:00:16,379
אני יודע שההסתערות הראשונה שלך לתוך
תחביר C יכול להיות מרתיע.

5
00:00:16,379 --> 00:00:20,060
אבל אני מבטיח לך, בסופו של
כמובן, אתה יכול להסתכל על

6
00:00:20,060 --> 00:00:23,870
כמה משימות ראשונה ו
להשלים אותם בתוך דקות.

7
00:00:23,870 --> 00:00:27,830
>> עכשיו שאתה מקבל יותר מוכר
עם תחביר, בואו לקבל לקיסר.

8
00:00:27,830 --> 00:00:31,720
בקיסר, המשתמש יגיש
מפתח שלם כשורת פקודת

9
00:00:31,720 --> 00:00:35,300
ויכוח, ולאחר מכן להזין רגיל
הודעת טקסט בשורת הפקודה.

10
00:00:35,300 --> 00:00:38,050
אז תכנית צופן
הטקסט וההדפסה

11
00:00:38,050 --> 00:00:40,020
ההודעה המוצפנת שלהם.

12
00:00:40,020 --> 00:00:42,980
>> Enciphering לקיסר
הוא די פשוט.

13
00:00:42,980 --> 00:00:46,455
Shift כל אות, בהם
טקסט רגיל, על ידי המפתח.

14
00:00:46,455 --> 00:00:49,220
כתוצאה מכך, זה גם
די חסר ביטחון.

15
00:00:49,220 --> 00:00:53,850
אבל ליישם את הקיסר יציג
לנו נתונים ומערך ASCIIMath

16
00:00:53,850 --> 00:00:54,460
מבנים.

17
00:00:54,460 --> 00:00:57,510
אנחנו נגיע למורכבים יותר
צופן מאוחר יותר.

18
00:00:57,510 --> 00:01:01,680
עם מפתח של קיסר 2, מכתב ב
טקסט רגיל יהיה מיוצג על ידי

19
00:01:01,680 --> 00:01:07,580
ג במכתב מוצפן כי C
הוא שתי אותיות א 'ב' לאחר תהיה

20
00:01:07,580 --> 00:01:12,450
מיוצג על ידי D ו-C על ידי א 'לקראת
סופו של האלפבית, W הוא

21
00:01:12,450 --> 00:01:18,550
מיוצג על ידי Y, X ועל ידי צ'אבל Y
אין שתי אותיות אחרי זה, אז

22
00:01:18,550 --> 00:01:21,070
את צופן עוטף את האלפבית.

23
00:01:21,070 --> 00:01:27,190
Y בטקסט רגיל ובכך מיוצג על ידי
בהודעה המוצפנת, ו-Z על ידי ב 'זה אולי

24
00:01:27,190 --> 00:01:32,080
לעזור לצפייה בסייפר הקיסר כמו
גלגל האלפבית רציף.

25
00:01:32,080 --> 00:01:35,760
>> כדי להצפין את הטקסט שלהם, המשתמש
ייכנס שני טיעונים

26
00:01:35,760 --> 00:01:37,090
לשורת הפקודה -

27
00:01:37,090 --> 00:01:40,010
. / קיסר ואחריו מפתח.

28
00:01:40,010 --> 00:01:44,710
כמו תמיד, אנחנו לא יכולים לסמוך על המשתמש
לחלוטין להזנת קלט שעושה

29
00:01:44,710 --> 00:01:45,800
מובן לתכנית שלנו.

30
00:01:45,800 --> 00:01:50,670
אז אנחנו נצטרך לאמת אותם
קלט שורת הפקודה.

31
00:01:50,670 --> 00:01:57,285
>> במקום להשתמש בחלל עיקרי int, אנחנו
באמצעות תכנית + int ראשי, int, מחרוזת argv.

32
00:01:57,285 --> 00:02:01,730
Argc משתנה השלם מייצג
מספר הארגומנטים שמועברים ל

33
00:02:01,730 --> 00:02:02,880
בשורת הפקודה.

34
00:02:02,880 --> 00:02:09,070
וargv הוא מערך, או לחשוב על זה כעל
רשימה, הטיעונים עברה פנימה

35
00:02:09,070 --> 00:02:12,000
>> אז לקיסר, איך אנחנו לאמת
הקלט של המשתמש?

36
00:02:12,000 --> 00:02:15,870
ובכן, הם צריכים רק להיכנס
שני טיעוני שורת הפקודה -

37
00:02:15,870 --> 00:02:18,150
. / קיסר ומפתח.

38
00:02:18,150 --> 00:02:22,340
אז אם argc הוא לא 2, זה אומר ש
הם גם שכחו את מפתח ורק

39
00:02:22,340 --> 00:02:27,230
נכנס. / קיסר, או שהם
נכנס מספר מפתחות.

40
00:02:27,230 --> 00:02:29,770
>> אם זה המקרה, אז אתה
רוצה הוראות להדפסה

41
00:02:29,770 --> 00:02:30,910
ולצאת מהתכנית.

42
00:02:30,910 --> 00:02:34,320
הם יצטרכו לנסות שוב
משורת הפקודה.

43
00:02:34,320 --> 00:02:37,430
אבל גם אם argc הוא 2, אתה
צריך לבדוק אם הם

44
00:02:37,430 --> 00:02:39,100
אתן לך מפתח חוקי.

45
00:02:39,100 --> 00:02:40,730
לקיסר, אתה צריך מספר שלם.

46
00:02:40,730 --> 00:02:43,260
אבל argv הוא מערך של מחרוזות.

47
00:02:43,260 --> 00:02:46,490
איך לגשת למפתח זה?

48
00:02:46,490 --> 00:02:47,850
>> מבט מהיר על מערכים -

49
00:02:47,850 --> 00:02:51,410
מבני נתונים המחזיקים במספר רב של
ערכים מאותו סוג נתונים.

50
00:02:51,410 --> 00:02:55,350
ערכים הם אפס למדד, כלומר
המרכיב הראשון הוא אפס המדד

51
00:02:55,350 --> 00:03:00,260
והאלמנט האחרון הוא בגודל אינדקס
1 מינוס, שבו גודל הוא מספר

52
00:03:00,260 --> 00:03:02,850
אלמנטים במערך.

53
00:03:02,850 --> 00:03:07,380
>> אם אני הכריז תיבת דואר של מערך מחרוזת חדשה
אורך של 3, מבחינה ויזואלית, זה

54
00:03:07,380 --> 00:03:08,570
נראה כך.

55
00:03:08,570 --> 00:03:11,520
שלוש מכולות למחרוזות
, זה לצד זה.

56
00:03:11,520 --> 00:03:15,445
כדי לגשת לכל אלמנט, אתה מקליד את השם
של המערך ולאחר מכן מצביע על

57
00:03:15,445 --> 00:03:18,080
המדד בסוגריים מרובעים.

58
00:03:18,080 --> 00:03:21,610
הנה, אני הקצאת ערך לכל אחד
אלמנט, בדיוק כפי שהייתי עושה עם כל

59
00:03:21,610 --> 00:03:24,310
משתנה מחרוזת אחרת.

60
00:03:24,310 --> 00:03:29,020
>> אז לגשת לשורת פקודת הטיעונים שלנו,
כל מה שאנחנו צריכים לעשות הוא לגשת

61
00:03:29,020 --> 00:03:31,690
האלמנט הנכון של מערך argv.

62
00:03:31,690 --> 00:03:37,360
אם המשתמש נכנס צוות. / Blastoff
רקטות לעבר המסוף, argv 0 הייתם

63
00:03:37,360 --> 00:03:38,950
להיות. / blastoff.

64
00:03:38,950 --> 00:03:45,010
argv יהיה צוות, ו
ARG2 יהיה טילים.

65
00:03:45,010 --> 00:03:47,670
>> עכשיו אנחנו יכולים לגשת המפתח שלנו,
אנחנו עדיין צריכים לעשות

66
00:03:47,670 --> 00:03:49,040
בטוח שזה נכון.

67
00:03:49,040 --> 00:03:51,060
אנחנו צריכים להפוך אותו למספר שלם.

68
00:03:51,060 --> 00:03:54,680
אבל אנחנו לא יכולים פשוט להטיל כמו
מה שעשינו בעבר.

69
00:03:54,680 --> 00:03:58,800
למזלנו, לפונקצית Y דואגת
זה בשבילנו, ואפילו מחזיר 0

70
00:03:58,800 --> 00:04:02,110
אם לא ניתן להמיר את המחרוזת
למספר שלם.

71
00:04:02,110 --> 00:04:04,450
זה תלוי בך, אם כי, כדי לספר
המשתמש למה אתה לא

72
00:04:04,450 --> 00:04:06,220
לתת התכנית להמשיך.

73
00:04:06,220 --> 00:04:10,710
אחסן את התוצאה ל Y ב
מספר שלם, ויש לך את המפתח שלך.

74
00:04:10,710 --> 00:04:12,070
החלק הבא הוא פשוט.

75
00:04:12,070 --> 00:04:15,940
תנחה את המשתמש לטקסט רגיל שלהם,
שיהיה מסוג מחרוזת הנתונים.

76
00:04:15,940 --> 00:04:18,339
למזלנו, כל המשתמש שהוזנו
מחרוזות הן חוקיות.

77
00:04:18,339 --> 00:04:21,170

78
00:04:21,170 --> 00:04:24,760
>> עכשיו שיש לנו את כל הקלט הדרוש
מהמשתמש, זה זמן בשבילנו

79
00:04:24,760 --> 00:04:26,520
להצפין את המסר שלהם.

80
00:04:26,520 --> 00:04:29,200
הרעיון של קיסר הוא פשוט
מספיק כדי להבין.

81
00:04:29,200 --> 00:04:33,750
אבל איך יודע שהמחשב שלך
מכתבים הגיעו לאחר עוד אחד?

82
00:04:33,750 --> 00:04:36,100
>> כאן מקום טבלת ASCII נכנס

83
00:04:36,100 --> 00:04:39,420
לכל תו מספר שלם
מספר משויך אליו.

84
00:04:39,420 --> 00:04:41,380
הון הוא 65.

85
00:04:41,380 --> 00:04:43,310
ההון ב 'הוא 66.

86
00:04:43,310 --> 00:04:45,260
אותיות קטנות הוא 97.

87
00:04:45,260 --> 00:04:47,590
ב אותיות קטנות הוא 98.

88
00:04:47,590 --> 00:04:50,770
אבל דמויות לא מוגבלות
לרק מספרי האלפבית.

89
00:04:50,770 --> 00:04:56,020
לדוגמה, סימן @
64 הוא מספר ASCII.

90
00:04:56,020 --> 00:04:59,690
>> לפני ההתמודדות עם כל המחרוזת,
בואו נעמיד פנים שאנחנו פשוט צריכים לעבור

91
00:04:59,690 --> 00:05:01,220
תו אחד.

92
00:05:01,220 --> 00:05:04,640
ובכן, אנחנו רק רוצים להעביר בפועל
אותיות בטקסט רגיל, ולא

93
00:05:04,640 --> 00:05:06,020
תווים או מספרים.

94
00:05:06,020 --> 00:05:09,100
אז הדבר הראשון שאנחנו רוצים
לבדוק הוא אם הדמות היא ב

95
00:05:09,100 --> 00:05:10,430
האלפבית.

96
00:05:10,430 --> 00:05:14,460
>> Isalpha הפונקציה עושה את זה בשביל
שלנו ומחזיר בוליאני -

97
00:05:14,460 --> 00:05:18,570
נכון, אם הדמויות הוא מכתב,
שקר, אם בדרך אחרת.

98
00:05:18,570 --> 00:05:22,270
שתי פונקציות שימושיות אחרות
isupper וislower, עם

99
00:05:22,270 --> 00:05:23,860
שמות מובן מאליו.

100
00:05:23,860 --> 00:05:27,370
הם חוזרים נכון אם התו נתון
הוא אותיות גדולות או קטנה,

101
00:05:27,370 --> 00:05:28,740
בהתאמה.

102
00:05:28,740 --> 00:05:33,770
מאז הם Booleans, הם
שימושית לשימוש כתנאים.

103
00:05:33,770 --> 00:05:38,310
>> אם isalpha מחזיר אמיתי, תצטרך
להעביר את הדמות שעל ידי המפתח.

104
00:05:38,310 --> 00:05:43,750
אז בואו תפתחו לASCIIMath
ולעשות קצת מתמטיקה ASCII.

105
00:05:43,750 --> 00:05:48,700
השימוש דומה מאוד לשימוש
לקיסר ולוקח במפתח ב

106
00:05:48,700 --> 00:05:50,870
שורת הפקודה.

107
00:05:50,870 --> 00:05:59,590
>> אם אני מפעיל ASCIIMath 5, נראה שזה יוסיף
5 ל, נותן לי את המכתב F, ו

108
00:05:59,590 --> 00:06:01,260
הצגת ערך ASCII.

109
00:06:01,260 --> 00:06:04,090
אז בואו נסתכל על התכנית.

110
00:06:04,090 --> 00:06:11,820
>> אתם עשויים לתהות, ממש כאן, למה
מכתב הוא מספר שלם, כאשר זה

111
00:06:11,820 --> 00:06:14,330
באופן ברור, טוב, מכתב.

112
00:06:14,330 --> 00:06:17,690
מתברר שדמויות ו
מספרים שלמים וניתנים להחלפה.

113
00:06:17,690 --> 00:06:21,730
על ידי לשים את המכתב באחד
מרכאות, המספר השלם יכולים לאחסן

114
00:06:21,730 --> 00:06:25,390
ערך ASCII של בירה
א 'תיזהר, אם כי.

115
00:06:25,390 --> 00:06:27,150
אתה צריך את בגדים בודדים.

116
00:06:27,150 --> 00:06:31,260
בלי מרכאות בודדות,
המהדר הייתי מחפש משתנה

117
00:06:31,260 --> 00:06:35,510
בשם, ולא אופי.

118
00:06:35,510 --> 00:06:42,140
>> ואז אני מוסיף מכתב ומפתח, אחסון
סכום בתוצאת משתני int.

119
00:06:42,140 --> 00:06:47,740
למרות שתוצאה היא מסוג הנתונים
מספר שלם, הצהרת printf משתמשת

120
00:06:47,740 --> 00:06:50,370
% מציין מיקום ג לתווים.

121
00:06:50,370 --> 00:06:54,530
אז התכנית מדפיסה את התו
קשור עם תוצאת המספר השלם.

122
00:06:54,530 --> 00:07:00,400
ומאחר שהדפסנו את המספר השלם
טופס גם באמצעות% d, אנו רואים

123
00:07:00,400 --> 00:07:02,110
המספר גם כן.

124
00:07:02,110 --> 00:07:04,450
אז עכשיו אתה יכול לראות שאנחנו
טיפול בדמויות ו

125
00:07:04,450 --> 00:07:06,980
מספרים שלמים, ולהיפך.

126
00:07:06,980 --> 00:07:12,205
>> בואו לבדוק כמה ASCIIMath
יותר פעמים באמצעות 25 כמפתח.

127
00:07:12,205 --> 00:07:15,510

128
00:07:15,510 --> 00:07:17,090
אנחנו מקבלים את אות Z.

129
00:07:17,090 --> 00:07:19,750
עכשיו אנחנו מנסים 26.

130
00:07:19,750 --> 00:07:25,600
אנחנו רוצים לקבל את המכתב, אבל
במקום זה אנחנו מקבלים סוגר שמאלי.

131
00:07:25,600 --> 00:07:29,490
אז ברור, רק מוסיף
מפתח למכתב לא יעשה.

132
00:07:29,490 --> 00:07:32,780
אנחנו צריכים להבין את נוסחה כדי לעטוף
מסביב לאותיות, כמו שלנו

133
00:07:32,780 --> 00:07:34,570
למשל בהתחלה עשה את זה.

134
00:07:34,570 --> 00:07:38,520
>> נוסחה לקיסר
שינוי הוא כדלקמן.

135
00:07:38,520 --> 00:07:42,750
ג עמ 'שווה בתוספת K מודולו 26.

136
00:07:42,750 --> 00:07:46,040
זכור כי מודולו הוא שימושי
מבצע שנותן לנו את השארית

137
00:07:46,040 --> 00:07:49,880
של חלוקת מספר אחד על ידי השנייה.

138
00:07:49,880 --> 00:07:54,870
בואו ליישם את נוסחה הזאת למישור
מכתב טקסט עם מפתח של 2.

139
00:07:54,870 --> 00:08:01,810
ערך ASCII של Y הוא 89, אשר
נותן לנו 91 מודולו 26,

140
00:08:01,810 --> 00:08:03,690
אשר שווה 13 -

141
00:08:03,690 --> 00:08:08,740
בהחלט לא ערך ASCII
של, שהוא 67.

142
00:08:08,740 --> 00:08:12,810
>> לרצות אותי עכשיו ולהתרחק
ערכי ASCII למדד אלפביתי

143
00:08:12,810 --> 00:08:18,690
שבו הוא אפס וZ הוא 25,
כלומר Y הוא 24.

144
00:08:18,690 --> 00:08:25,830
24 2 בתוספת, 6 מודולו, נותנת לנו 26,
26 מודולו, 0, שהוא

145
00:08:25,830 --> 00:08:28,170
אינדקס אלפביתי של.

146
00:08:28,170 --> 00:08:32,980
כך נראית נוסחה זו שתחול על
אינדקס אלפביתי של המכתב ו

147
00:08:32,980 --> 00:08:34,960
הערך שלו לא ASCII.

148
00:08:34,960 --> 00:08:37,630
>> אבל אתה מתחיל עם ערכי ASCII.

149
00:08:37,630 --> 00:08:41,650
ולהדפיס את התו המוצפן,
תצטרך ערך ASCII שלו גם כן.

150
00:08:41,650 --> 00:08:46,400
זה תלוי בך, אם כן, כדי להבין
איך לעבור קדימה ואחורה.

151
00:08:46,400 --> 00:08:49,850
>> ברגע שאתה להבין את נוסחה הנכונה
עבור תו אחד, כל מה שאתה צריך לעשות

152
00:08:49,850 --> 00:08:53,520
הוא להחיל את אותה נוסחה לכל
מכתב בטקסט רגיל -

153
00:08:53,520 --> 00:08:57,720
רק אם אות זו היא אלפביתי,
כמובן.

154
00:08:57,720 --> 00:09:02,360
וזכור כי אתה צריך לשמור
המקרה, עליון או תחתון, זה שבו

155
00:09:02,360 --> 00:09:06,890
isUpper ופונקציות isLower
ציינו קודם לכן יהיה שימושי.

156
00:09:06,890 --> 00:09:08,830
אולי יש לך שתי נוסחאות -

157
00:09:08,830 --> 00:09:11,680
אחד לאותיות רישיות
ואחת לאותיות קטנות.

158
00:09:11,680 --> 00:09:18,420
אז isUpper isLower יעזור לך
לקבוע איזו נוסחה ליישם.

159
00:09:18,420 --> 00:09:22,460
>> איך ליישם את נוסחת שלך לכל
תו בודד במחרוזת?

160
00:09:22,460 --> 00:09:25,910
ובכן, היא פשוט מחרוזת
מערך של תווים.

161
00:09:25,910 --> 00:09:31,150
אז אתה יכול לגשת לכל תו על ידי
קיבוץ על כל דמות ב

162
00:09:31,150 --> 00:09:33,450
מחרוזת ללולאה.

163
00:09:33,450 --> 00:09:37,550
באשר למצבו שלך ללולאה,
פונקצית strlen, למחרוזת

164
00:09:37,550 --> 00:09:39,280
האורך, יהיה שימושי.

165
00:09:39,280 --> 00:09:44,020
זה לוקח במחרוזת כקלט ו
מחזיר את האורך של מחרוזת ש.

166
00:09:44,020 --> 00:09:49,250
הקפד לכלול את הספרייה הנכונה
כדי להשתמש בפונקצית אורך המחרוזת.

167
00:09:49,250 --> 00:09:51,790
>> ויש לך הודעה המוצפנת שלך.

168
00:09:51,790 --> 00:09:53,260
השם שלי הוא Zamyla.

169
00:09:53,260 --> 00:09:54,510
ו[ קוד דיבור לפני].

170
00:09:54,510 --> 00:10:02,944