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

2
00:00:10,103 --> 00:00:11,270
>> ZAMYLA CHAN: Grattis
på avsluta din

3
00:00:11,270 --> 00:00:13,200
första par C-program.

4
00:00:13,200 --> 00:00:16,379
Jag vet att din första razzia i
C syntax kan vara skrämmande.

5
00:00:16,379 --> 00:00:20,060
Men jag försäkrar er, i slutet av
Naturligtvis kommer du att kunna titta på

6
00:00:20,060 --> 00:00:23,870
första par uppdrag och
slutföra dem på några minuter.

7
00:00:23,870 --> 00:00:27,830
>> Nu när du får mer bekant
med syntax, låt oss komma till Caesar.

8
00:00:27,830 --> 00:00:31,720
I Caesar, kommer användaren lämna in en
heltal nyckel som en kommandorad

9
00:00:31,720 --> 00:00:35,300
argument, och ange sedan en vanlig
textmeddelande vid prompten.

10
00:00:35,300 --> 00:00:38,050
Programmet kommer då att kryptera
texten och tryck

11
00:00:38,050 --> 00:00:40,020
deras ciphertext budskap.

12
00:00:40,020 --> 00:00:42,980
>> Krypterings för Caesar
är ganska enkel.

13
00:00:42,980 --> 00:00:46,455
Shift varje bokstav, i deras
klartext, med nyckeln.

14
00:00:46,455 --> 00:00:49,220
Som ett resultat, det är också
ganska osäker.

15
00:00:49,220 --> 00:00:53,850
Men att genomföra Caesar kommer att införa
oss till ASCIIMath och array uppgifter

16
00:00:53,850 --> 00:00:54,460
strukturer.

17
00:00:54,460 --> 00:00:57,510
Vi kommer till mer komplexa
chiffer senare.

18
00:00:57,510 --> 00:01:01,680
Med en Caesar nyckel 2, bokstaven A i
klartext skulle representeras av

19
00:01:01,680 --> 00:01:07,580
bokstaven C i chiffertexten eftersom C
är två bokstäver efter A. B skulle vara

20
00:01:07,580 --> 00:01:12,450
företrädd av D och C av E. Mot
slutet av alfabetet är W

21
00:01:12,450 --> 00:01:18,550
företrädd av Y och X med Z. Men Y
har inte två bokstäver efter det, så

22
00:01:18,550 --> 00:01:21,070
de chiffer sveper runt alfabetet.

23
00:01:21,070 --> 00:01:27,190
Y i klartext alltså representeras av
A i chiffertexten, och Z av B. Det kan

24
00:01:27,190 --> 00:01:32,080
Hjälp för att visa Caesar Cypher som
en kontinuerlig alfabet hjul.

25
00:01:32,080 --> 00:01:35,760
>> Att kryptera sin text, användaren
träder två argument

26
00:01:35,760 --> 00:01:37,090
till kommandoraden -

27
00:01:37,090 --> 00:01:40,010
. / Caesar följt av en nyckel.

28
00:01:40,010 --> 00:01:44,710
Som alltid, kan vi lita inte användaren
fullständigt ange ingång som gör

29
00:01:44,710 --> 00:01:45,800
känsla för vårt program.

30
00:01:45,800 --> 00:01:50,670
Så vi måste validera sina
kommandoraden.

31
00:01:50,670 --> 00:01:57,285
>> Istället för att använda int main tomrum, vi
använder int main, int argc, string argv.

32
00:01:57,285 --> 00:02:01,730
Den heltalsvariabel argc representerar
antalet argument som skickas till

33
00:02:01,730 --> 00:02:02,880
kommandoraden.

34
00:02:02,880 --> 00:02:09,070
Och argv är en array, eller se det som
en förteckning, av argumenten gått i.

35
00:02:09,070 --> 00:02:12,000
>> Så för Caesar, hur vi validerar
användarens input?

36
00:02:12,000 --> 00:02:15,870
Jo, de skall bara ange
två kommandoradsargument -

37
00:02:15,870 --> 00:02:18,150
. / Caesar och en nyckel.

38
00:02:18,150 --> 00:02:22,340
Så om argc inte är 2, betyder det att
de glömde antingen en nyckel och bara

39
00:02:22,340 --> 00:02:27,230
in. / Caesar, eller de
angett flera nycklar.

40
00:02:27,230 --> 00:02:29,770
>> Om så är fallet, så kommer du
vill skriva ut instruktioner

41
00:02:29,770 --> 00:02:30,910
och avsluta programmet.

42
00:02:30,910 --> 00:02:34,320
De måste försöka igen
från kommandoraden.

43
00:02:34,320 --> 00:02:37,430
Men även om argc är 2, kommer du
måste kontrollera om de

44
00:02:37,430 --> 00:02:39,100
ger dig en giltig nyckel.

45
00:02:39,100 --> 00:02:40,730
För Caesar, behöver du ett heltal.

46
00:02:40,730 --> 00:02:43,260
Men argv är en array av strängar.

47
00:02:43,260 --> 00:02:46,490
Hur får du tillgång nyckeln?

48
00:02:46,490 --> 00:02:47,850
>> En snabb titt på arrayer -

49
00:02:47,850 --> 00:02:51,410
datastrukturer som håller multipla
värden av samma datatyp.

50
00:02:51,410 --> 00:02:55,350
Posterna är noll-indexerad, vilket innebär att
det första elementet är indexet noll

51
00:02:55,350 --> 00:03:00,260
och det sista elementet vid index storlek
minus 1, där storlek är antalet

52
00:03:00,260 --> 00:03:02,850
element i uppsättningen.

53
00:03:02,850 --> 00:03:07,380
>> Om jag förklarade en ny brevlåda sträng array
av längd 3, visuellt, det

54
00:03:07,380 --> 00:03:08,570
ser ut så här.

55
00:03:08,570 --> 00:03:11,520
Tre behållare för stråkar
, Sida vid sida.

56
00:03:11,520 --> 00:03:15,445
För att komma åt ett element skriver du namnet
av uppsättningen och sedan indikera

57
00:03:15,445 --> 00:03:18,080
Indexet inom hakparenteser.

58
00:03:18,080 --> 00:03:21,610
Här, jag tilldela ett värde till varje
element, precis som jag skulle göra med någon

59
00:03:21,610 --> 00:03:24,310
annan sträng variabel.

60
00:03:24,310 --> 00:03:29,020
>> Så för att komma åt våra kommandoradsargument,
allt vi behöver göra är att komma

61
00:03:29,020 --> 00:03:31,690
den högra delen av argv array.

62
00:03:31,690 --> 00:03:37,360
Om användaren anger. / Blastoff Team
Rocket i terminalen, argv 0 skulle

63
00:03:37,360 --> 00:03:38,950
vara. / blastoff.

64
00:03:38,950 --> 00:03:45,010
argv skulle vara Team, och
arg2 vore raket.

65
00:03:45,010 --> 00:03:47,670
>> Nu när vi kan komma åt vår nyckel,
Vi behöver fortfarande göra

66
00:03:47,670 --> 00:03:49,040
säker på att det är rätt.

67
00:03:49,040 --> 00:03:51,060
Vi måste omvandla det till ett heltal.

68
00:03:51,060 --> 00:03:54,680
Men vi kan inte bara kasta ut
vi har gjort tidigare.

69
00:03:54,680 --> 00:03:58,800
Lyckligtvis tar A till Y-funktion omsorg
av detta för oss och även returnerar 0

70
00:03:58,800 --> 00:04:02,110
Om strängen inte kan omvandlas
in ett heltal.

71
00:04:02,110 --> 00:04:04,450
Det är upp till dig, men, för att berätta
användaren varför kommer du inte

72
00:04:04,450 --> 00:04:06,220
låta programmet fortsätta.

73
00:04:06,220 --> 00:04:10,710
Lagra resultatet av A till Y i en
heltal, och där har du din nyckel.

74
00:04:10,710 --> 00:04:12,070
Nästa del är enkel.

75
00:04:12,070 --> 00:04:15,940
Uppmana användaren för deras vanlig text,
vilket kommer att vara av datatypen string.

76
00:04:15,940 --> 00:04:18,339
Lyckligtvis för oss, matas alla användare
strängar är giltiga.

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

78
00:04:21,170 --> 00:04:24,760
>> Nu när vi har all nödvändig input
från användaren, är det dags för oss att

79
00:04:24,760 --> 00:04:26,520
kryptera sitt budskap.

80
00:04:26,520 --> 00:04:29,200
Begreppet Caesar är enkel
nog att förstå.

81
00:04:29,200 --> 00:04:33,750
Men hur vet din dator som
breven kommer efter varandra?

82
00:04:33,750 --> 00:04:36,100
>> Här är där ASCII tabellen kommer in

83
00:04:36,100 --> 00:04:39,420
Varje karaktär har ett heltal
antal associerade med det.

84
00:04:39,420 --> 00:04:41,380
Capital A är 65.

85
00:04:41,380 --> 00:04:43,310
Capital B är 66.

86
00:04:43,310 --> 00:04:45,260
Gemener en är 97.

87
00:04:45,260 --> 00:04:47,590
Gement b är 98.

88
00:04:47,590 --> 00:04:50,770
Men tecknen är inte begränsade
till bara alfabetiska siffror.

89
00:04:50,770 --> 00:04:56,020
Till exempel, tecknet @
är ASCII nummer 64.

90
00:04:56,020 --> 00:04:59,690
>> Innan behandlar hela strängen,
Låt oss låtsas att vi har bara att flytta

91
00:04:59,690 --> 00:05:01,220
en karaktär.

92
00:05:01,220 --> 00:05:04,640
Tja, vill vi bara att flytta faktiska
bokstäver i klartext, inte

93
00:05:04,640 --> 00:05:06,020
bokstäver eller siffror.

94
00:05:06,020 --> 00:05:09,100
Så det första som vi kommer att vilja
kontrollera är om karaktären är i

95
00:05:09,100 --> 00:05:10,430
alfabetet.

96
00:05:10,430 --> 00:05:14,460
>> Funktionen isalpha gör detta för
oss och returnerar ett booleskt -

97
00:05:14,460 --> 00:05:18,570
sant om karaktärerna är en bokstav,
falskt om något annat.

98
00:05:18,570 --> 00:05:22,270
Två andra användbara funktioner är
isupper och islower, med

99
00:05:22,270 --> 00:05:23,860
självförklarande namn.

100
00:05:23,860 --> 00:05:27,370
De återvänder sant om givet tecken
är stora eller små bokstäver,

101
00:05:27,370 --> 00:05:28,740
respektive.

102
00:05:28,740 --> 00:05:33,770
Eftersom de är Booleans, de är
lämpligt att använda som villkor.

103
00:05:33,770 --> 00:05:38,310
>> Om isalpha returnerar sant, behöver du
att flytta tecknet med nyckeln.

104
00:05:38,310 --> 00:05:43,750
Så låt oss öppna för ASCIIMath
och göra vissa ASCII matte.

105
00:05:43,750 --> 00:05:48,700
Användningsområdet är mycket lik användningen
för Caesar och tar in en knapp på

106
00:05:48,700 --> 00:05:50,870
kommandoraden.

107
00:05:50,870 --> 00:05:59,590
>> Om jag kör ASCIIMath 5, verkar det att lägga
5 till en, ger mig bokstaven f, och

108
00:05:59,590 --> 00:06:01,260
visning av ASCII-värdet.

109
00:06:01,260 --> 00:06:04,090
Så låt oss ta en titt på programmet.

110
00:06:04,090 --> 00:06:11,820
>> Du kanske undrar, just här, varför
brev är ett heltal, när det är

111
00:06:11,820 --> 00:06:14,330
tydligt, väl, ett brev.

112
00:06:14,330 --> 00:06:17,690
Det visar sig att tecken och
heltal är utbytbara.

113
00:06:17,690 --> 00:06:21,730
Genom att sätta bokstaven A i singel
citattecken, kan heltalet lagra

114
00:06:21,730 --> 00:06:25,390
ASCII-värdet på kapitalet
A. Var försiktig dock.

115
00:06:25,390 --> 00:06:27,150
Du behöver de enskilda kläder.

116
00:06:27,150 --> 00:06:31,260
Utan de enkla citattecken, den
kompilator skulle leta efter en variabel

117
00:06:31,260 --> 00:06:35,510
heter A, och inte tecknet.

118
00:06:35,510 --> 00:06:42,140
>> Då ska jag lägga brev och en nyckel, lagra
Summan i int variabler resultatet.

119
00:06:42,140 --> 00:06:47,740
Även om resultatet är av datatypen
heltal, använder min printf uttalande

120
00:06:47,740 --> 00:06:50,370
% C platshållare för tecken.

121
00:06:50,370 --> 00:06:54,530
Så att programmet skriver ut tecknet
associerad med heltal resultatet.

122
00:06:54,530 --> 00:07:00,400
Och eftersom vi tryckt heltal
form samt med% d, ser vi

123
00:07:00,400 --> 00:07:02,110
numret också.

124
00:07:02,110 --> 00:07:04,450
Så nu kan du se att vi
behandla tecken och

125
00:07:04,450 --> 00:07:06,980
heltal, och vice versa.

126
00:07:06,980 --> 00:07:12,205
>> Låt oss testa ut ASCIIMath några
fler gånger med 25 som en nyckel.

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

128
00:07:15,510 --> 00:07:17,090
Vi får bokstaven z..

129
00:07:17,090 --> 00:07:19,750
Nu försöker vi 26.

130
00:07:19,750 --> 00:07:25,600
Vi vill få bokstaven a, men
istället får vi en vänster konsol.

131
00:07:25,600 --> 00:07:29,490
Så uppenbarligen, bara lägga till
nyckeln till brevet inte kommer att göra.

132
00:07:29,490 --> 00:07:32,780
Vi måste ta reda på en formel för att slå
runt alfabetet, gillar vår

133
00:07:32,780 --> 00:07:34,570
exempel i början gjorde.

134
00:07:34,570 --> 00:07:38,520
>> En formel för Caesars
skift är följande.

135
00:07:38,520 --> 00:07:42,750
c är lika med p plus k modulo 26.

136
00:07:42,750 --> 00:07:46,040
Kom ihåg att modulo är en användbar
operation som ger oss resten

137
00:07:46,040 --> 00:07:49,880
att dela ett antal av den andra.

138
00:07:49,880 --> 00:07:54,870
Låt oss tillämpa denna formel på slätten
text brev med en nyckel 2.

139
00:07:54,870 --> 00:08:01,810
ASCII-värdet för y är 89, vilket
ger oss 91 modulo 26,

140
00:08:01,810 --> 00:08:03,690
vilket är lika med 13 -

141
00:08:03,690 --> 00:08:08,740
definitivt inte ASCII-värdet
en, är som 67.

142
00:08:08,740 --> 00:08:12,810
>> Humor mig nu och röra sig bort från
ASCII-värden till ett kartotek

143
00:08:12,810 --> 00:08:18,690
där A är noll och Z är 25,
vilket innebär att Y är 24.

144
00:08:18,690 --> 00:08:25,830
24 plus 2, modulo 6, ger oss 26,
modulo 26, 0, som är den

145
00:08:25,830 --> 00:08:28,170
alfabetiskt register över ett.

146
00:08:28,170 --> 00:08:32,980
Så denna formel tycks gälla den
alfabetiskt register över brevet och

147
00:08:32,980 --> 00:08:34,960
inte dess ASCII värde.

148
00:08:34,960 --> 00:08:37,630
>> Men du börjar med ASCII-värden.

149
00:08:37,630 --> 00:08:41,650
Och att skriva ut ciphertext karaktär,
du behöver dess ASCII värde samt.

150
00:08:41,650 --> 00:08:46,400
Det är upp till dig, då, för att räkna ut
hur du växlar fram och tillbaka.

151
00:08:46,400 --> 00:08:49,850
>> När du räkna ut den rätta formeln
för ett tecken, allt du behöver göra

152
00:08:49,850 --> 00:08:53,520
är att tillämpa samma formel för varje
brev i klartext -

153
00:08:53,520 --> 00:08:57,720
endast om denna skrivelse är alfabetisk,
förstås.

154
00:08:57,720 --> 00:09:02,360
Och kom ihåg att du måste bevara
fallet, övre eller nedre, det är där

155
00:09:02,360 --> 00:09:06,890
den isupper och funktioner isLower
nämnts tidigare kommer väl till hands.

156
00:09:06,890 --> 00:09:08,830
Du kanske har två formler -

157
00:09:08,830 --> 00:09:11,680
ett för versaler
och en för gemener.

158
00:09:11,680 --> 00:09:18,420
Så isupper en isLower hjälper dig
avgöra vilken formel att gälla.

159
00:09:18,420 --> 00:09:22,460
>> Hur ansöker du din formel till varje
enstaka tecken i en sträng?

160
00:09:22,460 --> 00:09:25,910
Tja, är en sträng bara en
matris med tecken.

161
00:09:25,910 --> 00:09:31,150
Så du kan komma åt varje tecken genom
gruppering över varje tecken i

162
00:09:31,150 --> 00:09:33,450
sträng i en for-slinga.

163
00:09:33,450 --> 00:09:37,550
När det gäller villkor för din for-slingan,
funktionen strlen, för sträng

164
00:09:37,550 --> 00:09:39,280
längd, kommer att komma till hands.

165
00:09:39,280 --> 00:09:44,020
Det tar i en sträng som indata och
returnerar längden på den strängen.

166
00:09:44,020 --> 00:09:49,250
Se till att inkludera rätt biblioteket
att använda funktionen stränglängden.

167
00:09:49,250 --> 00:09:51,790
>> Och där har du din ciphertext.

168
00:09:51,790 --> 00:09:53,260
Mitt namn är Zamyla.

169
00:09:53,260 --> 00:09:54,510
Och [Pratar CODE].

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