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
>> 凯撒加密
其实很简单。

13
00:00:42,980 --> 00:00:46,455
每个字母移位，在他们的
纯文本的关键。

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，字母A
纯文本将代表

19
00:01:01,680 --> 00:01:07,580
密文的字母C，因为C
后，A，B两个字母

20
00:01:07,580 --> 00:01:12,450
D和C表示E.走向
字母表末尾，W是

21
00:01:12,450 --> 00:01:18,550
X，Y三种由Z.不过Y表示的
没有后两个字母，所以

22
00:01:18,550 --> 00:01:21,070
字母表密码环绕。

23
00:01:21,070 --> 00:01:27,190
因此，Y在纯文本代表的
A的密文，和Z B.它可

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 ARGC，串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
如果用户输入/升空队
火箭到终端中，argv 0

63
00:03:37,360 --> 00:03:38,950
/升空。

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
幸运的是，在A到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
资本A是65。

85
00:04:41,380 --> 00:04:43,310
资本B是66。

86
00:04:43,310 --> 00:04:45,260
小写a是97。

87
00:04:45,260 --> 00:04:47,590
小写b是98。

88
00:04:47,590 --> 00:04:50,770
但文字并不局限于
只是字母数字。

89
00:04:50,770 --> 00:04:56,020
例如，@符号
是ASCII数字64。

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
他们返回true，如果给定的字符
是大写或小写，

101
00:05:27,370 --> 00:05:28,740
分别

102
00:05:28,740 --> 00:05:33,770
由于他们是布尔值，他们
有用的使用条件。

103
00:05:33,770 --> 00:05:38,310
>> 如果返回true，因而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
通过把字母A在单
引号，整数可以存储

114
00:06:21,730 --> 00:06:25,390
资本的ASCII值
A.要小心，虽然。

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
命名为A，而不是字符。

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
％C字符占位符。

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
我们想要得到的字母a，但
相反，我们得到了一个左括号。

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
Ç等于P加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
y的ASCII值89，
为我们提供了模数26 91

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
其中A是零和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
在fo​​r循环中的字符串。

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