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

2
00:00:10,103 --> 00:00:11,270
>> ZAMYLA CHAN: Parabéns
em terminar o seu

3
00:00:11,270 --> 00:00:13,200
primeiro par de programas em C.

4
00:00:13,200 --> 00:00:16,379
Eu sei que a sua primeira incursão no
Sintaxe C pode ser assustador.

5
00:00:16,379 --> 00:00:20,060
Mas garanto-lhe, no final do
Claro, você vai ser capaz de olhar para o

6
00:00:20,060 --> 00:00:23,870
primeiro par de atribuições e
concluí-las em poucos minutos.

7
00:00:23,870 --> 00:00:27,830
>> Agora que você está ficando mais familiarizado
com a sintaxe, vamos começar a César.

8
00:00:27,830 --> 00:00:31,720
Em César, o usuário deverá apresentar um
chave número inteiro como uma linha de comando

9
00:00:31,720 --> 00:00:35,300
argumento, em seguida, digite uma planície
mensagem de texto no prompt.

10
00:00:35,300 --> 00:00:38,050
O programa irá então cifrar
o texto e impressão

11
00:00:38,050 --> 00:00:40,020
sua mensagem de texto cifrado.

12
00:00:40,020 --> 00:00:42,980
>> A cifragem de César
é bastante simples.

13
00:00:42,980 --> 00:00:46,455
Deslocar cada letra, em sua
texto simples, pela chave.

14
00:00:46,455 --> 00:00:49,220
Como resultado, é também
muito inseguro.

15
00:00:49,220 --> 00:00:53,850
Mas a implementação César irá introduzir
nos ASCIIMath e matriz de dados

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

17
00:00:54,460 --> 00:00:57,510
Nós vamos chegar a mais complexa
cifras posteriores.

18
00:00:57,510 --> 00:01:01,680
Com uma chave de César de 2, a letra A em
texto simples seria representado por

19
00:01:01,680 --> 00:01:07,580
a letra C em texto cifrado, porque C
é de duas letras após A. B seria

20
00:01:07,580 --> 00:01:12,450
representado por D e C por E. Rumo
o fim do alfabeto, W é

21
00:01:12,450 --> 00:01:18,550
representado por Y e X, Y Z. Mas
não tem duas letras para depois, de modo

22
00:01:18,550 --> 00:01:21,070
as cifras envolve o alfabeto.

23
00:01:21,070 --> 00:01:27,190
Y em texto simples é, portanto, representado por
Um em texto cifrado, e Z por B. Pode

24
00:01:27,190 --> 00:01:32,080
ajudar a ver o César como Cypher
uma roda alfabeto contínua.

25
00:01:32,080 --> 00:01:35,760
>> Para codificar seu texto, o usuário
entrará dois argumentos

26
00:01:35,760 --> 00:01:37,090
na linha de comando -

27
00:01:37,090 --> 00:01:40,010
. / Caesar seguido por uma chave.

28
00:01:40,010 --> 00:01:44,710
Como sempre, não podemos confiar em que o usuário
completamente para entrar entrada que fazer

29
00:01:44,710 --> 00:01:45,800
sentido para o nosso programa.

30
00:01:45,800 --> 00:01:50,670
Então nós vamos ter que validar o seu
entrada de linha de comando.

31
00:01:50,670 --> 00:01:57,285
>> Em vez de usar int void main, estamos
usando int main, argc int, string argv.

32
00:01:57,285 --> 00:02:01,730
O argc variável inteira representa
o número de argumentos passados ​​para

33
00:02:01,730 --> 00:02:02,880
na linha de comando.

34
00:02:02,880 --> 00:02:09,070
E argv é um array, ou pensar nele como
uma lista, dos argumentos passados ​​dentro

35
00:02:09,070 --> 00:02:12,000
>> Assim, para César, como é que vamos validar
entrada do usuário?

36
00:02:12,000 --> 00:02:15,870
Bem, eles só devem estar entrando
dois argumentos de linha de comando -

37
00:02:15,870 --> 00:02:18,150
. / Caesar e uma chave.

38
00:02:18,150 --> 00:02:22,340
Então, se não é argc 2, o que significa que
ou eles esqueceram a chave e só

39
00:02:22,340 --> 00:02:27,230
entrou. / caesar, ou eles
entrou várias chaves.

40
00:02:27,230 --> 00:02:29,770
>> Se este for o caso, então você vai
deseja imprimir instruções

41
00:02:29,770 --> 00:02:30,910
e sair do programa.

42
00:02:30,910 --> 00:02:34,320
Eles vão precisar para tentar novamente
a partir da linha de comando.

43
00:02:34,320 --> 00:02:37,430
Mas mesmo se argc é 2, você vai
precisa verificar se eles

44
00:02:37,430 --> 00:02:39,100
dar-lhe uma chave válida.

45
00:02:39,100 --> 00:02:40,730
Para Caesar, você precisa de um número inteiro.

46
00:02:40,730 --> 00:02:43,260
Mas argv é uma matriz de strings.

47
00:02:43,260 --> 00:02:46,490
Como você acessa a chave?

48
00:02:46,490 --> 00:02:47,850
>> Um rápido olhar para as matrizes -

49
00:02:47,850 --> 00:02:51,410
estruturas de dados que possuem múltipla
Os valores de dados do mesmo tipo.

50
00:02:51,410 --> 00:02:55,350
As inscrições são com índice zero, o que significa que
o primeiro elemento é o índice zero

51
00:02:55,350 --> 00:03:00,260
e o último elemento é pelo tamanho do índice
menos 1, em que tamanho é o número de

52
00:03:00,260 --> 00:03:02,850
elementos na matriz.

53
00:03:02,850 --> 00:03:07,380
>> Se eu declarei uma nova caixa de correio matriz de cadeia
de comprimento 3, visualmente, ele

54
00:03:07,380 --> 00:03:08,570
parecido com este.

55
00:03:08,570 --> 00:03:11,520
Três recipientes para cordas
, Lado a lado.

56
00:03:11,520 --> 00:03:15,445
Para aceder a qualquer elemento, você digita o nome
da matriz e, em seguida, indicam

57
00:03:15,445 --> 00:03:18,080
o índice entre colchetes.

58
00:03:18,080 --> 00:03:21,610
Aqui, vou atribuir um valor a cada
elemento, assim como eu faria com qualquer

59
00:03:21,610 --> 00:03:24,310
outra variável string.

60
00:03:24,310 --> 00:03:29,020
>> Então, para acessar nossos argumentos de linha de comando,
tudo o que temos a fazer é acessar

61
00:03:29,020 --> 00:03:31,690
o elemento de direito da matriz argv.

62
00:03:31,690 --> 00:03:37,360
Se o usuário entrou Team. / Decolagem
Foguete no terminal, argv 0 seria

63
00:03:37,360 --> 00:03:38,950
ser. / decolagem.

64
00:03:38,950 --> 00:03:45,010
argv seria Team, e
arg2 seria foguete.

65
00:03:45,010 --> 00:03:47,670
>> Agora que podemos acessar a nossa chave,
ainda precisamos fazer

66
00:03:47,670 --> 00:03:49,040
certeza de que ele está correto.

67
00:03:49,040 --> 00:03:51,060
Nós precisamos convertê-lo em um número inteiro.

68
00:03:51,060 --> 00:03:54,680
Mas não podemos apenas lançar como
fizemos anteriormente.

69
00:03:54,680 --> 00:03:58,800
Felizmente, para a função A Y cuida
isso para nós e até mesmo retorna 0

70
00:03:58,800 --> 00:04:02,110
se a cadeia não pode ser convertido
para um número inteiro.

71
00:04:02,110 --> 00:04:04,450
Cabe a você, no entanto, para dizer
o usuário por que você não vai

72
00:04:04,450 --> 00:04:06,220
deixar o programa prosseguir.

73
00:04:06,220 --> 00:04:10,710
Armazenar o resultado de um de Y numa
inteiro, e lá você tem a sua chave.

74
00:04:10,710 --> 00:04:12,070
A próxima parte é simples.

75
00:04:12,070 --> 00:04:15,940
Solicitar ao usuário o seu texto simples,
que será de dados tipo string.

76
00:04:15,940 --> 00:04:18,339
Felizmente para nós, todos os usuários inseridos
cordas são válidos.

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

78
00:04:21,170 --> 00:04:24,760
>> Agora que temos todos os meios necessários
do usuário, é tempo para nós

79
00:04:24,760 --> 00:04:26,520
codificar sua mensagem.

80
00:04:26,520 --> 00:04:29,200
O conceito de César é simples
o suficiente para entender.

81
00:04:29,200 --> 00:04:33,750
Mas como é que o computador sabe que
letras vir após o outro?

82
00:04:33,750 --> 00:04:36,100
>> Aqui é onde a tabela ASCII vem dentro

83
00:04:36,100 --> 00:04:39,420
Cada personagem tem um número inteiro
número associado a ele.

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

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

86
00:04:43,310 --> 00:04:45,260
Minúsculas um é 97.

87
00:04:45,260 --> 00:04:47,590
Minúsculas b é 98.

88
00:04:47,590 --> 00:04:50,770
Mas os personagens não se limitam
para apenas números alfabéticos.

89
00:04:50,770 --> 00:04:56,020
Por exemplo, o símbolo @
64 é o número ASCII.

90
00:04:56,020 --> 00:04:59,690
>> Antes de lidar com toda a corda,
vamos fingir que nós apenas temos que mudar

91
00:04:59,690 --> 00:05:01,220
um personagem.

92
00:05:01,220 --> 00:05:04,640
Bem, nós só queremos mudar real
letras no texto simples, não

93
00:05:04,640 --> 00:05:06,020
caracteres ou números.

94
00:05:06,020 --> 00:05:09,100
Então a primeira coisa que vamos querer
verificar é se o personagem está em

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

96
00:05:10,430 --> 00:05:14,460
>> O isalpha função faz isso para
nós e retorna um valor booleano -

97
00:05:14,460 --> 00:05:18,570
verdadeiro se os personagens é uma carta,
falso em caso contrário.

98
00:05:18,570 --> 00:05:22,270
Duas outras funções úteis são
isupper e islower, com

99
00:05:22,270 --> 00:05:23,860
nomes auto-explicativos.

100
00:05:23,860 --> 00:05:27,370
Eles retornam verdadeiro se o caráter dado
é maiúscula ou minúscula,

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

102
00:05:28,740 --> 00:05:33,770
Uma vez que eles são booleanos, eles são
útil para usar como condições.

103
00:05:33,770 --> 00:05:38,310
>> Se isalpha retorna verdadeiro, você vai precisar
para mudar o personagem pela chave.

104
00:05:38,310 --> 00:05:43,750
Então, vamos abrir a ASCIIMath
e fazer um pouco de matemática ASCII.

105
00:05:43,750 --> 00:05:48,700
A utilização é muito semelhante ao do uso
para César e leva em uma chave no

106
00:05:48,700 --> 00:05:50,870
linha de comando.

107
00:05:50,870 --> 00:05:59,590
>> Se eu executar ASCIIMath 5, parece adicionar
Cinco para um, dando-me a letra f, e

108
00:05:59,590 --> 00:06:01,260
exibindo o valor ASCII.

109
00:06:01,260 --> 00:06:04,090
Então, vamos dar uma olhada no programa.

110
00:06:04,090 --> 00:06:11,820
>> Você pode se perguntar, aqui, por
carta é um número inteiro, quando está

111
00:06:11,820 --> 00:06:14,330
claramente, também, uma carta.

112
00:06:14,330 --> 00:06:17,690
Acontece que os personagens e
inteiros são intercambiáveis.

113
00:06:17,690 --> 00:06:21,730
Ao colocar a letra A em um único
aspas, o inteiro pode armazenar

114
00:06:21,730 --> 00:06:25,390
o valor ASCII do capital
A. Tenha cuidado, porém.

115
00:06:25,390 --> 00:06:27,150
Você precisa das roupas simples.

116
00:06:27,150 --> 00:06:31,260
Sem as aspas simples, o
compilador iria procurar uma variável

117
00:06:31,260 --> 00:06:35,510
chamado A, e não o personagem.

118
00:06:35,510 --> 00:06:42,140
>> Então eu adiciono carta e uma chave, armazenando o
soma das variáveis ​​int resultado.

119
00:06:42,140 --> 00:06:47,740
Embora resultado é do tipo de dados
inteiro, a minha declaração printf utiliza o

120
00:06:47,740 --> 00:06:50,370
% C espaço reservado para os personagens.

121
00:06:50,370 --> 00:06:54,530
Assim, o programa imprime o caráter
relacionado com o resultado inteiro.

122
00:06:54,530 --> 00:07:00,400
E já que impresso o número inteiro
forma bem usando% d, vemos

123
00:07:00,400 --> 00:07:02,110
o número bem.

124
00:07:02,110 --> 00:07:04,450
Então, agora você pode ver que nós
tratar personagens e

125
00:07:04,450 --> 00:07:06,980
números inteiros, e vice-versa.

126
00:07:06,980 --> 00:07:12,205
>> Vamos teste fora ASCIIMath alguns
mais vezes usando 25 como uma chave.

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

128
00:07:15,510 --> 00:07:17,090
Ficamos com a letra z.

129
00:07:17,090 --> 00:07:19,750
Agora vamos tentar 26.

130
00:07:19,750 --> 00:07:25,600
Queremos chegar a letra a, mas
em vez disso temos um suporte esquerdo.

131
00:07:25,600 --> 00:07:29,490
Então, obviamente, apenas adicionando o
chave para a carta não vai fazer.

132
00:07:29,490 --> 00:07:32,780
Precisamos descobrir uma fórmula para embrulhar
todo o alfabeto, como o nosso

133
00:07:32,780 --> 00:07:34,570
exemplo, no início fez.

134
00:07:34,570 --> 00:07:38,520
>> A fórmula para o César
mudança é como se segue.

135
00:07:38,520 --> 00:07:42,750
c é igual p mais k modulo 26.

136
00:07:42,750 --> 00:07:46,040
Lembre-se que modulo é um instrumento útil
operação que nos dá a restante

137
00:07:46,040 --> 00:07:49,880
de dividir um número pelo outro.

138
00:07:49,880 --> 00:07:54,870
Vamos aplicar esta fórmula para a planície
carta de texto com uma chave de 2.

139
00:07:54,870 --> 00:08:01,810
O valor ASCII y é 89, que
dá-nos 91 modulo 26,

140
00:08:01,810 --> 00:08:03,690
o que equivale a 13 -

141
00:08:03,690 --> 00:08:08,740
definitivamente não é o valor ASCII
de a, que é 67.

142
00:08:08,740 --> 00:08:12,810
>> Humor me agora e afastar-se do
Valores ASCII para um índice alfabético

143
00:08:12,810 --> 00:08:18,690
onde A é zero e Z é 25,
o que significa que Y é 24.

144
00:08:18,690 --> 00:08:25,830
24 + 2, módulo 6, nos dá 26,
modulo 26, 0, que é o

145
00:08:25,830 --> 00:08:28,170
índice alfabético de um.

146
00:08:28,170 --> 00:08:32,980
Portanto, esta fórmula parece se aplicar ao
índice alfabético da carta e

147
00:08:32,980 --> 00:08:34,960
não o seu valor ASCII.

148
00:08:34,960 --> 00:08:37,630
>> Mas você começa com os valores ASCII.

149
00:08:37,630 --> 00:08:41,650
E para imprimir o caráter cifrado,
você vai precisar de seu valor ASCII também.

150
00:08:41,650 --> 00:08:46,400
Cabe a você, então, para descobrir
como mudar e para trás.

151
00:08:46,400 --> 00:08:49,850
>> Depois de descobrir a fórmula certa
para uma personagem, tudo o que você precisa fazer

152
00:08:49,850 --> 00:08:53,520
se aplicar a mesma fórmula para cada
letra no texto simples -

153
00:08:53,520 --> 00:08:57,720
apenas se a carta está em ordem alfabética,
claro.

154
00:08:57,720 --> 00:09:02,360
E lembre-se de que você precisa para preservar
o caso, superior ou inferior, que é onde

155
00:09:02,360 --> 00:09:06,890
as funções IsLower isupper e
mencionado anteriormente virá a calhar.

156
00:09:06,890 --> 00:09:08,830
Você pode ter duas fórmulas -

157
00:09:08,830 --> 00:09:11,680
um para letras maiúsculas
e um para letras minúsculas.

158
00:09:11,680 --> 00:09:18,420
Então isupper um eMinusculo irá ajudá-lo
determinar qual a fórmula que se aplica.

159
00:09:18,420 --> 00:09:22,460
>> Como você aplica a fórmula para cada
único caractere em uma string?

160
00:09:22,460 --> 00:09:25,910
Bem, uma string é apenas um
matriz de caracteres.

161
00:09:25,910 --> 00:09:31,150
Assim, você pode acessar cada personagem,
agrupamento sobre cada personagem do

162
00:09:31,150 --> 00:09:33,450
cordas em um loop for.

163
00:09:33,450 --> 00:09:37,550
Quanto à condição de loop for,
a função strlen, por corda

164
00:09:37,550 --> 00:09:39,280
comprimento, virá a calhar.

165
00:09:39,280 --> 00:09:44,020
Leva em uma string como entrada e
retorna o comprimento dessa corda.

166
00:09:44,020 --> 00:09:49,250
Certifique-se de incluir a biblioteca direita
para usar a função comprimento da corda.

167
00:09:49,250 --> 00:09:51,790
>> E aí você tem o texto cifrado.

168
00:09:51,790 --> 00:09:53,260
Meu nome é o Zamyla.

169
00:09:53,260 --> 00:09:54,510
E [CODE falando].

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