1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Review] [0 Quiz]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, José Ong] [Harvard University]

3
00:00:05,000 --> 00:00:08,000
>> [Esta é CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Ei, todo o mundo.

5
00:00:10,000 --> 00:00:15,000
Benvido á sesión de revisión para Quiz 0, o que está a ter lugar este mércores.

6
00:00:15,000 --> 00:00:19,000
O que imos facer hoxe á noite, eu estou con tres TFS outros,

7
00:00:19,000 --> 00:00:24,000
e xuntos imos pasar por unha revisión do que fixemos no curso ata o momento.

8
00:00:24,000 --> 00:00:27,000
Non vai ser 100% completo, pero debe darlle unha idea mellor

9
00:00:27,000 --> 00:00:31,000
que xa ten para abaixo e que aínda que estudar antes do mércores.

10
00:00:31,000 --> 00:00:34,000
E Sinto-se libre para levantar a man con preguntas como estamos indo,

11
00:00:34,000 --> 00:00:38,000
pero teña en conta que nós tamén imos ter un pouco de tempo ao final-

12
00:00:38,000 --> 00:00:41,000
acabar con uns minutos de sobra para facer preguntas xerais,

13
00:00:41,000 --> 00:00:47,000
de modo manter isto presente, e por iso estamos indo para comezar no inicio coa Semana 0.

14
00:00:47,000 --> 00:00:50,000
>> [Cuestionario 0 comentario!] [Parte 0] [Lexi Ross] Pero antes de facelo, imos falar sobre

15
00:00:50,000 --> 00:00:53,000
a loxística do quiz.

16
00:00:53,000 --> 00:00:55,000
>> [Loxística] [quiz ocorre o mércores 10/10, en vez dunha charla]

17
00:00:55,000 --> 00:00:57,000
>> [(Vexa http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf para máis detalles)] e mércores, 10 de outubro.

18
00:00:57,000 --> 00:01:00,000
>> Isto é onte, e vai a este URL aquí,

19
00:01:00,000 --> 00:01:03,000
que tamén é accesible desde CS50.net-hai unha ligazón a el-

20
00:01:03,000 --> 00:01:06,000
podes ver información sobre onde ir con base en

21
00:01:06,000 --> 00:01:10,000
seu sobrenome ou filiación escola, así como

22
00:01:10,000 --> 00:01:14,000
fala sobre exactamente o que o exame pode cubrir e os tipos de preguntas que vai conseguir.

23
00:01:14,000 --> 00:01:19,000
Teña presente que tamén vai ter a oportunidade de revisar a responder ao exame da sección,

24
00:01:19,000 --> 00:01:21,000
para que os seus TFS debe ir sobre algúns problemas da práctica,

25
00:01:21,000 --> 00:01:29,000
e esa é outra boa oportunidade de ver onde aínda que estudar para o quiz.

26
00:01:29,000 --> 00:01:32,000
Imos comezar no inicio con Bytes 'n' bits.

27
00:01:32,000 --> 00:01:35,000
Lembre-se un pouco é só un 0 ou un 1,

28
00:01:35,000 --> 00:01:38,000
e un byte é unha colección de oito deses bits.

29
00:01:38,000 --> 00:01:42,000
Imos ollar para esta colección de bits aquí.

30
00:01:42,000 --> 00:01:44,000
Debemos ser capaces de descubrir cantos bits existen.

31
00:01:44,000 --> 00:01:48,000
Onde contamos hai só 8 deles, oito 0 ou 1 unidades.

32
00:01:48,000 --> 00:01:51,000
E dende hai 8 bits, que é 1 byte,

33
00:01:51,000 --> 00:01:53,000
e imos convertelo en hexadecimal.

34
00:01:53,000 --> 00:01:58,000
Hexadecimal é base 16, e é moi fácil de se converter

35
00:01:58,000 --> 00:02:01,000
un número en binario, que é o que é, para un número hexadecimal.

36
00:02:01,000 --> 00:02:04,000
Todo o que facemos é mirar para grupos de 4,

37
00:02:04,000 --> 00:02:07,000
e convertela los para o díxito hexadecimal correspondente.

38
00:02:07,000 --> 00:02:11,000
Comezamos co grupo máis á dereita, 4, polo tanto, 0011.

39
00:02:11,000 --> 00:02:16,000
Isto vai ser un 1 e un 2 para xuntos, que fai 3.

40
00:02:16,000 --> 00:02:19,000
E entón, imos ollar para o outro bloque de 4.

41
00:02:19,000 --> 00:02:24,000
1101. Isto vai ser un 1, un 4 e un 8.

42
00:02:24,000 --> 00:02:28,000
Xuntos que vai ser 13, o que fai D.

43
00:02:28,000 --> 00:02:32,000
E imos lembrar que en hexadecimal que non só tes que ir de 0 a 9.

44
00:02:32,000 --> 00:02:36,000
Imos 0 a F, entón despois de 9, 10 corresponde a A,

45
00:02:36,000 --> 00:02:40,000
11 a B, et cetera, onde F é 15.

46
00:02:40,000 --> 00:02:44,000
Aquí 13 é un D,

47
00:02:44,000 --> 00:02:49,000
para convertelo-lo para decimal todo o que facemos é realmente

48
00:02:49,000 --> 00:02:52,000
tratar cada posición como unha potencia de 2.

49
00:02:52,000 --> 00:02:58,000
Isto é un 1, un 2, cero 4s, cero 8s, unha 16, etcétera,

50
00:02:58,000 --> 00:03:03,000
e é un pouco difícil de calcular na súa cabeza, pero se somos ao seguinte diapositiva

51
00:03:03,000 --> 00:03:05,000
podemos ver a resposta para iso.

52
00:03:05,000 --> 00:03:09,000
>> Esencialmente nós estamos indo en fronte de volta cara á esquerda,

53
00:03:09,000 --> 00:03:14,000
e nós estamos multiplicando cada díxito pola potencia correspondente de 2.

54
00:03:14,000 --> 00:03:19,000
E lembre, para hexadecimal denotamos estes números con 0x no inicio

55
00:03:19,000 --> 00:03:23,000
para que non se confunda con un número decimal.

56
00:03:23,000 --> 00:03:29,000
Continuando, esta é unha táboa ASCII,

57
00:03:29,000 --> 00:03:35,000
eo que nós usamos ASCII para se situar a partir de caracteres para valores numéricos.

58
00:03:35,000 --> 00:03:39,000
Teña en conta que no pset cifrado que fixo uso extensivo da táboa ASCII

59
00:03:39,000 --> 00:03:43,000
a fin de utilizar varios métodos de criptografía,

60
00:03:43,000 --> 00:03:47,000
o César ea cifra de Vigenère, para converterse letras diferentes

61
00:03:47,000 --> 00:03:52,000
nunha cadea de acordo coa clave dada polo usuario.

62
00:03:52,000 --> 00:03:56,000
Imos mirar un pouco de matemáticas ASCII.

63
00:03:56,000 --> 00:04:02,000
Mirando para 'P' + 1, na forma de carácteres, que sería Q,

64
00:04:02,000 --> 00:04:07,000
e lembre que '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
E como exactamente pode converter entre estas dúas formas?

66
00:04:10,000 --> 00:04:13,000
Non é realmente moi difícil.

67
00:04:13,000 --> 00:04:16,000
A fin de obter 5 subtraímos '0 '

68
00:04:16,000 --> 00:04:20,000
porque hai cinco prazas entre o '0 'eo '5'.

69
00:04:20,000 --> 00:04:23,000
Co fin de ir por outro camiño que acabamos de engadir a 0,

70
00:04:23,000 --> 00:04:25,000
por iso é unha especie de como aritmética regular.

71
00:04:25,000 --> 00:04:29,000
Basta lembrar que cando algo ten aspas arredor del é un personaxe

72
00:04:29,000 --> 00:04:37,000
e, polo tanto, corresponde a un valor na táboa ASCII.

73
00:04:37,000 --> 00:04:40,000
Movéndose para temas máis xerais da ciencia de ordenadores.

74
00:04:40,000 --> 00:04:43,000
Aprendemos que un algoritmo é e como se usa a programación

75
00:04:43,000 --> 00:04:45,000
para aplicar algoritmos.

76
00:04:45,000 --> 00:04:48,000
Algúns exemplos de algoritmos son algo realmente simple como

77
00:04:48,000 --> 00:04:51,000
comprobar se un número é par ou impar.

78
00:04:51,000 --> 00:04:54,000
Para que lembrar que mod o número por 2 e comprobar o resultado é 0.

79
00:04:54,000 --> 00:04:57,000
Se é así, é mesmo. Se non é estraño.

80
00:04:57,000 --> 00:04:59,000
E iso é un exemplo dun algoritmo moi básico.

81
00:04:59,000 --> 00:05:02,000
>> Un pouco de máis dun implicado é de busca binária,

82
00:05:02,000 --> 00:05:05,000
que falaremos sobre máis tarde na sesión de revisión.

83
00:05:05,000 --> 00:05:09,000
E a programación é o termo que usan para tomar un algoritmo

84
00:05:09,000 --> 00:05:15,000
e convertela-lo para codificar o ordenador poida ler.

85
00:05:15,000 --> 00:05:20,000
2 exemplos de programación Scratch,

86
00:05:20,000 --> 00:05:22,000
que é o que nós fixemos a Semana 0.

87
00:05:22,000 --> 00:05:25,000
Aínda que realmente non escribir o código é unha forma de implementar

88
00:05:25,000 --> 00:05:29,000
Nese algoritmo, o cal está a imprimir os números 1-10,

89
00:05:29,000 --> 00:05:32,000
e aquí podemos facer o mesmo na linguaxe de programación C.

90
00:05:32,000 --> 00:05:41,000
Estes son funcionalmente equivalentes, só escrito en diferentes linguas ou de sintaxe.

91
00:05:41,000 --> 00:05:44,000
A continuación, aprendeu sobre expresións booleanas,

92
00:05:44,000 --> 00:05:48,000
e un booleano é un valor que é certo ou falso,

93
00:05:48,000 --> 00:05:51,000
e expresións aquí moitas veces booleanos

94
00:05:51,000 --> 00:05:55,000
ir dentro de condicións, por iso, se (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
ben, nós xa definido x = 5, de xeito que condición vai avaliar a true.

96
00:06:00,000 --> 00:06:03,000
E se é verdade, calquera código que está por debaixo da condición

97
00:06:03,000 --> 00:06:08,000
Vai ser avaliada polo ordenador, de xeito que a corda que vai ser impreso

98
00:06:08,000 --> 00:06:12,000
para a saída estándar, ea condición prazo

99
00:06:12,000 --> 00:06:16,000
refírese a todo o que está dentro dos parénteses da declaración se.

100
00:06:16,000 --> 00:06:20,000
Lembre-se de todos os operadores.

101
00:06:20,000 --> 00:06:26,000
Lembre-se de && e | | cando estamos intentando combinar dous ou máis condicións,

102
00:06:26,000 --> 00:06:30,000
= Non == para comprobar se dúas cousas son iguais.

103
00:06:30,000 --> 00:06:36,000
Lembre que é = a asignación mentres == é un operador booleano.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ e despois o final 2 son auto-explicativos.

105
00:06:41,000 --> 00:06:45,000
Unha revisión xeral da lóxica booleana aquí.

106
00:06:45,000 --> 00:06:48,000
E expresións booleanas tamén son importantes en loops,

107
00:06:48,000 --> 00:06:50,000
que nós imos pasar por riba agora.

108
00:06:50,000 --> 00:06:56,000
Nós aprendemos sobre tres tipos de loops ata agora en CS50, polo de agora, e facer agora.

109
00:06:56,000 --> 00:06:59,000
E é importante saber que, mentres na maioría dos casos

110
00:06:59,000 --> 00:07:02,000
podemos realmente usar calquera tipo de loop xeralmente

111
00:07:02,000 --> 00:07:06,000
existen certos tipos de propósitos ou patróns comúns

112
00:07:06,000 --> 00:07:09,000
na programación que, especificamente, chamar a un destes lazos

113
00:07:09,000 --> 00:07:13,000
que fan que o. máis eficiente ou elegante para codifica-lo desa forma

114
00:07:13,000 --> 00:07:18,000
Imos falar sobre o que cada un destes ciclos tende a ser usado para máis frecuencia.

115
00:07:18,000 --> 00:07:21,000
>> En un loop que xeralmente xa sabe cantas veces queiramos interactuar.

116
00:07:21,000 --> 00:07:24,000
Isto é o que poñemos na condición.

117
00:07:24,000 --> 00:07:28,000
Para i = 0, i <10, por exemplo.

118
00:07:28,000 --> 00:07:31,000
Nós xa sabemos que queremos facer algo 10 veces.

119
00:07:31,000 --> 00:07:34,000
Agora, para un loop while, xeralmente non necesariamente

120
00:07:34,000 --> 00:07:36,000
Sabe cantas veces queremos que o lazo sexa executado.

121
00:07:36,000 --> 00:07:39,000
Pero sabemos que algún tipo de condición que queremos que

122
00:07:39,000 --> 00:07:41,000
sempre certo ou ser sempre falso.

123
00:07:41,000 --> 00:07:44,000
Por exemplo, mentres que é definido.

124
00:07:44,000 --> 00:07:46,000
Imos dicir que é unha variable booleana.

125
00:07:46,000 --> 00:07:48,000
Mentres tanto é verdade que queremos o código para avaliar,

126
00:07:48,000 --> 00:07:52,000
así un pouco máis extensible, un pouco máis xeral do que un loop,

127
00:07:52,000 --> 00:07:55,000
pero ningún por lazo pode ser convertido a un loop.

128
00:07:55,000 --> 00:08:00,000
Finalmente, facer loops while, que pode ser o máis complicado de entender de inmediato,

129
00:08:00,000 --> 00:08:04,000
son usados ​​frecuentemente cando queremos avaliar o primeiro código

130
00:08:04,000 --> 00:08:06,000
antes da primeira vez que comprobar a condición.

131
00:08:06,000 --> 00:08:09,000
Un caso de uso común para un facer loop while

132
00:08:09,000 --> 00:08:12,000
é cando quere obter a entrada do usuario, e vostede sabe que quere preguntar ao usuario

133
00:08:12,000 --> 00:08:15,000
para a entrada de polo menos unha vez, pero se eles non dan a vostede unha boa entrada de inmediato

134
00:08:15,000 --> 00:08:18,000
quere seguir facendo ata que eles dan-lle a boa entrada.

135
00:08:18,000 --> 00:08:21,000
Ese é o uso máis común de un loop Do While,

136
00:08:21,000 --> 00:08:23,000
e imos ollar para a estrutura real de estes lazos.

137
00:08:23,000 --> 00:08:27,000
Eles normalmente sempre tenden a seguir estes patróns.

138
00:08:27,000 --> 00:08:30,000
>> O lazo para dentro de ti ter 3 compoñentes:

139
00:08:30,000 --> 00:08:35,000
inicio, tipicamente algo int i = 0, onde i é o contador,

140
00:08:35,000 --> 00:08:40,000
condición, onde nós queremos dicir para realizar este ciclo mentres a esa condición aínda permanece,

141
00:08:40,000 --> 00:08:44,000
como i <10, e despois, finalmente, actualización, que é como incrementar

142
00:08:44,000 --> 00:08:47,000
a variable de contador en cada punto do ciclo.

143
00:08:47,000 --> 00:08:50,000
Unha cousa común para ver que hai só i + +,

144
00:08:50,000 --> 00:08:52,000
o que significa incrementar i por unha de cada vez.

145
00:08:52,000 --> 00:08:55,000
Tamén pode facer algo como i + = 2,

146
00:08:55,000 --> 00:08:58,000
o que significa engadir 2 a I Cada vez que pasar polo loop.

147
00:08:58,000 --> 00:09:03,000
E entón a facer iso só se refire a calquera código que realmente funciona como parte do ciclo.

148
00:09:03,000 --> 00:09:09,000
E para un loop while, esta vez nós realmente temos o arranque fóra do circuíto,

149
00:09:09,000 --> 00:09:12,000
así, por exemplo, imos dicir que estamos a tentar facer o mesmo tipo de loop como acaba de describir.

150
00:09:12,000 --> 00:09:16,000
Diriamos int i = 0 antes do lazo comeza.

151
00:09:16,000 --> 00:09:20,000
Entón poderiamos dicir mentres i <10 facelo,

152
00:09:20,000 --> 00:09:22,000
así mesmo bloque de código como antes,

153
00:09:22,000 --> 00:09:26,000
e esta vez a parte de actualización do código, por exemplo, i + +,

154
00:09:26,000 --> 00:09:29,000
realmente vai dentro do loop.

155
00:09:29,000 --> 00:09:33,000
E, finalmente, para un facer agora, é semellante ao do loop while,

156
00:09:33,000 --> 00:09:36,000
pero temos que lembrar que o código pode avaliar unha vez

157
00:09:36,000 --> 00:09:40,000
antes a condición é posible, por iso fai moito máis sentido

158
00:09:40,000 --> 00:09:44,000
se ollar para el, a fin de arriba para abaixo.

159
00:09:44,000 --> 00:09:49,000
Nun, facer mentres o código loop avalía antes de ollar para a condición, mentres

160
00:09:49,000 --> 00:09:55,000
mentres que un loop while, el verifica primeiro.

161
00:09:55,000 --> 00:09:59,000
Demostracións e variables.

162
00:09:59,000 --> 00:10:04,000
Cando queremos crear unha nova variable que primeiro quere para o arrincar.

163
00:10:04,000 --> 00:10:07,000
>> Por exemplo, a barra int inicia a barra variable,

164
00:10:07,000 --> 00:10:10,000
pero non darlle un valor, entón o que é o valor bar agora?

165
00:10:10,000 --> 00:10:12,000
Nós non sabemos.

166
00:10:12,000 --> 00:10:14,000
Pode ser un valor de lixo que foi previamente almacenado na memoria de alí,

167
00:10:14,000 --> 00:10:16,000
e nós non queremos usar esa variable

168
00:10:16,000 --> 00:10:19,000
ata que, en realidade, darlle un valor,

169
00:10:19,000 --> 00:10:21,000
para que declara-lo aquí.

170
00:10:21,000 --> 00:10:24,000
A continuación, iniciar a ser 42 a continuación.

171
00:10:24,000 --> 00:10:28,000
Agora, por suposto, sabemos que isto pode ser feito nunha única liña, bar int = 42.

172
00:10:28,000 --> 00:10:30,000
Pero só para quedar claro as distintas etapas que están en curso,

173
00:10:30,000 --> 00:10:34,000
a declaración e arranque están a suceder por separado aquí.

174
00:10:34,000 --> 00:10:38,000
Isto acontece nunha única etapa, e na próxima, int Baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
esta declaración abaixo, que Baz incrementos para que ao final do bloque de código

176
00:10:44,000 --> 00:10:48,000
se fósemos para imprimir o valor Baz sería 44

177
00:10:48,000 --> 00:10:52,000
porque declarar e arrincar que sexa unha barra de>,

178
00:10:52,000 --> 00:10:58,000
e entón incrementa-lo unha vez máis co + +.

179
00:10:58,000 --> 00:11:02,000
Nós fomos sobre iso brevemente bonito, pero é bo ter un xeneral

180
00:11:02,000 --> 00:11:04,000
comprensión do que temas e eventos.

181
00:11:04,000 --> 00:11:06,000
Nós principalmente, fixo iso en scratch,

182
00:11:06,000 --> 00:11:09,000
para que poida pensar en temas como varias secuencias de código

183
00:11:09,000 --> 00:11:11,000
executando ao mesmo tempo.

184
00:11:11,000 --> 00:11:14,000
En realidade, probabelmente non está funcionando, ao mesmo tempo,

185
00:11:14,000 --> 00:11:17,000
pero unha especie de abstractamente podemos pensar niso desa forma.

186
00:11:17,000 --> 00:11:20,000
>> No Scratch, por exemplo, tivemos os distintos sprites.

187
00:11:20,000 --> 00:11:22,000
Podería ser de execución de código diferentes ao mesmo tempo.

188
00:11:22,000 --> 00:11:26,000
Un deles podería ser a pé, mentres que o outro está dicindo algo

189
00:11:26,000 --> 00:11:29,000
nunha parte diferente da pantalla.

190
00:11:29,000 --> 00:11:34,000
Os eventos son unha outra forma de separar a lóxica

191
00:11:34,000 --> 00:11:37,000
entre os distintos elementos do seu código,

192
00:11:37,000 --> 00:11:40,000
e scratch fomos capaces de simular eventos usando Broadcast,

193
00:11:40,000 --> 00:11:43,000
e que é, en realidade, cando eu recibir, non cando escoito,

194
00:11:43,000 --> 00:11:47,000
pero, esencialmente, é unha forma de transmitir información

195
00:11:47,000 --> 00:11:49,000
a partir dun sprite para o outro.

196
00:11:49,000 --> 00:11:52,000
Por exemplo, pode querer transmitir ao longo do xogo,

197
00:11:52,000 --> 00:11:56,000
e cando outro sprite recibe ao longo do xogo,

198
00:11:56,000 --> 00:11:58,000
el responde dunha certa maneira.

199
00:11:58,000 --> 00:12:03,000
É un modelo importante para comprender a programación.

200
00:12:03,000 --> 00:12:07,000
Só para ir durante a semana básica 0, o que xa sabemos, ata agora,

201
00:12:07,000 --> 00:12:10,000
imos mirar para este programa C simple.

202
00:12:10,000 --> 00:12:14,000
O texto pode ser un pouco pequeno, a partir de aquí, pero eu vou pasar por iso moi rápido.

203
00:12:14,000 --> 00:12:20,000
Estamos incluíndo dous ficheiros de cabeceira na parte superior, cs50.h e stdio.h.

204
00:12:20,000 --> 00:12:23,000
Estamos entón a definición dun límite constante chamado a ser 100.

205
00:12:23,000 --> 00:12:26,000
Estamos a continuación, aplicar a nosa función principal.

206
00:12:26,000 --> 00:12:29,000
Unha vez que non usar argumentos de liña de comandos aquí, cómpre poñer baleiro

207
00:12:29,000 --> 00:12:32,000
como os argumentos para inicio.

208
00:12:32,000 --> 00:12:38,000
Vemos int enriba principal. Ese é o tipo de retorno, polo tanto, volver 0 na parte inferior.

209
00:12:38,000 --> 00:12:41,000
E estamos usando CS50 función de biblioteca obter int

210
00:12:41,000 --> 00:12:45,000
para pedir ao usuario para a entrada, e almacena-lo nesta variable x,

211
00:12:45,000 --> 00:12:51,000
Así, declaramos x arriba, e arrincar-lo con x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> A continuación, comproba que o usuario nos deu unha boa entrada.

213
00:12:53,000 --> 00:12:59,000
Se é LÍMITE ≥ queremos voltar un código de erro de 1 e imprimir unha mensaxe de erro.

214
00:12:59,000 --> 00:13:02,000
E, finalmente, a entrada o usuario ten nos dado boa

215
00:13:02,000 --> 00:13:08,000
imos facer a quadratura do número e imprima o resultado.

216
00:13:08,000 --> 00:13:11,000
Só para estar seguro de que os casa hit todos

217
00:13:11,000 --> 00:13:17,000
podes ver as etiquetas de diferentes partes do código aquí.

218
00:13:17,000 --> 00:13:19,000
Mencionei constantes, arquivos de cabeceira.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Asegúrese de lembrar que é unha variable local.

220
00:13:21,000 --> 00:13:24,000
Isto contrasta dunha variable global, o que imos falar sobre

221
00:13:24,000 --> 00:13:27,000
un pouco máis tarde na sesión de revisión,

222
00:13:27,000 --> 00:13:30,000
e estamos chamando a función de biblioteca printf,

223
00:13:30,000 --> 00:13:34,000
Polo tanto, se non había incluído o ficheiro de cabeceira stdio.h

224
00:13:34,000 --> 00:13:37,000
non sería capaz de chamar printf.

225
00:13:37,000 --> 00:13:42,000
E creo que a frecha que foi cortada aquí está a apuntar cara o% d,

226
00:13:42,000 --> 00:13:45,000
que é unha cadea de formato no printf.

227
00:13:45,000 --> 00:13:52,000
Di imprimir esa variable como un número% d.

228
00:13:52,000 --> 00:13:58,000
E é que para a Semana 0.

229
00:13:58,000 --> 00:14:06,000
Agora Lucas vai continuar.

230
00:14:06,000 --> 00:14:08,000
Ola, persoal. O meu nome é Lucas.

231
00:14:08,000 --> 00:14:10,000
Eu son un estudante de segundo ano da mellor casa no campus, Mather,

232
00:14:10,000 --> 00:14:14,000
e eu vou falar un pouco sobre a semana 1 e 2,1.

233
00:14:14,000 --> 00:14:16,000
[Semana 1 e 2,1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Como Lexi estaba dicindo, cando comezamos a traducir o seu código a partir de cero para C

235
00:14:19,000 --> 00:14:23,000
unha das cousas que percibimos é que non pode simplemente

236
00:14:23,000 --> 00:14:26,000
escribir o seu código e executa-lo usando unha bandeira verde máis.

237
00:14:26,000 --> 00:14:30,000
En realidade, ten que usar algunhas medidas para facer o seu programa C

238
00:14:30,000 --> 00:14:33,000
tornar-se un arquivo executábel.

239
00:14:33,000 --> 00:14:36,000
Basicamente o que fai cando está escribindo un programa que

240
00:14:36,000 --> 00:14:40,000
traducir a súa idea nunha linguaxe que un compilador pode entender,

241
00:14:40,000 --> 00:14:44,000
Entón, cando está escribindo un programa en C

242
00:14:44,000 --> 00:14:47,000
o que está facendo é realmente escribir algo que o compilador vai entender,

243
00:14:47,000 --> 00:14:50,000
e, a continuación, o compilador vai traducir este código

244
00:14:50,000 --> 00:14:53,000
en algo que o ordenador vai entender.

245
00:14:53,000 --> 00:14:55,000
>> E a cousa é, o seu ordenador é realmente moi burro.

246
00:14:55,000 --> 00:14:57,000
O seu ordenador non pode entender 0s e 1s,

247
00:14:57,000 --> 00:15:01,000
Entón, en realidade nos primeiros ordenadores xente xeralmente programados

248
00:15:01,000 --> 00:15:04,000
usando 0s e 1s, pero non máis, grazas a Deus.

249
00:15:04,000 --> 00:15:07,000
Non temos que memorizar secuencias de 0s e 1s

250
00:15:07,000 --> 00:15:10,000
para un loop ou loop de tempo e así por diante.

251
00:15:10,000 --> 00:15:13,000
É por iso que temos un compilador.

252
00:15:13,000 --> 00:15:17,000
O que un compilador fai é, basicamente, traduce o código C,

253
00:15:17,000 --> 00:15:21,000
no noso caso, para unha linguaxe que o ordenador vai entender,

254
00:15:21,000 --> 00:15:25,000
Que é o código obxecto, eo compilador que estamos usando

255
00:15:25,000 --> 00:15:30,000
chámase bumbum, polo que esta é, en realidade, o símbolo para o bumbum.

256
00:15:30,000 --> 00:15:33,000
Cando ten o seu programa, ten que facer dúas cousas.

257
00:15:33,000 --> 00:15:37,000
Primeiro, ten que compilar o seu programa, e entón está indo para executar o seu programa.

258
00:15:37,000 --> 00:15:41,000
Para compilar o seu programa que ten unha morea de opcións para facelo.

259
00:15:41,000 --> 00:15:44,000
O primeiro é facer program.c bumbum

260
00:15:44,000 --> 00:15:47,000
en que programa é o nome do seu programa.

261
00:15:47,000 --> 00:15:51,000
Neste caso, podes ver que eles están só dicindo "Ola, compilar meu programa".

262
00:15:51,000 --> 00:15:56,000
Non está dicindo "Eu quero este nome para o meu programa", ou algo.

263
00:15:56,000 --> 00:15:58,000
>> A segunda opción é dar un nome para o seu programa.

264
00:15:58,000 --> 00:16:02,000
Pode dicir clang-o e, a continuación, o nome que quere

265
00:16:02,000 --> 00:16:06,000
o arquivo executábel para ser nomeado como e despois program.c.

266
00:16:06,000 --> 00:16:11,000
E tamén pode facer facer programa, e ver como nos primeiros dous casos

267
00:16:11,000 --> 00:16:15,000
Eu coloque. C, e no terceiro eu só teño programas?

268
00:16:15,000 --> 00:16:18,000
Si, realmente non debe poñer. C cando usa facer.

269
00:16:18,000 --> 00:16:22,000
En caso contrario, o compilador é, en realidade, vai berrar con vostede.

270
00:16:22,000 --> 00:16:24,000
E tamén, eu non sei se vostedes lembran,

271
00:16:24,000 --> 00:16:29,000
pero moitas veces tamén usan-lcs50 ou lm.

272
00:16:29,000 --> 00:16:31,000
Iso é chamado de conexión.

273
00:16:31,000 --> 00:16:35,000
El só informa o compilador que vai usar esas bibliotecas alí,

274
00:16:35,000 --> 00:16:39,000
por iso, se quere usar cs50.h realmente ten que escribir

275
00:16:39,000 --> 00:16:43,000
clang program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Se non fai iso, o compilador non vai saber

277
00:16:45,000 --> 00:16:50,000
que está a usar estas funcións en cs50.h.

278
00:16:50,000 --> 00:16:52,000
E cando quere executar o programa ten dúas opcións.

279
00:16:52,000 --> 00:16:57,000
Se fixo program.c clang non dar un nome para o seu programa.

280
00:16:57,000 --> 00:17:01,000
Ten que executa-lo usando. A.out /.

281
00:17:01,000 --> 00:17:06,000
A.out é un nome estándar que bumbum dá o seu programa se non darlle un nome.

282
00:17:06,000 --> 00:17:11,000
Se non, vai facer. Programa / se deu un nome para o seu programa,

283
00:17:11,000 --> 00:17:15,000
e tamén se fixo o nome do programa que o programa vai estar

284
00:17:15,000 --> 00:17:23,000
xa está indo para ser programado o mesmo nome que o ficheiro c.

285
00:17:23,000 --> 00:17:26,000
Entón nós falamos sobre os tipos de datos e datos.

286
00:17:26,000 --> 00:17:31,000
>> Basicamente tipos de datos son a mesma cousa que usan pequenas caixas

287
00:17:31,000 --> 00:17:35,000
para almacenar valores, por iso os tipos de datos son, en realidade, só como Pokémons.

288
00:17:35,000 --> 00:17:39,000
Eles veñen en todos os tamaños e tipos.

289
00:17:39,000 --> 00:17:43,000
Eu non sei se esa analoxía ten sentido.

290
00:17:43,000 --> 00:17:46,000
O tamaño dos datos, en realidade, depende da arquitectura da máquina.

291
00:17:46,000 --> 00:17:49,000
Todos os tamaños de datos que eu vou amosar aquí

292
00:17:49,000 --> 00:17:53,000
son, en realidade, para unha máquina de 32 bits, que é o caso do noso dispositivo,

293
00:17:53,000 --> 00:17:56,000
pero se está realmente codificación do seu Mac ou Windows tamén

294
00:17:56,000 --> 00:17:59,000
Probablemente vai ter unha máquina de 64 bits,

295
00:17:59,000 --> 00:18:03,000
para lembrar que os tamaños de datos que eu vou amosar aquí

296
00:18:03,000 --> 00:18:06,000
son para a máquina de 32 bits.

297
00:18:06,000 --> 00:18:08,000
O primeiro que vimos foi un int,

298
00:18:08,000 --> 00:18:10,000
que é moi sinxelo.

299
00:18:10,000 --> 00:18:13,000
Usa int para almacenar un número enteiro.

300
00:18:13,000 --> 00:18:16,000
Vimos tamén o carácter, o char.

301
00:18:16,000 --> 00:18:20,000
Se quere usar unha carta ou un pequeno símbolo que probablemente vai usar un char.

302
00:18:20,000 --> 00:18:26,000
Un char ten 1 byte, o que significa 8 bits, como Lexi dixo.

303
00:18:26,000 --> 00:18:31,000
Basicamente, temos unha táboa ASCII que 256

304
00:18:31,000 --> 00:18:34,000
combinacións posibles de 0s e 1s,

305
00:18:34,000 --> 00:18:37,000
e entón, cando inserir un carácter que vai traducir

306
00:18:37,000 --> 00:18:44,000
o carácter que as entradas un número que ten na táboa ASCII, como Lexi dixo.

307
00:18:44,000 --> 00:18:48,000
Temos tamén a boia, que usan para almacenar números decimais.

308
00:18:48,000 --> 00:18:53,000
Se queres escoller 3,14, por exemplo, vai empregar un flotador

309
00:18:53,000 --> 00:18:55,000
ou unha parella que ten máis precisión.

310
00:18:55,000 --> 00:18:57,000
Unha boia ten 4 bytes.

311
00:18:57,000 --> 00:19:01,000
O dúo ten 8 bytes, entón a única diferenza é a precisión.

312
00:19:01,000 --> 00:19:04,000
Temos tamén unha lonxitude que se usa para enteiros,

313
00:19:04,000 --> 00:19:09,000
e podes ver por unha máquina de 32 bits dun int e un long teñen o mesmo tamaño,

314
00:19:09,000 --> 00:19:13,000
por iso non fai moito sentido usar un longa nunha máquina de 32 bits.

315
00:19:13,000 --> 00:19:17,000
>> Pero se vostede está a usar un ordenador Mac e 64-bit, en realidade, unha longa ten tamaño 8,

316
00:19:17,000 --> 00:19:19,000
por iso realmente depende da arquitectura.

317
00:19:19,000 --> 00:19:22,000
Para a máquina de 32 bits, non ten sentido usar un longa de verdade.

318
00:19:22,000 --> 00:19:25,000
E, a continuación, un tempo longo, por outro lado, ten 8 bytes,

319
00:19:25,000 --> 00:19:30,000
por iso é moi bo se quere ter un número enteiro máis.

320
00:19:30,000 --> 00:19:34,000
E, finalmente, temos cadea, que é na verdade un char *,

321
00:19:34,000 --> 00:19:37,000
que é un punteiro para unha char.

322
00:19:37,000 --> 00:19:40,000
É moi fácil pensar que o tamaño da cadea vai ser como

323
00:19:40,000 --> 00:19:42,000
o número de caracteres que ten alí,

324
00:19:42,000 --> 00:19:45,000
pero, en realidade, * o char-se

325
00:19:45,000 --> 00:19:49,000
ten o tamaño dun punteiro para unha char, que é de 4 bytes.

326
00:19:49,000 --> 00:19:52,000
O tamaño dunha char * é 4 bytes.

327
00:19:52,000 --> 00:19:56,000
Non importa se ten unha pequena palabra ou unha letra ou algo.

328
00:19:56,000 --> 00:19:58,000
Vai ser de 4 bytes.

329
00:19:58,000 --> 00:20:01,000
Tamén aprendemos un pouco sobre o reparto,

330
00:20:01,000 --> 00:20:04,000
Entón, como podes ver, se ten, por exemplo, un programa que di

331
00:20:04,000 --> 00:20:08,000
int x = 3 e, a continuación, printf ("% d", x / 2)

332
00:20:08,000 --> 00:20:12,000
vostedes saben o que vai imprimir na pantalla?

333
00:20:12,000 --> 00:20:14,000
>> Alguén? >> [Os alumnos] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, si.

335
00:20:16,000 --> 00:20:20,000
Cando fai 3/2 vai obter 1,5,

336
00:20:20,000 --> 00:20:24,000
pero xa que estamos usando un enteiro que vai ignorar a parte decimal,

337
00:20:24,000 --> 00:20:26,000
e vai ter un.

338
00:20:26,000 --> 00:20:29,000
Se non quere que isto ocorre o que podes facer, por exemplo,

339
00:20:29,000 --> 00:20:33,000
é declarar un float y = x.

340
00:20:33,000 --> 00:20:40,000
Entón x que adoitaban ser tres agora vai ser 3,000 en y.

341
00:20:40,000 --> 00:20:44,000
E entón podes imprimir o s / 2.

342
00:20:44,000 --> 00:20:50,000
En realidade, eu debería ter un 2. alí.

343
00:20:50,000 --> 00:20:55,000
El vai facer 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
e está indo para obter 1,5.

345
00:20:58,000 --> 00:21:06,000
E temos esa f 0,2 só para pedir 2 unidades decimais da parte decimal.

346
00:21:06,000 --> 00:21:12,000
Se ten 0,3 f que vai ter, en realidade, 1.500.

347
00:21:12,000 --> 00:21:16,000
Se é 2, será 1,50.

348
00:21:16,000 --> 00:21:18,000
Tamén temos ese caso aquí.

349
00:21:18,000 --> 00:21:22,000
Se fai float x = 3,14 e entón x printf

350
00:21:22,000 --> 00:21:24,000
está indo para obter 3.14.

351
00:21:24,000 --> 00:21:29,000
E se fai x = int X,

352
00:21:29,000 --> 00:21:34,000
o que significa tratar x como un int e imprimir x agora

353
00:21:34,000 --> 00:21:36,000
vai ter 3,00.

354
00:21:36,000 --> 00:21:38,000
Isto ten sentido?

355
00:21:38,000 --> 00:21:41,000
Porque é primeiro tratar x como un número enteiro, entón está ignorando a parte decimal,

356
00:21:41,000 --> 00:21:45,000
e entón está imprimindo x.

357
00:21:45,000 --> 00:21:47,000
E, finalmente, tamén se pode facer iso,

358
00:21:47,000 --> 00:21:52,000
int x = 65, e entón declarar un char c = x,

359
00:21:52,000 --> 00:21:56,000
e entón se imprimir o c realmente está indo para obter

360
00:21:56,000 --> 00:21:59,000
Un, entón basicamente o que está facendo aquí

361
00:21:59,000 --> 00:22:02,000
está traducindo o enteiro para o personaxe,

362
00:22:02,000 --> 00:22:05,000
así como a táboa ASCII fai.

363
00:22:05,000 --> 00:22:08,000
Tamén falamos sobre operadores matemáticos.

364
00:22:08,000 --> 00:22:14,000
A maioría deles son moi sinxelo, para +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
e tamén falamos sobre mod, que é o resto da división de dous números.

366
00:22:20,000 --> 00:22:23,000
Se ten un 10% 3, por exemplo,

367
00:22:23,000 --> 00:22:27,000
significa dividir 10 por 3, e que é a parte restante?

368
00:22:27,000 --> 00:22:30,000
Vai ser 1, polo que é realmente moi útil para unha morea de programas.

369
00:22:30,000 --> 00:22:38,000
Para Vigenère e César eu estou seguro que todos vostedes utilizado mod.

370
00:22:38,000 --> 00:22:43,000
Sobre operadores matemáticos, ter moito coidado ao combinar * e /.

371
00:22:43,000 --> 00:22:48,000
>> Por exemplo, se vostede fai (3/2) * 2 o que vai conseguir?

372
00:22:48,000 --> 00:22:50,000
[Os alumnos] 2.

373
00:22:50,000 --> 00:22:54,000
É, 2, por 3/2 vai ser igual a 1,5,

374
00:22:54,000 --> 00:22:57,000
pero unha vez que está facendo operacións entre dous números enteiros

375
00:22:57,000 --> 00:22:59,000
en realidade está indo só para considerar un,

376
00:22:59,000 --> 00:23:03,000
e 1 * 2 vai ser 2, que debe ter moito coidado

377
00:23:03,000 --> 00:23:07,000
ao facer aritmética con enteiros porque

378
00:23:07,000 --> 00:23:12,000
pode ter que 2 = 3, nese caso.

379
00:23:12,000 --> 00:23:14,000
E tamén ter moito coidado coa precedencia.

380
00:23:14,000 --> 00:23:21,000
Normalmente usar parénteses para estar seguro de que sabe o que está facendo.

381
00:23:21,000 --> 00:23:27,000
Algúns atallos útiles, por suposto, é un i + + ou i + = 1

382
00:23:27,000 --> 00:23:30,000
ou usando + =.

383
00:23:30,000 --> 00:23:34,000
Isto é o mesmo que facer i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Tamén pode facer I - ou I - = 1,

385
00:23:39,000 --> 00:23:42,000
que é a mesma cousa que i = i -1,

386
00:23:42,000 --> 00:23:46,000
algo que vostedes usan unha morea de loops, polo menos.

387
00:23:46,000 --> 00:23:52,000
Ademais, para *, se usa * = e se, por exemplo,

388
00:23:52,000 --> 00:23:57,000
i * = 2 é o mesmo que dicir i = i * 2,

389
00:23:57,000 --> 00:23:59,000
ea mesma cousa para a división.

390
00:23:59,000 --> 00:24:08,000
Se fai i / = 2 é a mesma cousa que i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Agora sobre funcións.

392
00:24:10,000 --> 00:24:13,000
Vostedes aprenderon que funcións son unha estratexia moi boa para salvar código

393
00:24:13,000 --> 00:24:16,000
mentres está programando, entón se quere realizar a mesma tarefa

394
00:24:16,000 --> 00:24:20,000
no código de novo e de novo, probablemente quere usar unha función

395
00:24:20,000 --> 00:24:25,000
só así non tes que copiar e pegar o código unha e outra vez.

396
00:24:25,000 --> 00:24:28,000
En realidade, a principal é unha función, e cando amosar-lle o formato dunha función

397
00:24:28,000 --> 00:24:32,000
vai ver que é moi evidente.

398
00:24:32,000 --> 00:24:35,000
Tamén usamos funcións dalgunhas bibliotecas,

399
00:24:35,000 --> 00:24:39,000
por exemplo, printf, Getin, que é a partir da biblioteca de CS50,

400
00:24:39,000 --> 00:24:43,000
e outras funcións como toupper.

401
00:24:43,000 --> 00:24:46,000
Todas estas funcións son realmente aplicadas noutras bibliotecas,

402
00:24:46,000 --> 00:24:49,000
e cando poñer estes arquivos tether no inicio do seu programa

403
00:24:49,000 --> 00:24:53,000
está dicindo que pode por favor me dar o código para estas funcións

404
00:24:53,000 --> 00:24:57,000
entón eu non teño que aplica-las por min mesmo?

405
00:24:57,000 --> 00:25:00,000
E tamén pode escribir as súas propias funcións, entón cando comezar a programar

406
00:25:00,000 --> 00:25:04,000
entender que as bibliotecas non teñen todas as funcións que precisa.

407
00:25:04,000 --> 00:25:10,000
Para o pset pasado, por exemplo, escribir deseñar, scramble, e de investigación,

408
00:25:10,000 --> 00:25:13,000
e é moi, moi importante para ser capaz de escribir funcións

409
00:25:13,000 --> 00:25:17,000
porque son útiles, e usalos todo o tempo na programación,

410
00:25:17,000 --> 00:25:19,000
e el salva unha morea de código.

411
00:25:19,000 --> 00:25:21,000
O formato dunha función é esta.

412
00:25:21,000 --> 00:25:24,000
Temos tipo de retorno no inicio. Cal é o tipo de retorno?

413
00:25:24,000 --> 00:25:27,000
É só cando a función devolverá.

414
00:25:27,000 --> 00:25:29,000
Se vostede ten unha función, por exemplo, factorial,

415
00:25:29,000 --> 00:25:31,000
que se vai calcular unha factorial dun número enteiro,

416
00:25:31,000 --> 00:25:34,000
probablemente vai voltar un enteiro tamén.

417
00:25:34,000 --> 00:25:37,000
A continuación, o tipo de retorno vai ser int.

418
00:25:37,000 --> 00:25:41,000
Printf realmente ten un tipo de retorno void

419
00:25:41,000 --> 00:25:43,000
porque non está retornando nada.

420
00:25:43,000 --> 00:25:45,000
Vostede está só imprimir cousas na pantalla

421
00:25:45,000 --> 00:25:48,000
e saír da función despois.

422
00:25:48,000 --> 00:25:51,000
Entón tes o nome da función que pode escoller.

423
00:25:51,000 --> 00:25:55,000
Debe ser un pouco razoable, como non escoller un nome como xyz

424
00:25:55,000 --> 00:25:58,000
ou como X2F.

425
00:25:58,000 --> 00:26:02,000
Probe facer-se un nome que ten sentido.

426
00:26:02,000 --> 00:26:04,000
>> Por exemplo, se é factorial, din factorial.

427
00:26:04,000 --> 00:26:08,000
Se é unha función que vai deseñar algo, chame-o deseñar.

428
00:26:08,000 --> 00:26:11,000
E despois temos os parámetros, que son tamén chamados de argumentos,

429
00:26:11,000 --> 00:26:14,000
que son como os recursos que a súa función debe

430
00:26:14,000 --> 00:26:17,000
desde o seu código para realizar a súa tarefa.

431
00:26:17,000 --> 00:26:20,000
Se queres calcular o factorial dun número

432
00:26:20,000 --> 00:26:23,000
probablemente precisa ter un número para calcular un factorial.

433
00:26:23,000 --> 00:26:27,000
Un dos argumentos que vai ter é o propio número.

434
00:26:27,000 --> 00:26:31,000
E entón el vai facer algo e voltar o valor ao final

435
00:26:31,000 --> 00:26:35,000
a menos que sexa unha función void.

436
00:26:35,000 --> 00:26:37,000
Imos ver un exemplo.

437
00:26:37,000 --> 00:26:40,000
Se eu queira escribir unha función que suma todos os números en un array de enteiros,

438
00:26:40,000 --> 00:26:43,000
en primeiro lugar, o tipo de retorno vai ser int

439
00:26:43,000 --> 00:26:46,000
porque eu teño un array de enteiros.

440
00:26:46,000 --> 00:26:51,000
E entón eu vou ter o nome da función como sumArray,

441
00:26:51,000 --> 00:26:54,000
e entón el vai levar o propio array para nums int

442
00:26:54,000 --> 00:26:58,000
e entón a lonxitude da matriz, entón eu sei cantos números eu teño que sumar.

443
00:26:58,000 --> 00:27:02,000
Entón eu teño que arrincar unha contía variable chamada, por exemplo, para 0,

444
00:27:02,000 --> 00:27:08,000
e cada vez que vexo un elemento na matriz Debo engadir que a suma, entón eu fixen un loop.

445
00:27:08,000 --> 00:27:15,000
Así como dixo Lexi, vostede int i = 0, i lonxitude <e i + +.

446
00:27:15,000 --> 00:27:20,000
E para cada elemento da matriz que fixen suma + = nums [i],

447
00:27:20,000 --> 00:27:24,000
e despois volvín a suma, por iso é moi simple, e aforra unha morea de código

448
00:27:24,000 --> 00:27:28,000
Se está usando esta función unha morea de veces.

449
00:27:28,000 --> 00:27:32,000
Entón demos un ollo en condicións.

450
00:27:32,000 --> 00:27:38,000
Temos if, else e else if.

451
00:27:38,000 --> 00:27:42,000
Imos ver o que é a diferenza entre aqueles.

452
00:27:42,000 --> 00:27:45,000
Bótalle un ollo nestes dous códigos. Cal é a diferencia entre eles?

453
00:27:45,000 --> 00:27:49,000
O primeiro ten, basicamente os códigos quero que diga

454
00:27:49,000 --> 00:27:51,000
se un número é +, -, ou 0.

455
00:27:51,000 --> 00:27:55,000
O primeiro di si é> 0, entón é positivo.

456
00:27:55,000 --> 00:28:00,000
Se é = 0, é 0, e se é <0, entón é negativo.

457
00:28:00,000 --> 00:28:04,000
>> E o outro está facendo if, else if, else.

458
00:28:04,000 --> 00:28:07,000
A diferenza entre os dous é que este está indo realmente para

459
00:28:07,000 --> 00:28:13,000
comprobar se> 0, <0 = 0 ou tres veces,

460
00:28:13,000 --> 00:28:17,000
por iso, se ten o número 2, por exemplo, que vai vir aquí e dicir

461
00:28:17,000 --> 00:28:21,000
if (x> 0), e só pode dicir que si, entón eu imprimir positivo.

462
00:28:21,000 --> 00:28:25,000
Pero aínda que sei que é> 0 e non vai ser 0 ou <0

463
00:28:25,000 --> 00:28:29,000
Eu aínda vou facer é 0, é <0,

464
00:28:29,000 --> 00:28:33,000
entón eu estou indo realmente dentro IFS que eu non tiña que

465
00:28:33,000 --> 00:28:38,000
porque eu xa sei que non vai satisfacer calquera destas condicións.

466
00:28:38,000 --> 00:28:41,000
Podo utilizar o if, else if, else comunicado.

467
00:28:41,000 --> 00:28:45,000
El basicamente di que se x = 0 eu imprimir o positivo.

468
00:28:45,000 --> 00:28:48,000
Se non é, eu vou tamén probar isto.

469
00:28:48,000 --> 00:28:51,000
Se é 2, non vou facer iso.

470
00:28:51,000 --> 00:28:54,000
Basicamente, se eu x = 2, diría

471
00:28:54,000 --> 00:28:57,000
if (x> 0), si, para imprimir esta.

472
00:28:57,000 --> 00:29:00,000
Agora que sei que é> 0, e que satisfeito o primeiro

473
00:29:00,000 --> 00:29:02,000
Eu non estou indo a executar este código.

474
00:29:02,000 --> 00:29:09,000
O código é executado máis rápido, en realidade, tres veces máis rápido se usa isto.

475
00:29:09,000 --> 00:29:11,000
Tamén soubemos e e ou.

476
00:29:11,000 --> 00:29:15,000
Eu non vou pasar por iso porque Lexi xa falamos sobre eles.

477
00:29:15,000 --> 00:29:17,000
É só o && e operador | |.

478
00:29:17,000 --> 00:29:21,000
>> O único que eu vou dicir é ter coidado cando ten tres condicións.

479
00:29:21,000 --> 00:29:24,000
Use parénteses porque é moi confuso cando ten unha condición

480
00:29:24,000 --> 00:29:27,000
e outro, ou outro.

481
00:29:27,000 --> 00:29:30,000
Use parénteses só para estar seguro de que as súas condicións de ter sentido

482
00:29:30,000 --> 00:29:34,000
porque, nese caso, por exemplo, pode imaxinar que

483
00:29:34,000 --> 00:29:38,000
que podería ser a primeira condición e un ou o outro

484
00:29:38,000 --> 00:29:41,000
ou as dúas condicións combinadas nunha e

485
00:29:41,000 --> 00:29:45,000
ou o terceiro, entón teña coidado.

486
00:29:45,000 --> 00:29:48,000
E, finalmente, falamos de opcións.

487
00:29:48,000 --> 00:29:53,000
Un switch é moi útil cando ten unha variable.

488
00:29:53,000 --> 00:29:55,000
Imos dicir que ten unha variable como n

489
00:29:55,000 --> 00:29:59,000
que poden ser 0, 1 ou 2, e para cada un destes casos

490
00:29:59,000 --> 00:30:01,000
está indo a executar unha tarefa.

491
00:30:01,000 --> 00:30:04,000
Pode dicir cambiar a variable, e indica que

492
00:30:04,000 --> 00:30:08,000
o valor é, entón, como valor1 eu vou facer iso,

493
00:30:08,000 --> 00:30:12,000
e entón eu romper, o que significa que eu non vou mirar para calquera dos outros casos

494
00:30:12,000 --> 00:30:15,000
porque xa convencido de que no caso de

495
00:30:15,000 --> 00:30:20,000
e, a continuación, valor2 e así por diante, e tamén pode ter un interruptor estándar.

496
00:30:20,000 --> 00:30:24,000
Isto significa que se non satisfai calquera dos casos que eu tiven

497
00:30:24,000 --> 00:30:29,000
que eu vou facer outra cousa, pero iso é opcional.

498
00:30:29,000 --> 00:30:36,000
Isto é todo para min. Agora imos ter Tommy.

499
00:30:36,000 --> 00:30:41,000
Todo ben, isto vai ser Semana 3-ISH.

500
00:30:41,000 --> 00:30:45,000
Estes son algúns dos temas que imos cubrindo, cripto, alcance, matrices, etcétera.

501
00:30:45,000 --> 00:30:49,000
Só unha palabra rápida sobre criptografía. Nós non estamos indo a martelar esta casa.

502
00:30:49,000 --> 00:30:52,000
>> Fixemos iso en pset 2, pero para o quiz seguro que vostede sabe a diferencia

503
00:30:52,000 --> 00:30:54,000
entre a cifra de César ea cifra de Vigenère,

504
00:30:54,000 --> 00:30:57,000
como dous traballos cifras e como é para cifrar

505
00:30:57,000 --> 00:30:59,000
e descifrar o texto usando estes dous códigos.

506
00:30:59,000 --> 00:31:03,000
Lembre, a cifra de César simplemente xira cada personaxe co mesmo valor,

507
00:31:03,000 --> 00:31:06,000
asegurarse de mod polo número de letras no alfabeto.

508
00:31:06,000 --> 00:31:09,000
E a cifra de Vigenère, por outra banda, cada roda de caracteres

509
00:31:09,000 --> 00:31:12,000
por un importe distinto, entón en vez de dicir

510
00:31:12,000 --> 00:31:15,000
cada rolda caracteres por 3 Vigenère ha xirar cada personaxe

511
00:31:15,000 --> 00:31:17,000
por unha cantidade diferente dependendo de algunha contrasinal

512
00:31:17,000 --> 00:31:20,000
onde cada letra da palabra clave representa unha cantidade diferente

513
00:31:20,000 --> 00:31:26,000
para xirar o texto claro por.

514
00:31:26,000 --> 00:31:28,000
Imos primeiro falar sobre alcance de variables.

515
00:31:28,000 --> 00:31:30,000
Existen dous tipos de variables.

516
00:31:30,000 --> 00:31:33,000
Temos variables locais, e estes van ser definidos

517
00:31:33,000 --> 00:31:36,000
fóra do principal ou fóra de calquera función ou bloque,

518
00:31:36,000 --> 00:31:39,000
e estas estarán accesibles en calquera lugar no seu programa.

519
00:31:39,000 --> 00:31:41,000
Se vostede ten unha función e que función é un loop while

520
00:31:41,000 --> 00:31:44,000
a gran variable global é accesible en calquera lugar.

521
00:31:44,000 --> 00:31:48,000
Unha variable local, por outro lado, é delimitado ao lugar onde está definido.

522
00:31:48,000 --> 00:31:53,000
>> Se vostede ten unha función aquí, por exemplo, temos esta función g,

523
00:31:53,000 --> 00:31:56,000
e dentro g existe unha variable aquí chamada y,

524
00:31:56,000 --> 00:31:58,000
e iso significa que esta é unha variable local.

525
00:31:58,000 --> 00:32:00,000
Aínda que esta variable é chamada y

526
00:32:00,000 --> 00:32:03,000
e esta variable é chamado Y estas dúas funcións

527
00:32:03,000 --> 00:32:06,000
non teño idea do que cada un dos outros locais son variables.

528
00:32:06,000 --> 00:32:10,000
Por outra banda, aquí, dicimos int x = 5,

529
00:32:10,000 --> 00:32:12,000
e iso está fóra do alcance de calquera función.

530
00:32:12,000 --> 00:32:16,000
É fóra do alcance do principal, polo que esta é unha variable global.

531
00:32:16,000 --> 00:32:20,000
Isto significa que dentro destas dúas funcións, cando digo - x ou x + +

532
00:32:20,000 --> 00:32:26,000
Eu estou accedendo o mesmo x y en que este e este y son variables diferentes.

533
00:32:26,000 --> 00:32:30,000
Esa é a diferenza entre unha variable global e unha variable local.

534
00:32:30,000 --> 00:32:33,000
Tanto como deseño está en causa, ás veces, pode ser unha idea mellor

535
00:32:33,000 --> 00:32:37,000
para manter variables locais sempre que poida

536
00:32:37,000 --> 00:32:39,000
xa que ter un monte de variables globais pode ser moi confuso.

537
00:32:39,000 --> 00:32:42,000
Se tes unha morea de funcións modificando todo a mesma cousa

538
00:32:42,000 --> 00:32:45,000
pode esquecer que esta función accidentalmente modifica este global,

539
00:32:45,000 --> 00:32:47,000
e esta outra función non sabe sobre iso,

540
00:32:47,000 --> 00:32:50,000
e que o fai ser moi confuso como obtén máis de código.

541
00:32:50,000 --> 00:32:53,000
Mantendo variables locais sempre que poida

542
00:32:53,000 --> 00:32:56,000
é proxecto só bo.

543
00:32:56,000 --> 00:33:00,000
Matrices, lembre, son simplemente as listas de elementos do mesmo tipo.

544
00:33:00,000 --> 00:33:04,000
Dentro IC non pode ter unha lista como 1, 2,0, Olá

545
00:33:04,000 --> 00:33:06,000
Nós simplemente non pode facelo.

546
00:33:06,000 --> 00:33:11,000
>> Cando declarar unha matriz en C de todos os elementos teñen que ser do mesmo tipo.

547
00:33:11,000 --> 00:33:14,000
Aquí eu teño un conxunto de 3 números enteiros.

548
00:33:14,000 --> 00:33:18,000
Aquí eu teño a lonxitude da matriz, pero eu estou declarando o nesta sintaxe

549
00:33:18,000 --> 00:33:21,000
onde especifica que todos os elementos están tecnicamente eu non teño deste 3.

550
00:33:21,000 --> 00:33:25,000
O compilador é intelixente o suficiente para descubrir o quão grande a matriz debe ser.

551
00:33:25,000 --> 00:33:28,000
Agora cando desexa ou establecer o valor dunha matriz

552
00:33:28,000 --> 00:33:30,000
Esta é a sintaxe para facelo.

553
00:33:30,000 --> 00:33:33,000
Isto efectivamente modificar o segundo elemento da matriz porque lembrar,

554
00:33:33,000 --> 00:33:36,000
numeración comeza en 0, non en 1.

555
00:33:36,000 --> 00:33:42,000
Se quero ler ese valor podo dicir algo así como int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Ou se eu queira definir ese valor, como eu estou facendo aquí,

557
00:33:44,000 --> 00:33:47,000
Podo dicir array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Ese tempo acceder elementos polo seu índice

559
00:33:50,000 --> 00:33:52,000
ou a súa posición, ou cando eles están na matriz,

560
00:33:52,000 --> 00:33:57,000
e que a lista comeza en 0.

561
00:33:57,000 --> 00:34:00,000
Tamén podemos ter matrices de matrices,

562
00:34:00,000 --> 00:34:03,000
e iso é chamado de matriz multi-dimensional.

563
00:34:03,000 --> 00:34:05,000
Cando temos un array multi-dimensional

564
00:34:05,000 --> 00:34:07,000
Isto significa que podemos ter algo así como liñas e columnas,

565
00:34:07,000 --> 00:34:11,000
e esta é só unha forma de ver iso ou pensar sobre iso.

566
00:34:11,000 --> 00:34:14,000
Cando eu teño un array multi-dimensional que significa que eu vou comezar a ter

567
00:34:14,000 --> 00:34:17,000
máis que un índice, porque se eu tivera unha reixa

568
00:34:17,000 --> 00:34:19,000
só dicindo o que liña está en non nos dá un número.

569
00:34:19,000 --> 00:34:22,000
Isto é realmente só vai dar-nos unha lista de números.

570
00:34:22,000 --> 00:34:25,000
Imos dicir que eu teño esa matriz aquí.

571
00:34:25,000 --> 00:34:30,000
Eu teño unha matriz chamada reixa, e eu estou dicindo que é dúas liñas e tres columnas,

572
00:34:30,000 --> 00:34:32,000
e por iso esta é unha forma de ver isto.

573
00:34:32,000 --> 00:34:37,000
Cando digo que quero comezar o elemento en [1] [2]

574
00:34:37,000 --> 00:34:41,000
Isto significa que, porque estes son liñas e despois columnas

575
00:34:41,000 --> 00:34:44,000
Vou saltar para a liña 1 desde que eu dixen un.

576
00:34:44,000 --> 00:34:49,000
>> Entón eu vou vir aquí para a columna 2, e eu estou indo a obter o valor 6.

577
00:34:49,000 --> 00:34:51,000
Ten sentido?

578
00:34:51,000 --> 00:34:55,000
Arrays multi-dimensional, lembre, son tecnicamente só unha matriz de matrices.

579
00:34:55,000 --> 00:34:57,000
Podemos ter matrices de matrices de matrices.

580
00:34:57,000 --> 00:35:00,000
Podemos seguir, pero realmente unha forma de pensar

581
00:35:00,000 --> 00:35:03,000
como iso está colocado para fóra eo que está a suceder é velo

582
00:35:03,000 --> 00:35:09,000
nunha reixa coma este.

583
00:35:09,000 --> 00:35:12,000
Cando pasar matrices para funcións, eles van comportarse

584
00:35:12,000 --> 00:35:16,000
un pouco diferente do que cando pasar variables para funcións regulares

585
00:35:16,000 --> 00:35:18,000
como pasar un int ou float.

586
00:35:18,000 --> 00:35:21,000
Cando pasamos nun tipo int ou char ou calquera destes outros datos

587
00:35:21,000 --> 00:35:24,000
Nós só deu un ollo a función modifica

588
00:35:24,000 --> 00:35:28,000
o valor da variable que o cambio non vai propagar-se

589
00:35:28,000 --> 00:35:32,000
para a función de chamada.

590
00:35:32,000 --> 00:35:35,000
Cunha matriz, por outra banda, que se celebrará.

591
00:35:35,000 --> 00:35:39,000
Se eu pasar un array para algunha función e que función modifica algúns dos elementos,

592
00:35:39,000 --> 00:35:43,000
cando volverse para a función que a chamou

593
00:35:43,000 --> 00:35:47,000
miña matriz é agora vai ser diferente, e vocabulario para

594
00:35:47,000 --> 00:35:50,000
é arrays son pasados ​​por referencia, como veremos máis adiante.

595
00:35:50,000 --> 00:35:53,000
Isto está relacionado á forma como o traballo punteiros, onde estes tipos de datos básicos,

596
00:35:53,000 --> 00:35:55,000
por outro lado, son pasados ​​por valor.

597
00:35:55,000 --> 00:35:59,000
>> Podemos pensar que, como facer unha copia de algunha variable e despois pasar na copia.

598
00:35:59,000 --> 00:36:01,000
Non importa o que facemos con esa variable.

599
00:36:01,000 --> 00:36:06,000
A función de chamada non vai ser consciente de que el cambiou.

600
00:36:06,000 --> 00:36:10,000
Matrices son só un pouco diferente a este respecto.

601
00:36:10,000 --> 00:36:13,000
Por exemplo, como acabamos de ver, a principal é simplemente unha función

602
00:36:13,000 --> 00:36:15,000
que pode tomar dous argumentos.

603
00:36:15,000 --> 00:36:20,000
O primeiro argumento para a función principal é argc, ou o número de argumentos,

604
00:36:20,000 --> 00:36:23,000
eo segundo argumento é chamado argv,

605
00:36:23,000 --> 00:36:27,000
e eses son os valores reais tales argumentos.

606
00:36:27,000 --> 00:36:30,000
Imos dicir que eu teño un programa chamado this.c,

607
00:36:30,000 --> 00:36:34,000
e eu digo iso, e eu estou indo a executar isto na liña de comandos.

608
00:36:34,000 --> 00:36:38,000
Agora, para pasar uns argumentos para o meu programa chamado iso,

609
00:36:38,000 --> 00:36:42,000
Eu podería dicir algo así como. / Este é cs 50.

610
00:36:42,000 --> 00:36:45,000
Isto é o que nós imaxinamos David a facer todos os días no terminal.

611
00:36:45,000 --> 00:36:48,000
Pero agora, a función principal no interior do referido programa

612
00:36:48,000 --> 00:36:52,000
ten estes valores, así argc e 4.

613
00:36:52,000 --> 00:36:56,000
Pode ser un pouco confuso, porque realmente estamos só pasando é cs 50.

614
00:36:56,000 --> 00:36:58,000
Isto é só 3.

615
00:36:58,000 --> 00:37:02,000
Pero lembre que o primeiro elemento de argv ou o primeiro argumento

616
00:37:02,000 --> 00:37:05,000
é o nome da propia función.

617
00:37:05,000 --> 00:37:07,190
Entón iso significa que temos catro cousas aquí,

618
00:37:07,190 --> 00:37:10,530
eo primeiro elemento é o que vai ser. / iso.

619
00:37:10,530 --> 00:37:12,970
E iso vai ser representado como unha cadea.

620
00:37:12,970 --> 00:37:18,590
A continuación, o resto dos elementos son o que ingresaran despois do nome do programa.

621
00:37:18,590 --> 00:37:22,720
Así como un aparte, coma nós, probablemente, viu en pset 2,

622
00:37:22,720 --> 00:37:28,780
Lembre que a secuencia de 50 a 50 ≠ enteiro.

623
00:37:28,780 --> 00:37:32,520
Polo tanto, non podemos dicir algo así como, "int x = argv 3. '

624
00:37:32,520 --> 00:37:36,470
>> Isto só non vai ter sentido, porque esta é unha cadea, e este é un número enteiro.

625
00:37:36,470 --> 00:37:38,510
Entón, se quere converter entre o 2, lembre, nós imos

626
00:37:38,510 --> 00:37:40,810
teñen esa función máxica chamada atoi.

627
00:37:40,810 --> 00:37:46,270
Que recibe unha cadea e retorna o enteiro representado dentro desa secuencia.

628
00:37:46,270 --> 00:37:48,360
Entón, iso é un erro fácil de facer no quiz,

629
00:37:48,360 --> 00:37:51,590
só de pensar que este será automaticamente o tipo correcto.

630
00:37:51,590 --> 00:37:53,860
Pero só sei que estes serán sempre cordas

631
00:37:53,860 --> 00:38:00,920
mesmo se a cadea contén só un número enteiro ou un personaxe ou unha boia.

632
00:38:00,920 --> 00:38:03,380
Entón, agora imos falar sobre o tempo de execución.

633
00:38:03,380 --> 00:38:06,700
Cando temos todos estes algoritmos que facer todas estas cousas tolas,

634
00:38:06,700 --> 00:38:11,580
torna-se moi útil para a pregunta: "Canto tempo eles levaron?"

635
00:38:11,580 --> 00:38:15,500
Nós representamos que con algo chamado de notación asintótica.

636
00:38:15,500 --> 00:38:18,430
Entón iso significa que - ben, imos dicir que dar o noso algoritmo

637
00:38:18,430 --> 00:38:20,840
algunha entrada moi, moi, moi grande.

638
00:38:20,840 --> 00:38:23,840
Queremos facer a pregunta: "Canto tempo vai levar?

639
00:38:23,840 --> 00:38:26,370
Cantas medidas ha tomar o noso algoritmo para realizar

640
00:38:26,370 --> 00:38:29,980
como unha función do tamaño da entrada? "

641
00:38:29,980 --> 00:38:33,080
Así, a primeira forma que podemos describir o tempo de execución é con gran O.

642
00:38:33,080 --> 00:38:35,380
E este é o noso tempo de execución de peor caso.

643
00:38:35,380 --> 00:38:38,590
Polo tanto, se queremos clasificar un array, e nós damos o noso algoritmo dunha matriz

644
00:38:38,590 --> 00:38:41,000
que está en orde decrescente, cando debería estar en orde ascendente,

645
00:38:41,000 --> 00:38:43,130
que vai ser o peor caso.

646
00:38:43,130 --> 00:38:49,800
Este é o noso límite superior o tempo máximo de noso algoritmo pode tomar.

647
00:38:49,800 --> 00:38:54,740
Por outra banda, este Ω vai describir mellor caso tempo de execución.

648
00:38:54,740 --> 00:38:58,210
Entón, se nós damos unha matriz xa clasificados para un algoritmo de clasificación,

649
00:38:58,210 --> 00:39:00,940
canto tempo vai levar para solucionar isto?

650
00:39:00,940 --> 00:39:06,610
E este, a continuación, describe un límite inferior no tempo de execución.

651
00:39:06,610 --> 00:39:10,980
Entón, aquí son só algunhas palabras que describen algunhas veces comúns en execución.

652
00:39:10,980 --> 00:39:13,120
Estes son, en orde crecente.

653
00:39:13,120 --> 00:39:16,060
O tempo máis rápido en execución que temos é chamado constante.

654
00:39:16,060 --> 00:39:19,800
>> Isto significa que non importa cantos elementos damos o noso algoritmo,

655
00:39:19,800 --> 00:39:22,280
non importa quão grande é a nosa matriz, a selección

656
00:39:22,280 --> 00:39:26,510
ou facendo o que estamos facendo para a matriz sempre terá a mesma cantidade de tempo.

657
00:39:26,510 --> 00:39:30,270
Así, podemos representar que só un 1, o cal é unha constante.

658
00:39:30,270 --> 00:39:32,410
Tamén mirou en tempo de execución logarítmica.

659
00:39:32,410 --> 00:39:34,800
Polo tanto, algo así como procura binaria é logarítmica,

660
00:39:34,800 --> 00:39:37,140
onde imos cortar o problema á metade o tempo

661
00:39:37,140 --> 00:39:40,970
e despois as cousas só quedan máis de alí.

662
00:39:40,970 --> 00:39:43,580
E se está sempre escribindo un o de calquera algoritmo de factorial,

663
00:39:43,580 --> 00:39:47,850
probablemente non debe considerarse este como o seu traballo do día.

664
00:39:47,850 --> 00:39:53,910
Ao comparar tempos de execución é importante manter presente esas cousas.

665
00:39:53,910 --> 00:39:57,760
Entón, se eu teño un algoritmo que é O (n), e alguén

666
00:39:57,760 --> 00:40:03,590
ten un algoritmo de O (2n) estes son realmente assintoticamente equivalente.

667
00:40:03,590 --> 00:40:06,590
Entón, se nós imaxinarmos n para ser un número grande como Eleventy millóns:

668
00:40:06,590 --> 00:40:13,090
Entón, cando estamos comparando Eleventy millóns para algo así como Eleventy millóns + 3,

669
00:40:13,090 --> 00:40:17,640
de súpeto que tres realmente non fai unha gran diferenza máis.

670
00:40:17,640 --> 00:40:20,980
É por iso que nós imos comezar a considerar estas cousas equivalentes.

671
00:40:20,980 --> 00:40:24,220
Entón, cousas como esas constantes aquí, hai 2 x este, ou a adición de 3,

672
00:40:24,220 --> 00:40:27,180
Estes son só constantes, e estes van caer cara arriba.

673
00:40:27,180 --> 00:40:32,480
É por iso que todos os 3 destes tempos de execución son o mesmo que dicir que son O (n).

674
00:40:32,480 --> 00:40:37,490
Do mesmo xeito, se temos dous tempos de execución doutros, digamos O (n ³ + 2n ²), podemos engadir

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, e despois temos outro tempo de execución que é só o (n ³).

676
00:40:42,070 --> 00:40:46,290
De novo, estes son a mesma cousa, porque estes - estes non son os mesmos.

677
00:40:46,290 --> 00:40:49,840
Estas son as mesmas cousas, me desculpe. Entón, eses son os mesmos, porque

678
00:40:49,840 --> 00:40:53,090
este ³ n vai dominar este ² 2n.

679
00:40:53,090 --> 00:40:59,130
>> O que non é o mesmo é ter executado tempos como O (n ³) e O (n ²)

680
00:40:59,130 --> 00:41:02,820
porque este ³ n é moito maior do que isto n ².

681
00:41:02,820 --> 00:41:05,470
Entón, se temos expoñentes, de súpeto, iso comeza coa materia,

682
00:41:05,470 --> 00:41:08,280
pero cando estamos lidando só con factores como estamos aquí,

683
00:41:08,280 --> 00:41:12,810
entón non vai importar, porque eles están indo só para caer fóra.

684
00:41:12,810 --> 00:41:16,760
Imos dar un ollo a algúns dos algoritmos que vimos ata agora

685
00:41:16,760 --> 00:41:19,260
e falar sobre o seu tempo de execución.

686
00:41:19,260 --> 00:41:23,850
A primeira forma de ollar para un número nunha lista, o que vimos, foi busca lineal.

687
00:41:23,850 --> 00:41:26,950
Ea aplicación da busca lineal é super sinxelo.

688
00:41:26,950 --> 00:41:30,490
Nós só temos unha lista, e imos mirar para cada elemento da lista

689
00:41:30,490 --> 00:41:34,260
ata atopar o número que estamos a buscar.

690
00:41:34,260 --> 00:41:38,370
Entón, o que significa que no peor dos casos, este (n).

691
00:41:38,370 --> 00:41:40,860
E o peor caso aquí podería ser o elemento

692
00:41:40,860 --> 00:41:45,710
o último elemento, a continuación, usando busca lineal, debemos ollar para cada elemento

693
00:41:45,710 --> 00:41:50,180
ata chegar ao último, a fin de saber que era realmente na lista.

694
00:41:50,180 --> 00:41:52,910
Non podemos simplemente desistir no medio e dicir: "É, probablemente, non existe."

695
00:41:52,910 --> 00:41:55,980
Coa busca lineal temos que ollar para a cousa toda.

696
00:41:55,980 --> 00:41:59,090
O tempo de traballo mellor caso, por outra banda, é constante

697
00:41:59,090 --> 00:42:04,200
porque, no mellor caso, o elemento que estamos a buscar é só o primeiro da lista.

698
00:42:04,200 --> 00:42:08,930
Por iso, vai levar exactamente o paso 1, non importa quão grande a lista

699
00:42:08,930 --> 00:42:12,140
se nós estamos mirando para o primeiro elemento de cada vez.

700
00:42:12,140 --> 00:42:15,390
>> Entón, cando busca, lembre, non esixe que a nosa lista de ser clasificado.

701
00:42:15,390 --> 00:42:19,430
Porque nós estamos indo simplemente para ollar sobre cada elemento, e iso realmente non importa

702
00:42:19,430 --> 00:42:23,560
que orde os elementos están dentro

703
00:42:23,560 --> 00:42:28,110
Un algoritmo de busca máis intelixente é algo así como investigación binaria.

704
00:42:28,110 --> 00:42:31,500
Lembre, a implementación de busca binaria é cando vai

705
00:42:31,500 --> 00:42:34,320
manter a ollar para o medio da lista.

706
00:42:34,320 --> 00:42:38,000
E porque estamos a ollar para o medio, é necesario que a lista é ordenada

707
00:42:38,000 --> 00:42:40,580
ou ben non sabemos onde o medio é, e temos que mirar por riba

708
00:42:40,580 --> 00:42:44,480
toda a lista de atopalo, e entón en que punto estamos só perdendo tempo.

709
00:42:44,480 --> 00:42:48,480
Entón, se temos unha lista ordenada e atopamos a medio, imos comparar a media

710
00:42:48,480 --> 00:42:51,590
ao elemento que estamos a buscar.

711
00:42:51,590 --> 00:42:54,640
Se é moi alto, entón podemos esquecer a metade dereita

712
00:42:54,640 --> 00:42:57,810
porque sabemos que, se o noso elemento xa é moi alta

713
00:42:57,810 --> 00:43:01,080
e todo a dereita deste elemento é aínda maior,

714
00:43:01,080 --> 00:43:02,760
entón non necesita mirar máis alá.

715
00:43:02,760 --> 00:43:05,430
Onde, por outra banda, o noso elemento é moi baixa,

716
00:43:05,430 --> 00:43:08,700
sabemos todo á esquerda do elemento que é tamén moi baixa,

717
00:43:08,700 --> 00:43:11,390
por iso realmente non fai sentido mirar para alí, tamén.

718
00:43:11,390 --> 00:43:15,760
Desta forma, a cada paso e cada vez que ollar para o punto medio da lista,

719
00:43:15,760 --> 00:43:19,060
imos cortar pola metade o noso problema, porque de súpeto sabemos

720
00:43:19,060 --> 00:43:23,040
unha morea de números que non poden ser o que estamos a buscar.

721
00:43:23,040 --> 00:43:26,950
>> En pseudocódigo este sería algo coma isto,

722
00:43:26,950 --> 00:43:30,990
e porque estamos cortando a lista á metade a cada momento,

723
00:43:30,990 --> 00:43:34,920
nosas peor caso de execución de saltos no tempo lineal para logarítmica.

724
00:43:34,920 --> 00:43:39,260
Entón, de súpeto, temos log-in pasos para atopar un elemento nunha lista.

725
00:43:39,260 --> 00:43:42,460
O tempo de execución de mellor caso, no entanto, aínda é constante

726
00:43:42,460 --> 00:43:45,180
porque agora imos só dicir que o elemento que estamos a buscar é

727
00:43:45,180 --> 00:43:48,380
sempre medio exacto da lista orixinal.

728
00:43:48,380 --> 00:43:52,080
Así, podemos aumentar a nosa lista tan grande como queremos, pero se o elemento que estamos a buscar é no medio,

729
00:43:52,080 --> 00:43:54,910
el só vai levar un paso.

730
00:43:54,910 --> 00:44:00,920
Entón é por iso que estamos O (log n) e Ω (1) ou constante.

731
00:44:00,920 --> 00:44:04,510
Imos executar busca binaria nesta lista.

732
00:44:04,510 --> 00:44:08,020
Entón, imos dicir que nós estamos mirando para o elemento 164.

733
00:44:08,020 --> 00:44:11,650
O primeiro que imos facer é atopar o punto medio desta lista.

734
00:44:11,650 --> 00:44:15,060
O que pasa é que o punto medio vai caer entre estes dous números,

735
00:44:15,060 --> 00:44:18,960
entón imos arbitrariamente dicir, toda vez que o punto medio cae entre dous números,

736
00:44:18,960 --> 00:44:21,150
imos redondear para arriba.

737
00:44:21,150 --> 00:44:24,330
Nós só necesitamos ter seguro de que facemos isto a cada paso do camiño.

738
00:44:24,330 --> 00:44:29,040
Entón, imos redondear para arriba, e nós imos dicir que 161 é o medio de lista.

739
00:44:29,040 --> 00:44:34,640
Entón, 161 <164, e todos os elementos para a esquerda de 161

740
00:44:34,640 --> 00:44:39,120
tamén é <164, entón sabemos que iso non vai axudar en todo

741
00:44:39,120 --> 00:44:42,690
para comezar a ollar para aquí porque o elemento que estamos a buscar non pode estar alí.

742
00:44:42,690 --> 00:44:47,060
Entón o que podemos facer é que podemos esquecer que a metade toda esquerda da lista,

743
00:44:47,060 --> 00:44:51,700
e agora considerar só a partir da dereita da fronte 161.

744
00:44:51,700 --> 00:44:54,050
>> Entón, de novo, este é o punto medio; imos redondear para arriba.

745
00:44:54,050 --> 00:44:56,260
Agora 175 é moi grande.

746
00:44:56,260 --> 00:44:59,180
Entón, nós sabemos que non vai axudar-nos a ollar aquí ou aquí,

747
00:44:59,180 --> 00:45:06,610
así que podemos só xogar iso fóra, e, finalmente, imos acertar o 164.

748
00:45:06,610 --> 00:45:10,560
Calquera dúbida en busca binaria?

749
00:45:10,560 --> 00:45:14,180
Imos pasar de busca mediante unha lista xa clasificada

750
00:45:14,180 --> 00:45:17,660
para realmente tomar unha lista de números en calquera orde

751
00:45:17,660 --> 00:45:20,960
e facer esa lista en orde crecente.

752
00:45:20,960 --> 00:45:24,060
O primeiro algoritmo vimos foi chamado Bubble sort.

753
00:45:24,060 --> 00:45:27,300
E esta sería máis sinxelo dos algoritmos que vimos.

754
00:45:27,300 --> 00:45:32,970
Especie de burbulla, di que cando os dous elementos dentro da lista están fóra do lugar,

755
00:45:32,970 --> 00:45:36,500
ou sexa, hai un maior número á esquerda dun número máis baixo,

756
00:45:36,500 --> 00:45:40,190
entón nós estamos indo a troca-los, porque iso significa que a lista será

757
00:45:40,190 --> 00:45:42,860
"Máis ordenada" do que era antes.

758
00:45:42,860 --> 00:45:45,180
E nós só estamos indo para continuar este proceso de novo e de novo e de novo

759
00:45:45,180 --> 00:45:52,100
ata que finalmente o tipo elementos de burbulla para o seu ubicación correcta e temos unha lista clasificada.

760
00:45:52,100 --> 00:45:57,230
>> O tempo de execución deste será o (n ²). Por que?

761
00:45:57,230 --> 00:46:00,370
Ben, porque no peor dos casos, imos tomar todos os elementos, e

762
00:46:00,370 --> 00:46:04,570
imos acabar comparando-a con todos os outros elementos da lista.

763
00:46:04,570 --> 00:46:08,030
Pero, no mellor dos casos, temos unha lista xa clasificados, tipo de burbulla

764
00:46:08,030 --> 00:46:12,230
só vai pasar por unha vez, dicir "Nope. non facer calquera cambio, así que eu son feito."

765
00:46:12,230 --> 00:46:17,410
Entón, nós temos un tempo mellor caso de execución de Ω (n).

766
00:46:17,410 --> 00:46:20,680
Imos correr especie de burbulla nunha lista.

767
00:46:20,680 --> 00:46:23,560
Ou primeiro, imos ollar para algúns pseudocódigo moi rapidamente.

768
00:46:23,560 --> 00:46:28,160
Queremos dicir que queremos seguir, en cada iteração do loop,

769
00:46:28,160 --> 00:46:32,190
manter o control da existencia ou non cambiamos todos os elementos.

770
00:46:32,190 --> 00:46:37,610
Así, a razón para iso é que nós imos parar cando non trocaron todos os elementos.

771
00:46:37,610 --> 00:46:41,980
Entón, a comezos do noso lazo non trocar nada, entón imos dicir que é falso.

772
00:46:41,980 --> 00:46:47,170
Agora, imos percorrer a lista e comparar elemento i ó elemento i + 1

773
00:46:47,170 --> 00:46:50,310
e se é o caso en que existe un maior número á esquerda dun número menor,

774
00:46:50,310 --> 00:46:52,310
entón nós estamos indo só para trocalos.

775
00:46:52,310 --> 00:46:54,490
>> E entón, imos lembrar que trocamos un elemento.

776
00:46:54,490 --> 00:46:58,900
Isto significa que temos que percorrer a lista polo menos unha vez máis

777
00:46:58,900 --> 00:47:02,160
porque a condición en que se detivo é cando toda a lista é xa clasificados,

778
00:47:02,160 --> 00:47:04,890
o que significa que non teña feito calquera cambio.

779
00:47:04,890 --> 00:47:09,960
É por iso que a nosa condición aquí é "mentres algúns elementos foron trocados."

780
00:47:09,960 --> 00:47:13,720
Entón, agora imos ollar para esta rodando nunha lista.

781
00:47:13,720 --> 00:47:16,640
Eu teño unha lista 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Especie de burbulla vai comezar todo o camiño á esquerda, e vai para comparar

783
00:47:19,850 --> 00:47:24,700
os elementos i, de xeito 0 a i + 1, que é o elemento 1.

784
00:47:24,700 --> 00:47:29,020
Vai dicir, ben 5> 0, pero agora 5 é a esquerda,

785
00:47:29,020 --> 00:47:32,500
entón eu teño cambiar o 5 eo 0.

786
00:47:32,500 --> 00:47:35,470
Cando troca-los, de súpeto, eu recibín esta lista diferente.

787
00:47:35,470 --> 00:47:38,260
Agora 5> 1, entón nós estamos indo a trocalos.

788
00:47:38,260 --> 00:47:42,160
5 non é> 6, polo tanto, non precisa facer nada aquí.

789
00:47:42,160 --> 00:47:46,690
Pero 6> 4, polo que necesitamos cambiar.

790
00:47:46,690 --> 00:47:49,740
Unha vez máis, temos que percorrer toda a lista para, finalmente, descubrir

791
00:47:49,740 --> 00:47:52,330
que estes están fóra de orde, nós troca-los,

792
00:47:52,330 --> 00:47:57,120
e neste momento temos que percorrer a lista unha vez máis

793
00:47:57,120 --> 00:48:05,390
para asegurarse de que todo está no seu fin, e neste tipo de burbulla punto de rematar.

794
00:48:05,390 --> 00:48:10,720
Un algoritmo diferente para a toma de algúns elementos e clasificalos los é unha especie de selección.

795
00:48:10,720 --> 00:48:15,740
A idea detrás tipo de selección é que nós imos construír unha parte clasificada na lista

796
00:48:15,740 --> 00:48:18,150
Un elemento de cada vez.

797
00:48:18,150 --> 00:48:23,170
>> E a forma como imos facelo é a través da construción de segmento esquerdo da lista.

798
00:48:23,170 --> 00:48:27,510
E, basicamente, cada - en cada etapa, imos levar o menor elemento que nos queda

799
00:48:27,510 --> 00:48:32,310
que non sexa resolto aínda, e nós estamos indo a mover para o segmento clasificado.

800
00:48:32,310 --> 00:48:35,850
Isto significa que necesitamos continuamente atopar o elemento mínimo indiferenciados

801
00:48:35,850 --> 00:48:40,720
e levar ese elemento mínimo e troca-lo co que

802
00:48:40,720 --> 00:48:45,090
máis á esquerda elemento que non está clasificada.

803
00:48:45,090 --> 00:48:50,890
O tempo de execución deste será o (n ²), porque no peor caso

804
00:48:50,890 --> 00:48:55,070
necesitamos comparar cada elemento de calquera outro elemento.

805
00:48:55,070 --> 00:48:59,250
Porque nós estamos dicindo que, se comezar na metade esquerda da lista, cómpre

806
00:48:59,250 --> 00:49:02,970
que pasar por todo o segmento da dereita para atopar o menor elemento.

807
00:49:02,970 --> 00:49:05,430
E entón, unha vez máis, temos que pasar por riba de todo o segmento dereito e

808
00:49:05,430 --> 00:49:08,210
continuar máis que unha e outra e outra vez.

809
00:49:08,210 --> 00:49:11,350
Isto vai ser ² n. Nós imos ter que un circuíto para dentro doutro loop

810
00:49:11,350 --> 00:49:13,350
o que suxire ² n.

811
00:49:13,350 --> 00:49:16,530
No pensamento mellor caso, imos dicir que darlle unha lista xa clasificados;

812
00:49:16,530 --> 00:49:19,270
Nós realmente non facer mellor que ² n.

813
00:49:19,270 --> 00:49:21,730
Porque tipo de selección non ten forma de saber que

814
00:49:21,730 --> 00:49:25,540
o elemento mínimo é só a ocorrer de eu estar mirando.

815
00:49:25,540 --> 00:49:28,970
El aínda precisa estar seguro de que este é realmente o mínimo.

816
00:49:28,970 --> 00:49:31,670
>> E a única forma de ter seguro de que é o mínimo, usando ese algoritmo,

817
00:49:31,670 --> 00:49:34,640
é mirar para cada elemento novo.

818
00:49:34,640 --> 00:49:38,420
Entón, realmente, se der a el - se der tipo de selección dunha lista xa clasificados,

819
00:49:38,420 --> 00:49:42,720
el non vai facer nada mellor que darlle unha lista que non é clasificado aínda.

820
00:49:42,720 --> 00:49:46,320
By the way, se ocorrer de ser o caso de que algo é O (algo)

821
00:49:46,320 --> 00:49:50,640
eo omega de algo, podemos dicir de forma máis sucinta que é θ de algo.

822
00:49:50,640 --> 00:49:52,760
Entón, se ves que chegar en calquera lugar, iso é o que significa só.

823
00:49:52,760 --> 00:49:57,580
>> Se algo é theta de n ², é tanto grande (n ²) e Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Entón, o mellor caso e peor caso, non fai diferenzas,

825
00:49:59,790 --> 00:50:04,400
o algoritmo vai facer a mesma cousa todo o tempo.

826
00:50:04,400 --> 00:50:06,610
Entón é iso que pseudocódigo para tipo de selección pode parecer.

827
00:50:06,610 --> 00:50:10,630
Estamos basicamente vai dicir que quero iterar sobre a lista

828
00:50:10,630 --> 00:50:15,180
de esquerda a dereita, e en cada iteração do loop, eu estou indo a mover

829
00:50:15,180 --> 00:50:19,780
o elemento mínimo para esta porción da lista ordenada.

830
00:50:19,780 --> 00:50:23,260
E unha vez que eu paso algo alí, eu nunca precisa ollar para este elemento novo.

831
00:50:23,260 --> 00:50:28,600
Porque así que eu cambiar un elemento para o segmento esquerdo da lista, está clasificada

832
00:50:28,600 --> 00:50:32,600
porque estamos facendo todo en orde crecente, usando mínimos.

833
00:50:32,600 --> 00:50:38,740
Entón nós dixemos, todo ben, estamos en posición i, e necesitamos de ollar para todos os elementos

834
00:50:38,740 --> 00:50:42,260
á dereita de i, a fin de atopar o mínimo.

835
00:50:42,260 --> 00:50:46,150
Así, isto significa que quere ollar de i + 1 para o fin da lista.

836
00:50:46,150 --> 00:50:51,610
E agora, o elemento que nós estamos a buscar é a menos que o noso mínimo ata agora,

837
00:50:51,610 --> 00:50:54,190
que, lembre, estamos empezando a fóra mínimo a ser só

838
00:50:54,190 --> 00:50:57,020
calquera elemento que estamos actualmente, eu vou asumir que é o mínimo.

839
00:50:57,020 --> 00:51:00,270
Se eu atopar un elemento que é menor do que iso, entón eu vou dicir, ok,

840
00:51:00,270 --> 00:51:02,700
ben, eu atope un novo mínimo.

841
00:51:02,700 --> 00:51:06,080
Vou lembrar de onde ese mínimo era.

842
00:51:06,080 --> 00:51:09,560
>> Entón, agora, despois de xa ter pasado por ese segmento dereito indiferenciados,

843
00:51:09,560 --> 00:51:16,690
Eu podo dicir que eu vou cambiar o elemento mínimo co elemento que está na posición i.

844
00:51:16,690 --> 00:51:21,100
Que vai construír a miña lista, miña porción clasificada na lista da esquerda para a dereita,

845
00:51:21,100 --> 00:51:25,190
e non precisa ollar para un elemento novo, xa que é nesa porción.

846
00:51:25,190 --> 00:51:27,930
Unha vez que teñamos trocado el.

847
00:51:27,930 --> 00:51:30,260
Entón, imos realizar tipo de selección na lista.

848
00:51:30,260 --> 00:51:38,220
O elemento de azul aquí vai ser a i, é o elemento vermello vai ser o elemento mínimo.

849
00:51:38,220 --> 00:51:41,570
Entón eu comeza todo o camiño á esquerda da lista, para 5.

850
00:51:41,570 --> 00:51:44,610
Agora necesitamos atopar o elemento mínimo indiferenciados.

851
00:51:44,610 --> 00:51:49,480
Así, dicimos 0 <5, entón 0 é o meu novo mínimo.

852
00:51:49,480 --> 00:51:53,820
>> Pero eu non podo deixar por aí, porque, aínda que poidamos recoñecer que 0 é menor,

853
00:51:53,820 --> 00:51:59,390
que necesitamos para realizar a través de todos os outros elementos da lista para estar seguro.

854
00:51:59,390 --> 00:52:01,760
Entón, un é grande, 6 é maior, 4 é maior.

855
00:52:01,760 --> 00:52:05,850
Isto significa que, despois de ollar para todos estes elementos, xa determinou 0 é o menor.

856
00:52:05,850 --> 00:52:09,800
Entón, eu vou cambiar o 5 eo 0.

857
00:52:09,800 --> 00:52:15,480
Unha vez eu cambiar iso, eu estou indo a obter unha nova lista, e eu sei que eu nunca precisa ollar para iso 0 novo

858
00:52:15,480 --> 00:52:19,380
porque unha vez eu cambie, eu clasificados por el e estamos a facer.

859
00:52:19,380 --> 00:52:22,730
Agora resulta que o elemento azul é novo 5,

860
00:52:22,730 --> 00:52:26,030
e que ten que ollar para o 1, a 6 e 4 para determinar que un

861
00:52:26,030 --> 00:52:31,520
é o menor elemento mínimo, entón imos cambiar o 1 eo 5.

862
00:52:31,520 --> 00:52:36,890
Unha vez máis, temos que mirar - comparar a 5 a 6 e 4,

863
00:52:36,890 --> 00:52:39,830
e imos cambiar o 4 eo 5, e, finalmente, comparar

864
00:52:39,830 --> 00:52:45,740
os números 2 e trocalos ata chegar a nosa lista de clasificados.

865
00:52:45,740 --> 00:52:49,730
Calquera dúbida sobre tipo de selección?

866
00:52:49,730 --> 00:52:56,420
Okay. Imos pasar ao último tema aquí, e que é a recursividade.

867
00:52:56,420 --> 00:52:59,810
>> Recursão, lembre, é esa cousa meta realmente onde unha función

868
00:52:59,810 --> 00:53:02,740
repetidamente chama a si mesmo.

869
00:53:02,740 --> 00:53:05,620
Entón, en algún punto, mentres que a nosa fuction é repetidamente chamado-se,

870
00:53:05,620 --> 00:53:10,100
é preciso haber algún punto no que paramos de chamar.

871
00:53:10,100 --> 00:53:13,670
Porque se nós non facemos iso, entón imos só continuar a facelo para sempre

872
00:53:13,670 --> 00:53:16,660
eo noso programa é só non vai rematar.

873
00:53:16,660 --> 00:53:19,200
Chamamos esta condición no caso base.

874
00:53:19,200 --> 00:53:22,570
É o caso base di, en vez de chamar a unha función de novo,

875
00:53:22,570 --> 00:53:25,330
Eu só vou volver algún valor.

876
00:53:25,330 --> 00:53:28,080
Polo tanto, unha vez que xa retornou un valor, nós paramos de chamar,

877
00:53:28,080 --> 00:53:32,550
eo resto das invitacións que fixemos ata agora tamén pode retornar.

878
00:53:32,550 --> 00:53:36,050
O oposto do caso base é o caso recursivo.

879
00:53:36,050 --> 00:53:39,050
E isto é cando queremos facer unha outra chamada para a función que estamos actualmente dentro

880
00:53:39,050 --> 00:53:44,690
E probablemente, aínda que non sempre, quere usar argumentos diferentes.

881
00:53:44,690 --> 00:53:48,940
>> Entón, se temos unha función chamada f, ef chamado só de tomar un argumento,

882
00:53:48,940 --> 00:53:52,010
e nós seguimos chamando f (1), f (1), f (1), e iso só acontece que

883
00:53:52,010 --> 00:53:56,510
o argumento cae nun caso recursivo, estamos aínda non vai parar.

884
00:53:56,510 --> 00:54:01,620
Mesmo se temos un caso base, necesitamos ter seguro de que, finalmente, imos bater ese caso base.

885
00:54:01,620 --> 00:54:04,250
Non só manter permanecer neste caso recursivo.

886
00:54:04,250 --> 00:54:09,870
Xeralmente, cando chamamos a nós mesmos, probablemente imos ter un argumento diferente cada vez.

887
00:54:09,870 --> 00:54:12,700
Aquí é unha función moi simple recursiva.

888
00:54:12,700 --> 00:54:15,090
Entón, iso vai calcular o factorial dun número.

889
00:54:15,090 --> 00:54:17,790
Alí enriba, aquí temos o noso caso base.

890
00:54:17,790 --> 00:54:22,330
No caso de que n ≤ 1, nós non imos chamar factorial de novo.

891
00:54:22,330 --> 00:54:26,490
Nós imos parar, estamos só indo para voltar un valor.

892
00:54:26,490 --> 00:54:30,170
Se iso non é verdade, entón nós estamos indo para acertar noso caso recursivo.

893
00:54:30,170 --> 00:54:33,550
Nótese aquí que non estamos só chamando factorial (n), porque iso non sería moi útil.

894
00:54:33,550 --> 00:54:36,810
Nós imos chamar factorial de outra cousa.

895
00:54:36,810 --> 00:54:40,850
>> E así podes ver, finalmente, pasar un algo factorial (5) ou,

896
00:54:40,850 --> 00:54:45,900
imos chamar factorial (4) e así por diante, e, finalmente, imos bater este escenario de base.

897
00:54:45,900 --> 00:54:51,730
Polo tanto, este parece ser bo. Imos ver o que acontece cando nós realmente executar este.

898
00:54:51,730 --> 00:54:57,840
Esta é a pila, e imos dicir que principal vai chamar esta función cun argumento (4).

899
00:54:57,840 --> 00:55:02,200
Polo tanto, unha vez factorial ve e = 4, factorial irá identificar.

900
00:55:02,200 --> 00:55:05,010
Agora, de súpeto, temos factorial (3).

901
00:55:05,010 --> 00:55:10,780
Entón, estas funcións van continuar crecendo ata finalmente chegar noso caso base.

902
00:55:10,780 --> 00:55:17,830
Neste punto, o valor de retorno é o retorno (NX o valor de retorno deste),

903
00:55:17,830 --> 00:55:21,290
o valor de retorno é NX valor o retorno deste.

904
00:55:21,290 --> 00:55:23,290
Finalmente cómpre acertar algún número.

905
00:55:23,290 --> 00:55:26,560
Arriba aquí, dicimos retorno 1.

906
00:55:26,560 --> 00:55:30,650
Isto significa que unha vez que volver ese número, podemos pop esta na pila.

907
00:55:30,650 --> 00:55:36,570
Polo tanto, este factorial (1) está feito.

908
00:55:36,570 --> 00:55:41,190
Cando un regresa, ese factoriais (1) retorna, ese retorno a 1.

909
00:55:41,190 --> 00:55:46,910
O valor de retorno a iso, lembre, foi NX o valor de retorno deste.

910
00:55:46,910 --> 00:55:50,720
Entón, de súpeto, esa cara sabe que eu quero volver 2.

911
00:55:50,720 --> 00:55:55,910
>> Entón lembre, voltar o valor desta é só NX o valor de retorno aquí.

912
00:55:55,910 --> 00:56:01,160
Entón agora podemos dicir 3 x 2, e, finalmente, aquí podemos dicir

913
00:56:01,160 --> 00:56:04,010
iso é só vai ser 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
E unha vez que retorna, nós descender a un único enteiro dentro da principal.

915
00:56:09,570 --> 00:56:15,460
Calquera dúbida sobre recursão?

916
00:56:15,460 --> 00:56:17,090
Todo ben. Polo tanto, non hai máis tempo para preguntas, ao final,

917
00:56:17,090 --> 00:56:23,360
pero agora Joseph cubrirá os temas restantes.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Todo ben. Polo tanto, agora que xa falamos sobre recursões,

919
00:56:25,590 --> 00:56:27,840
imos falar un pouco sobre o que é merge sort.

920
00:56:27,840 --> 00:56:31,740
Merge sort é basicamente unha outra forma de ordenar unha lista de números.

921
00:56:31,740 --> 00:56:36,430
E como funciona é, con merge sort tes unha lista, eo que facemos é

922
00:56:36,430 --> 00:56:39,120
dicimos, imos dividir iso en dúas metades.

923
00:56:39,120 --> 00:56:42,750
Imos primeiro executar merge sort novo na metade esquerda,

924
00:56:42,750 --> 00:56:45,040
Entón imos correr merge sort na metade dereita,

925
00:56:45,040 --> 00:56:50,240
e que nos dá agora dúas metades que son clasificados, e agora imos combinar esas metades xuntas.

926
00:56:50,240 --> 00:56:55,010
É un pouco difícil de ver sen un exemplo, así que imos percorrer as propostas e ver o que acontece.

927
00:56:55,010 --> 00:56:59,590
Entón comeza con esta lista, que dividídelo en dúas metades.

928
00:56:59,590 --> 00:57:02,300
Corremos merge sort na metade esquerda primeiro.

929
00:57:02,300 --> 00:57:06,660
Entón esta é a metade esquerda, e agora executa-los a través desta lista de novo

930
00:57:06,660 --> 00:57:09,800
que é pasado para merge sort, e entón miramos, máis unha vez,

931
00:57:09,800 --> 00:57:13,270
na parte esquerda da lista e corremos merge sort sobre el.

932
00:57:13,270 --> 00:57:15,880
Agora, temos unha lista de números 2,

933
00:57:15,880 --> 00:57:19,010
e agora a metade esquerda é só un elemento de lonxitude, e non podemos

934
00:57:19,010 --> 00:57:23,380
dividir unha lista que non é máis que un elemento no medio, de xeito que acabamos de dicir, unha vez que temos 50,

935
00:57:23,380 --> 00:57:26,400
que é só un elemento, xa está clasificado.

936
00:57:26,400 --> 00:57:29,860
>> Unha vez que estamos a facer que, podemos ver que podemos

937
00:57:29,860 --> 00:57:32,230
pasar a metade dereita da lista,

938
00:57:32,230 --> 00:57:36,480
e 3 tamén é clasificado, e agora que as dúas metades desta lista son clasificados

939
00:57:36,480 --> 00:57:39,080
podemos xuntar eses números xuntos de novo.

940
00:57:39,080 --> 00:57:45,320
Así, analizamos 50 e 3, 3 e menor que 50, de xeito que vai en primeiro lugar e, a continuación, 50 vén dentro

941
00:57:45,320 --> 00:57:49,340
Agora, iso está feito, nós volver a esa lista e tipo é media dereita.

942
00:57:49,340 --> 00:57:52,440
42 é o número propio, polo que xa está clasificada.

943
00:57:52,440 --> 00:57:57,850
Entón agora nós comparar estes 2 e 3 é menor que 42, de xeito que é posto en primeiro lugar,

944
00:57:57,850 --> 00:58:02,340
agora con 42 anos e colocar, e 50 e colocar dentro

945
00:58:02,340 --> 00:58:07,220
Agora, que está clasificado, que percorrer todo o camiño de volta ao principio, 1337 e 15.

946
00:58:07,220 --> 00:58:14,560
Ben, nós agora ollar para a metade esquerda da lista; 1337 é, por si só por iso é clasificado e mesmo con 15.

947
00:58:14,560 --> 00:58:19,020
Entón agora nós combinar eses dous números para ordenar que a lista orixinal, 15 <1,337,

948
00:58:19,020 --> 00:58:23,060
así vai en primeiro lugar, entón 1337 vai dentro

949
00:58:23,060 --> 00:58:26,640
E agora nós clasificamos as dúas metades da lista orixinal encima.

950
00:58:26,640 --> 00:58:30,440
E todo o que temos que facer é combinar estes.

951
00:58:30,440 --> 00:58:36,890
Nós miramos para os 2 primeiros números desta lista, 3 <15, entón vai para a matriz de clasificación en primeiro lugar.

952
00:58:36,890 --> 00:58:44,460
15 <42, así que vai dentro Agora, 42 <1337, que vai dentro

953
00:58:44,460 --> 00:58:51,010
50 <1,337, de xeito que vai dentro e entender que só tivo dous números fóra desta lista.

954
00:58:51,010 --> 00:58:53,640
Polo tanto, non estamos só alternando entre as dúas listas.

955
00:58:53,640 --> 00:58:56,050
Estamos só mirando para o inicio, e nós estamos levando o elemento

956
00:58:56,050 --> 00:59:00,270
que é menor e, a continuación, colocar-lo na nosa matriz.

957
00:59:00,270 --> 00:59:04,080
Agora mesclou todas as metades e estamos a facer.

958
00:59:04,080 --> 00:59:07,780
>> Calquera dúbida sobre merge sort? Si?

959
00:59:07,780 --> 00:59:14,190
[Estudante] Se dividir en grupos distintos, por que non só división lo unha vez

960
00:59:14,190 --> 00:59:19,970
e ten 3 e 2 en un grupo? [Resto do inintelixíbel cuestión]

961
00:59:19,970 --> 00:59:24,940
A razón - entón a pregunta é, por que non podemos simplemente xuntalas en que o primeiro paso despois de telos?

962
00:59:24,940 --> 00:59:29,530
A razón que podemos facelo, inicie os elementos máis á esquerda de ambos os dous lados,

963
00:59:29,530 --> 00:59:33,040
e despois tome a menor e poñelas, é que sabemos que eses

964
00:59:33,040 --> 00:59:35,290
listas individuais están en ordes clasificados.

965
00:59:35,290 --> 00:59:37,290
Entón, se eu estou ollando para os elementos máis á esquerda de ambas as metades,

966
00:59:37,290 --> 00:59:40,490
Sei que eles van ser os pequenos elementos desas listas.

967
00:59:40,490 --> 00:59:43,930
Para que eu poida poñer-los en puntos menor elemento desta lista grande.

968
00:59:43,930 --> 00:59:47,810
Por outra banda, se eu ollar para as dúas listas no segundo nivel por alí,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 e 15, os que non están clasificados.

970
00:59:51,640 --> 00:59:55,770
Entón, se eu ollar para 50 e 1337, eu vou poñer 50 na miña primeira lista.

971
00:59:55,770 --> 01:00:00,130
Pero iso non fai moito sentido, porque 3 é o menor elemento de todos aqueles.

972
01:00:00,130 --> 01:00:04,390
Entón, a única razón que podemos facer este paso combinando é porque nosas listas xa están clasificados.

973
01:00:04,390 --> 01:00:07,010
É por iso que temos que comezar todo o camiño ata o fondo

974
01:00:07,010 --> 01:00:09,800
porque cando temos só un único número, vostede sabe que un único número

975
01:00:09,800 --> 01:00:14,120
en si xa é unha lista ordenada.

976
01:00:14,120 --> 01:00:19,360
>> Algunha pregunta? Non?

977
01:00:19,360 --> 01:00:24,260
Complexidade? Ben, pode ver que en cada etapa hai números finais,

978
01:00:24,260 --> 01:00:27,590
e podemos dividir unha lista en media log n veces,

979
01:00:27,590 --> 01:00:31,700
que é onde nós comezamos este rexistro n x n complexidade.

980
01:00:31,700 --> 01:00:34,940
E vai ver o mellor caso para merge sort é n log n, e iso só acontece

981
01:00:34,940 --> 01:00:39,340
que o peor caso, ou o Ω alí, tamén é n log n.

982
01:00:39,340 --> 01:00:42,480
Algo para manter presente.

983
01:00:42,480 --> 01:00:45,750
Seguindo adiante, imos ir a algún arquivo de super básica I / O.

984
01:00:45,750 --> 01:00:48,830
Se mirou para Scramble, vai notar que tivemos algún tipo de sistema

985
01:00:48,830 --> 01:00:51,270
onde podes gravar nun ficheiro de rexistro, se ler o código.

986
01:00:51,270 --> 01:00:53,730
Imos ver como pode facelo.

987
01:00:53,730 --> 01:00:57,450
Ben, temos fprintf, que pode pensar en como só printf,

988
01:00:57,450 --> 01:01:01,720
pero só a impresión a un ficheiro en vez diso, e, polo tanto, o F no inicio.

989
01:01:01,720 --> 01:01:07,570
Este tipo de código ata aquí, o que fai é, como ten que ter visto en Scramble,

990
01:01:07,570 --> 01:01:12,310
pasa pola súa impresión matriz de 2 dimensións fóra de liña en liña cales son os números.

991
01:01:12,310 --> 01:01:17,850
Neste caso, printf imprime ao seu terminal ou o que chamamos a saída estándar de sección.

992
01:01:17,850 --> 01:01:22,170
>> E agora, neste caso, todo o que temos que facer é substituír printf con fprintf,

993
01:01:22,170 --> 01:01:26,770
dicir o que arquivo que quere imprimir, e, neste caso, só imprime-lo para o arquivo

994
01:01:26,770 --> 01:01:32,230
en vez de mostrala ao seu terminal.

995
01:01:32,230 --> 01:01:36,500
Ben, entón, que levanta a cuestión: Onde é que imos conseguir este tipo de ficheiro, non?

996
01:01:36,500 --> 01:01:39,840
Pasamos sesión nese fuction fprintf pero non tiñamos idea de onde veu.

997
01:01:39,840 --> 01:01:43,980
Ben, ao principio do código, o que houbo foi este anaco de código aquí,

998
01:01:43,980 --> 01:01:48,340
que basicamente di que o ficheiro aberto chama log.txt.

999
01:01:48,340 --> 01:01:53,220
¿Que facer despois diso é que temos que estar seguro de que o arquivo está realmente aberto con éxito.

1000
01:01:53,220 --> 01:01:57,070
Por iso, pode fallar por varias razóns, non ten espazo suficiente no seu ordenador, por exemplo.

1001
01:01:57,070 --> 01:01:59,790
Por iso é sempre importante antes de facer calquera operación co ficheiro

1002
01:01:59,790 --> 01:02:03,300
que comprobar que o arquivo foi aberto con éxito.

1003
01:02:03,300 --> 01:02:09,330
Entón, o que que un, iso é un argumento para fopen, así, podemos abrir un arquivo de moitas maneiras.

1004
01:02:09,330 --> 01:02:13,510
O que podemos facer é, podemos pasalo w, o que significa substituír o ficheiro, se saír xa,

1005
01:02:13,510 --> 01:02:18,070
Podemos pasar dun a que engada ao final do ficheiro, no canto de ignore-los,

1006
01:02:18,070 --> 01:02:22,730
ou podemos especificar r, o que significa, imos abrir o ficheiro como só lectura.

1007
01:02:22,730 --> 01:02:24,890
Entón, se o programa tenta facer os cambios para o arquivo,

1008
01:02:24,890 --> 01:02:30,140
berrar con eles e non deixalos facer.

1009
01:02:30,140 --> 01:02:33,320
Finalmente, unha vez que está feito co arquivo, fixeron que fai operacións sobre ela,

1010
01:02:33,320 --> 01:02:35,860
necesitamos ter seguro de que peche o ficheiro.

1011
01:02:35,860 --> 01:02:38,830
E así, ao final do seu programa, que vai paso-los de novo

1012
01:02:38,830 --> 01:02:42,120
este ficheiro que abriu, e só o peche.

1013
01:02:42,120 --> 01:02:44,650
Entón iso é algo importante que ten que estar seguro que fai.

1014
01:02:44,650 --> 01:02:47,180
Entón lembre que pode abrir un arquivo, entón podes escribir o ficheiro,

1015
01:02:47,180 --> 01:02:51,270
facer operacións no arquivo, pero entón tes que pechar o ficheiro no final.

1016
01:02:51,270 --> 01:02:53,270
>> Calquera dúbida sobre arquivo básico I / O? Si?

1017
01:02:53,270 --> 01:02:58,050
[Pregunta do estudante, inintelixible]

1018
01:02:58,050 --> 01:03:02,480
Aquí. A cuestión é: onde é que este arquivo log.txt aparecer?

1019
01:03:02,480 --> 01:03:07,890
Ben, se só darlle log.txt, crea-lo no mesmo directorio que o executábel.

1020
01:03:07,890 --> 01:03:10,500
Entón, se está - >> [pregunta Estudante, inintelixible]

1021
01:03:10,500 --> 01:03:18,830
Si Na mesma carpeta, ou no mesmo directorio, como lle chaman.

1022
01:03:18,830 --> 01:03:21,400
Agora memoria, pila, pila e.

1023
01:03:21,400 --> 01:03:23,400
Entón, como é a memoria definidos no ordenador?

1024
01:03:23,400 --> 01:03:26,270
Ben, pode imaxinar a memoria como unha especie de este bloque aquí.

1025
01:03:26,270 --> 01:03:30,260
E na memoria, temos o que se chama de pila preso alí, ea pila que está alí embaixo.

1026
01:03:30,260 --> 01:03:34,480
E a pila crece cara abaixo e a pila crece cara arriba.

1027
01:03:34,480 --> 01:03:38,620
Así como Tommy mencionado - Oh, ben, e nós temos eses outros catro segmentos que eu vou chegar a un segundo -

1028
01:03:38,620 --> 01:03:42,890
Como Tommy dixo anteriormente, vostede sabe como se chaman as súas funcións e chamar uns ós outros?

1029
01:03:42,890 --> 01:03:44,930
Constrúense este tipo de cadro de pila.

1030
01:03:44,930 --> 01:03:47,360
Ben, as chamadas principais foo, foo colócase na pila.

1031
01:03:47,360 --> 01:03:52,430
Foo chama bar, bar de conseguir poñer na pila, e que é colocado na pila despois.

1032
01:03:52,430 --> 01:03:57,040
E como eles retornan, cada un retirado da pila.

1033
01:03:57,040 --> 01:04:00,140
O que cada un destes lugares e memoria soster?

1034
01:04:00,140 --> 01:04:03,110
Pois ben, a parte superior, que é o segmento de texto, contén o propio programa.

1035
01:04:03,110 --> 01:04:06,390
Así, o código de máquina, que está aí, unha vez que compilar o seu programa.

1036
01:04:06,390 --> 01:04:08,520
A continuación, calquera inicializar variables globais.

1037
01:04:08,520 --> 01:04:12,660
>> Entón tes variables globais no seu programa, e di así, a = 5,

1038
01:04:12,660 --> 01:04:15,260
que é colocado no segmento, e debaixo que,

1039
01:04:15,260 --> 01:04:18,990
ten os datos non inicializados global, que é só un int,

1040
01:04:18,990 --> 01:04:20,990
pero non dicir que é igual a nada.

1041
01:04:20,990 --> 01:04:23,870
Entender estes son variables globais, por iso eles están fóra de inicio.

1042
01:04:23,870 --> 01:04:28,560
Entón iso significa que todas as variables globais que son declarados, pero non son inicializados.

1043
01:04:28,560 --> 01:04:32,310
Entón, o que está no monte? Memoria alocada usando malloc, que nós imos chegar a algo.

1044
01:04:32,310 --> 01:04:35,990
E, finalmente, a pila que ten todas as variables locais

1045
01:04:35,990 --> 01:04:39,950
e todas as funcións que se pode chamar de calquera dos seus parámetros.

1046
01:04:39,950 --> 01:04:43,720
A última cousa, realmente non ten que saber que as variables de ambiente facer,

1047
01:04:43,720 --> 01:04:46,700
pero sempre que executar o programa, non é algo asociado, como

1048
01:04:46,700 --> 01:04:49,550
Este é o nome de usuario da persoa que executou o programa.

1049
01:04:49,550 --> 01:04:51,550
E iso vai ser unha especie de na parte inferior.

1050
01:04:51,550 --> 01:04:54,540
En termos de enderezos de memoria, que son valores hexadecimais,

1051
01:04:54,540 --> 01:04:58,170
os valores no inicio arriba a 0, e van ata o fin para o fondo.

1052
01:04:58,170 --> 01:05:00,440
Neste caso, se está no sistema de 32 bits,

1053
01:05:00,440 --> 01:05:05,390
o enderezo na parte inferior vai ser 0x, seguido por af, porque é 32 bits,

1054
01:05:05,390 --> 01:05:10,890
que é de 8 bytes, e neste caso corresponde a 8 bytes de 8 díxitos hexadecimais.

1055
01:05:10,890 --> 01:05:20,110
Entón aquí vai ter, como 0xffffff, e ata alí vai ter 0.

1056
01:05:20,110 --> 01:05:23,660
Entón, o que son punteiros? Algúns de vostedes poden non ter cuberto este na sección anterior.

1057
01:05:23,660 --> 01:05:26,660
pero podemos pasar por iso na charla, para un punteiro é só un tipo de datos

1058
01:05:26,660 --> 01:05:34,030
que as tendas, en vez de algún tipo de valor como 50, el almacena o enderezo de algún lugar na memoria.

1059
01:05:34,030 --> 01:05:36,020
Como a memoria [inintelixible].

1060
01:05:36,020 --> 01:05:41,120
Polo tanto, neste caso, o que temos é, temos un punteiro para un enteiro ou un int *,

1061
01:05:41,120 --> 01:05:46,210
e que contén este enderezo hexadecimal de 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Entón o que temos é, agora, este punteiro apunta nalgún lugar na memoria,

1063
01:05:50,880 --> 01:05:56,020
e iso é só un, o valor de 50 é neste lugar de memoria.

1064
01:05:56,020 --> 01:06:01,810
Nalgúns sistemas de 32 bits, en todos os sistemas de 32 bits, os punteiros levar ata 32 anacos ou 4 bytes.

1065
01:06:01,810 --> 01:06:06,020
Pero, por exemplo, nun sistema de 64 bits, os punteiros son 64 bits.

1066
01:06:06,020 --> 01:06:08,040
Entón, iso é algo que vai querer manter presente.

1067
01:06:08,040 --> 01:06:12,310
Entón, en un sistema de punta-bit, un punteiro e bits a longo prazo.

1068
01:06:12,310 --> 01:06:17,320
Os punteiros son unha cousa difícil de dixerir sen cousas extras,

1069
01:06:17,320 --> 01:06:20,300
entón imos pasar un exemplo de asignación dinámica de memoria.

1070
01:06:20,300 --> 01:06:25,130
O distribución dinámica de memoria fai por ti, ou o que chamamos malloc,

1071
01:06:25,130 --> 01:06:29,280
el permite que reservar algún tipo de datos fóra do set.

1072
01:06:29,280 --> 01:06:31,830
Polo tanto, este tipo de datos é máis permanente para a duración do programa.

1073
01:06:31,830 --> 01:06:36,430
Porque, como vostede sabe, se declarar x dentro dunha función, e que retorna de función,

1074
01:06:36,430 --> 01:06:40,910
xa non ten acceso ós datos que foron gardados en x.

1075
01:06:40,910 --> 01:06:44,420
O que imos facer punteiros é que imos almacenar valores de memoria ou tenda

1076
01:06:44,420 --> 01:06:46,840
nun segmento diferente de memoria, ou sexa, a pila.

1077
01:06:46,840 --> 01:06:49,340
Agora, despois volvemos para fóra da función, dende que temos un punteiro

1078
01:06:49,340 --> 01:06:54,960
para ese lugar na memoria, entón o que podemos facer é que podemos só ollar para os valores alí.

1079
01:06:54,960 --> 01:06:58,020
Vexamos un exemplo: Este é o noso esquema de memoria de novo.

1080
01:06:58,020 --> 01:07:00,050
E nós temos esa función, principal.

1081
01:07:00,050 --> 01:07:06,870
O que fai é - ben, tan sinxelo, non -? Int x = 5, que é só unha variable na pila na principal.

1082
01:07:06,870 --> 01:07:12,450
>> Por outra banda, agora imos declarar un punteiro que chama os giveMeThreeInts función.

1083
01:07:12,450 --> 01:07:16,800
E agora imos para esa función e crear un novo marco de pila para el.

1084
01:07:16,800 --> 01:07:20,440
Con todo, neste cadro de pila, nós declaramos tempo * int,

1085
01:07:20,440 --> 01:07:23,210
que mallocs tres enteiros para nós.

1086
01:07:23,210 --> 01:07:25,880
Así o tamaño int nos dará cantos bytes int este é,

1087
01:07:25,880 --> 01:07:29,620
malloc e dános que moitos bytes de espazo na pila.

1088
01:07:29,620 --> 01:07:32,890
Polo tanto, neste caso, creamos espazo suficiente para tres números enteiros,

1089
01:07:32,890 --> 01:07:36,830
ea pila é alí enriba, que é por iso que eu tirei máis arriba.

1090
01:07:36,830 --> 01:07:42,900
Así que está preparado, nós volvemos aquí, só precisa de 3 ints volveu,

1091
01:07:42,900 --> 01:07:47,000
e retorna o enderezo, no caso de que máis que a memoria é.

1092
01:07:47,000 --> 01:07:51,250
E nós definir punteiro = interruptor, e ata alí temos só un punteiro outro.

1093
01:07:51,250 --> 01:07:54,550
Pero o que os retorno de función é empilhado aquí, e desaparece.

1094
01:07:54,550 --> 01:07:59,250
Entón temporal desaparece, pero tamén manter o enderezo de onde

1095
01:07:59,250 --> 01:08:01,850
estes tres enteiros están dentro da rede.

1096
01:08:01,850 --> 01:08:06,180
Polo tanto, neste conxunto, os punteiros son alcance local para o cadro empilhados,

1097
01:08:06,180 --> 01:08:09,860
pero a memoria a que se refiren é o heap.

1098
01:08:09,860 --> 01:08:12,190
>> Isto ten sentido?

1099
01:08:12,190 --> 01:08:14,960
[Estudante] Pode repetir? >> [Joseph] Si

1100
01:08:14,960 --> 01:08:20,270
Entón, se eu volver un pouco, ve que temporal asignado

1101
01:08:20,270 --> 01:08:23,500
algunha memoria na pila alí enriba.

1102
01:08:23,500 --> 01:08:28,680
Entón, cando esa función, retorna giveMeThreeInts, esta pila aquí vai desaparecer.

1103
01:08:28,680 --> 01:08:35,819
E con el calquera das variables, neste caso, este punteiro que foi alocado no marco empilhado.

1104
01:08:35,819 --> 01:08:39,649
Isto vai desaparecer, pero desde que volveu de temperatura

1105
01:08:39,649 --> 01:08:46,330
e partimos punteiro = tempo, o punteiro agora vai apuntar a mesma memoria de localización como temperatura foi.

1106
01:08:46,330 --> 01:08:50,370
Entón, agora, a pesar de perder tempo, ese punteiro local,

1107
01:08:50,370 --> 01:08:59,109
nós tamén manter o enderezo de memoria do que estaba apuntando cara a dentro que o punteiro variable.

1108
01:08:59,109 --> 01:09:03,740
Preguntas? Isto pode ser unha especie de tema confuso se non ir máis en sección.

1109
01:09:03,740 --> 01:09:09,240
Podemos, o seu TF vai certamente pasar por iso e por suposto que podemos responder a preguntas

1110
01:09:09,240 --> 01:09:11,500
ao final da sesión de revisión para este.

1111
01:09:11,500 --> 01:09:14,220
Pero esta é unha especie de un tema complexo, e eu teño máis exemplos que van aparecer

1112
01:09:14,220 --> 01:09:18,790
que vai axudar a esclarecer o que realmente son os punteiros.

1113
01:09:18,790 --> 01:09:22,500
>> Neste caso, os punteiros son equivalentes ás matrices,

1114
01:09:22,500 --> 01:09:25,229
entón eu só podo usar ese punteiro como a mesma cousa que unha matriz int.

1115
01:09:25,229 --> 01:09:29,840
Entón, eu estou indexación en 0, e cambiando o primeiro número enteiro a 1,

1116
01:09:29,840 --> 01:09:39,689
cambiar o segundo enteiro de 2, e o número enteiro 3 a 3.

1117
01:09:39,689 --> 01:09:44,210
Entón, máis punteiros. Ben, lembro Binky.

1118
01:09:44,210 --> 01:09:48,319
Neste caso temos asignado un punteiro ou declaramos un punteiro,

1119
01:09:48,319 --> 01:09:52,760
pero, inicialmente, cando acababa de declarar un punteiro, non está a apuntar para calquera lugar na memoria.

1120
01:09:52,760 --> 01:09:54,930
É só valores de lixo no interior da mesma.

1121
01:09:54,930 --> 01:09:56,470
Entón eu non teño idea de onde este punteiro está apuntando.

1122
01:09:56,470 --> 01:10:01,630
El ten un enderezo que é só cuberto con 0 e 1, onde foi inicialmente declarado.

1123
01:10:01,630 --> 01:10:04,810
Eu non podo facer nada con iso ata eu chamar malloc sobre el

1124
01:10:04,810 --> 01:10:08,390
e entón el me dá un pouco de espazo na pila onde eu poida poñer valores dentro.

1125
01:10:08,390 --> 01:10:11,980
Entón, de novo, eu non sei o que está dentro desa memoria.

1126
01:10:11,980 --> 01:10:16,780
Entón o primeiro que teño que facer é comprobar que o sistema tiña suficiente memoria

1127
01:10:16,780 --> 01:10:20,850
para me dar de volta un número enteiro en primeiro lugar, que é por iso que eu estou facendo esta comprobación.

1128
01:10:20,850 --> 01:10:25,020
Se o punteiro é nulo, o que significa que non teñen espazo suficiente ou algún outro erro ocorreu,

1129
01:10:25,020 --> 01:10:26,320
así que eu debería saír do meu programa.

1130
01:10:26,320 --> 01:10:29,400
 Pero se fixo éxito, agora podo usar ese punteiro

1131
01:10:29,400 --> 01:10:35,020
eo que fai é punteiro * séguese que o enderezo é

1132
01:10:35,020 --> 01:10:38,480
onde este valor é, e defínese a igual a 1.

1133
01:10:38,480 --> 01:10:41,850
Entón, aquí, estamos comprobando a memoria existía.

1134
01:10:41,850 --> 01:10:45,380
>> Unha vez que vostede sabe que existe, pode pór nel

1135
01:10:45,380 --> 01:10:50,460
que o valor que quere poñer nel, neste caso 1.

1136
01:10:50,460 --> 01:10:53,060
Unha vez que estamos a facer con el, ten que liberar ese punteiro

1137
01:10:53,060 --> 01:10:57,160
porque necesitamos volver ao sistema que a memoria que solicitou, en primeiro lugar.

1138
01:10:57,160 --> 01:10:59,690
Como o ordenador non sabe cando estamos a facer con el.

1139
01:10:59,690 --> 01:11:02,510
Neste caso, estamos explicitamente dicindo que, ben, estamos a facer que a memoria.

1140
01:11:02,510 --> 01:11:10,780
Se algún outro proceso precisa del, algún outro programa precisa del, Sinto-se libre para ir adiante e leva-la.

1141
01:11:10,780 --> 01:11:15,110
O que tamén pode facer é que pode obter só o enderezo de variables locais no conxunto.

1142
01:11:15,110 --> 01:11:19,080
Entón x int e dentro do marco de empilhados principal.

1143
01:11:19,080 --> 01:11:23,060
E cando usamos este comercial, este operador, o que fai é

1144
01:11:23,060 --> 01:11:27,310
leva x, e X é só algúns datos da memoria, pero non ten un enderezo.

1145
01:11:27,310 --> 01:11:33,790
Está situado en algún lugar. Entón, chamando & x, o que isto significa que nos dá o enderezo de x.

1146
01:11:33,790 --> 01:11:38,430
Ao facelo, estamos facendo punto punteiro onde x é na memoria.

1147
01:11:38,430 --> 01:11:41,710
Agora só facer algo como * x, imos obter 5 de volta.

1148
01:11:41,710 --> 01:11:43,820
A estrela é chamada dereferencing-lo.

1149
01:11:43,820 --> 01:11:46,640
Vostede segue a dirección e terá o valor del alí almacenados.

1150
01:11:51,000 --> 01:11:53,310
>> Algunha pregunta? Si?

1151
01:11:53,310 --> 01:11:56,500
[Estudante] Se non fai a cousa tres puntas, ela aínda compilar?

1152
01:11:56,500 --> 01:11:59,490
Si Se non fai a cousa de 3 puntos, aínda vai compilar,

1153
01:11:59,490 --> 01:12:02,720
pero eu vou amosar o que pasa nun segundo, e sen facelo,

1154
01:12:02,720 --> 01:12:04,860
iso é o que chamamos baleirado de memoria. Non está dando ao sistema

1155
01:12:04,860 --> 01:12:07,850
apoiar a súa memoria, para despois dun tempo o programa vai acumular

1156
01:12:07,850 --> 01:12:10,940
memoria que non está a usar, e nada máis pode usalo.

1157
01:12:10,940 --> 01:12:15,750
Se xa viu o Firefox con 1,5 millóns de kilobytes no seu computador,

1158
01:12:15,750 --> 01:12:17,840
no xestor de tarefas, é o que está a suceder.

1159
01:12:17,840 --> 01:12:20,760
Tes un baleirado de memoria no programa que non está seguro.

1160
01:12:23,080 --> 01:12:26,240
Así como o punteiro traballo aritmética?

1161
01:12:26,240 --> 01:12:29,480
Ben, a aritmética de punteiro é unha especie de indexación como unha matriz.

1162
01:12:29,480 --> 01:12:36,370
Neste caso, eu teño un punteiro, e que fago é facer punto punteiro para o primeiro elemento

1163
01:12:36,370 --> 01:12:42,100
Esta serie de tres números enteiros que alocados.

1164
01:12:42,100 --> 01:12:46,670
Entón agora o que fago, o punteiro estrela só cambia o primeiro elemento da lista.

1165
01:12:46,670 --> 01:12:49,140
Estrela punteiro 1 puntos aquí.

1166
01:12:49,140 --> 01:12:53,140
Entón punteiro está aquí, é un punteiro aquí, punteiro 2 é aquí.

1167
01:12:53,140 --> 01:12:56,610
>> Entón, só tes que engadir 1 é a mesma cousa que se move ao longo desta matriz.

1168
01:12:56,610 --> 01:12:59,880
O que facemos é cando facemos un punteiro de obter o enderezo aquí,

1169
01:12:59,880 --> 01:13:04,180
e, a fin de obter o valor aquí, coloca unha estrela no de toda a expresión

1170
01:13:04,180 --> 01:13:05,990
para cancelar a referencia dela.

1171
01:13:05,990 --> 01:13:09,940
Así, neste caso, eu estou definindo a primeira posición nesta matriz a 1,

1172
01:13:09,940 --> 01:13:13,970
segundo lugar a 2, e a terceira posición 3.

1173
01:13:13,970 --> 01:13:18,180
Entón o que eu estou facendo aquí é que eu estou imprimindo noso punteiro 1,

1174
01:13:18,180 --> 01:13:19,970
que só me dá 2.

1175
01:13:19,970 --> 01:13:23,650
Agora estou incrementando punteiro, para que o punteiro é igual a un punteiro,

1176
01:13:23,650 --> 01:13:26,780
que se move cara adiante.

1177
01:13:26,780 --> 01:13:30,810
E agora, se eu imprimir un punteiro, punteiro 1 é agora 3,

1178
01:13:30,810 --> 01:13:33,990
que neste caso é impresa 3.

1179
01:13:33,990 --> 01:13:36,560
E a fin de algo libre, o punteiro que dou

1180
01:13:36,560 --> 01:13:40,540
debe estar apuntando para o inicio da matriz, que eu volvín do malloc.

1181
01:13:40,540 --> 01:13:43,430
Así, neste caso, se eu fose chamar tres aquí, iso non sería correcto,

1182
01:13:43,430 --> 01:13:45,070
porque é no medio da matriz.

1183
01:13:45,070 --> 01:13:48,820
Eu teño que restar para chegar ao lugar orixinal

1184
01:13:48,820 --> 01:13:50,420
o punto de inicio antes de que eu poida libertá-lo.

1185
01:13:56,300 --> 01:13:58,450
Entón, aquí está un exemplo máis complicado.

1186
01:13:58,450 --> 01:14:03,360
Neste caso, estamos alocando sete caracteres nunha matriz de caracteres.

1187
01:14:03,360 --> 01:14:06,480
>> E, neste caso, o que estamos facendo é que estamos looping sobre o 6 primeiro deles,

1188
01:14:06,480 --> 01:14:09,900
e estamos poñendo a Z.

1189
01:14:09,900 --> 01:14:13,350
Así, para i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Así, o punteiro + i vai só dar-nos, neste caso,

1191
01:14:16,220 --> 01:14:20,860
punteiro, punteiro 1, 2 punteiro, punteiro 3, e así por diante e así por diante no circuíto.

1192
01:14:20,860 --> 01:14:24,040
O que vai facer é que queda ese enderezo, dereferences-lo para obter o valor,

1193
01:14:24,040 --> 01:14:27,440
e cambia o valor que para un Z.

1194
01:14:27,440 --> 01:14:30,350
Entón, ao final lembrar que isto é unha cadea, non?

1195
01:14:30,350 --> 01:14:33,560
Todas as cordas teñen que rematar co caracter nulo de terminación.

1196
01:14:33,560 --> 01:14:38,620
Entón, o que fago é o punteiro 6 engada o carácter terminador nulo dentro

1197
01:14:38,620 --> 01:14:43,980
E agora o que estou facendo aquí, basicamente, está a aplicar printf para a cadea, non?

1198
01:14:43,980 --> 01:14:46,190
>> Entón, cando é que printf agora, cando atinxir o final dunha cadea?

1199
01:14:46,190 --> 01:14:48,230
Cando chega o carácter nulo de terminación.

1200
01:14:48,230 --> 01:14:52,030
Así, neste caso, os meus punteiro puntos orixinais para o inicio desta matriz.

1201
01:14:52,030 --> 01:14:56,410
Eu imprimir o primeiro carácter fóra. Eu movelo sobre unha.

1202
01:14:56,410 --> 01:14:58,420
Eu imprimir ese personaxe para fóra. Eu movelo máis.

1203
01:14:58,420 --> 01:15:02,180
E eu sigo facendo iso ata eu chegar ao final.

1204
01:15:02,180 --> 01:15:07,750
E agora o punteiro * final será dereference iso e obter o carácter nulo de terminación de volta.

1205
01:15:07,750 --> 01:15:11,780
E por iso o meu loop while é executado só cando ese valor non é o carácter nulo de terminación.

1206
01:15:11,780 --> 01:15:13,770
Entón, agora eu saír fóra deste circuíto.

1207
01:15:18,780 --> 01:15:21,180
E así se eu restar 6 deste punteiro,

1208
01:15:21,180 --> 01:15:22,860
Eu volver todo o camiño ata o principio.

1209
01:15:22,860 --> 01:15:27,880
Lembre, eu estou facendo iso porque eu teño que ir ao inicio, a fin de liberalo la.

1210
01:15:27,880 --> 01:15:30,270
>> Entón, sei que foi moi. Algunha pregunta?

1211
01:15:30,270 --> 01:15:31,870
Por favor, si?

1212
01:15:31,870 --> 01:15:36,610
[Inintelixible cuestión Estudante]

1213
01:15:36,610 --> 01:15:38,190
Podes dicir que máis alto? Sentímolo.

1214
01:15:38,190 --> 01:15:44,140
[Estudante] No último slide dereito antes de liberou o punteiro,

1215
01:15:44,140 --> 01:15:47,300
onde estaba realmente cambiando o valor do punteiro?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Entón, aquí. >> [Estudante] Ah, ok.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Entón, eu teño un punteiro menos menos, dereito,

1218
01:15:51,890 --> 01:15:54,140
o que move a cousa de volta un, e entón eu libertá-lo,

1219
01:15:54,140 --> 01:15:57,000
porque este punteiro debe ser apuntado para o inicio da matriz.

1220
01:15:57,000 --> 01:16:00,420
[Estudante] Pero iso non sería necesario se tivese parado tras esa liña.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Entón, se eu tiña parado despois diso, iso sería considerado un baleirado de memoria,

1222
01:16:03,130 --> 01:16:04,810
porque eu non executar libre.

1223
01:16:04,810 --> 01:16:11,290
[Estudante] I [inintelixible] tras as tres primeiras liñas que tiña un punteiro [inintelixible].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-Huh. Entón, cal é a pregunta alí?

1225
01:16:13,140 --> 01:16:14,780
Sentímolo. Non, non. Vai, vai, por favor.

1226
01:16:14,780 --> 01:16:16,870
[Estudante] Entón, non está cambiando o valor de punteiros.

1227
01:16:16,870 --> 01:16:19,130
Non tería que facer punteiro menos de menos.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Si, exactamente.

1229
01:16:19,730 --> 01:16:21,890
Entón, cando fago un punteiro e punteiro 2,

1230
01:16:21,890 --> 01:16:24,410
Eu non estou facendo un punteiro igual punteiro.

1231
01:16:24,410 --> 01:16:27,260
Así, o punteiro só permanece apuntando para o inicio da matriz.

1232
01:16:27,260 --> 01:16:31,460
É só cando fago máis, máis que define o valor de volta para dentro do punteiro,

1233
01:16:31,460 --> 01:16:33,550
que realmente move este xunto.

1234
01:16:36,860 --> 01:16:37,780
Todo ben.

1235
01:16:40,550 --> 01:16:42,030
Máis preguntas?

1236
01:16:44,680 --> 01:16:47,790
>> Unha vez máis, se este é o tipo esmagador, este será cuberto na sesión.

1237
01:16:47,790 --> 01:16:50,710
Pregunta ó seu compañeiro de ensino sobre iso, e podemos responder a preguntas ao final.

1238
01:16:53,510 --> 01:16:56,600
E, xeralmente, non quere facer esa cousa de menos.

1239
01:16:56,600 --> 01:16:59,760
Isto ten que esixir-me manter a par de que eu desprazamento na matriz.

1240
01:16:59,760 --> 01:17:04,520
Polo tanto, en xeral, este é só para explicar como funciona a aritmética de punteiro.

1241
01:17:04,520 --> 01:17:07,970
Pero o que nós normalmente gusto de facer é que nos gusta de crear unha copia do punteiro,

1242
01:17:07,970 --> 01:17:11,640
e despois imos utilizar esa copia, cando nos movemos en torno ao fío.

1243
01:17:11,640 --> 01:17:14,660
Entón, nestes caso, utilizar a copia para imprimir toda a cadea,

1244
01:17:14,660 --> 01:17:19,040
pero non hai que facer como punteiro menos 6 ou manter o control de canto nos cambiamos tanto,

1245
01:17:19,040 --> 01:17:22,700
só porque sabemos que o noso punto orixinal aínda sinalou o inicio da lista

1246
01:17:22,700 --> 01:17:25,340
e todo o que cambiou esta copia.

1247
01:17:25,340 --> 01:17:28,250
Polo tanto, en xeral, cambiar copias do punteiro orixinal.

1248
01:17:28,250 --> 01:17:32,350
Non intente a sorte de como - non cambiar copias orixinais.

1249
01:17:32,350 --> 01:17:35,290
Tentando cambiar só copias do seu orixinal.

1250
01:17:41,540 --> 01:17:44,870
Entón, entende cando pasamos a cadea en printf

1251
01:17:44,870 --> 01:17:48,990
non tes que poñer unha estrela na fronte del, como fixemos con todos os dereferences outros, non?

1252
01:17:48,990 --> 01:17:54,180
Entón, se imprimir o s% toda cadea de espera é un enderezo,

1253
01:17:54,180 --> 01:17:57,610
e, neste caso, un punteiro ou, neste caso, como un conxunto de caracteres.

1254
01:17:57,610 --> 01:18:00,330
>> Caracteres, char * s, e matrices son a mesma cousa.

1255
01:18:00,330 --> 01:18:03,690
Punteiro é para personaxes, e matrices de carácter son a mesma cousa.

1256
01:18:03,690 --> 01:18:05,720
E así, todo o que temos que facer é pasar punteiro.

1257
01:18:05,720 --> 01:18:08,150
Non debemos pasar como punteiro * ou algo así.

1258
01:18:13,110 --> 01:18:14,930
Entón, matrices e punteiros son a mesma cousa.

1259
01:18:14,930 --> 01:18:19,160
Cando está facendo algo así como x [s] aquí por unha matriz,

1260
01:18:19,160 --> 01:18:21,960
o que está facendo baixo o capo é que está dicindo, todo ben, é unha matriz de caracteres

1261
01:18:21,960 --> 01:18:23,690
por iso é un punteiro.

1262
01:18:23,690 --> 01:18:26,510
E así X son a mesma cousa,

1263
01:18:26,510 --> 01:18:28,650
e así o que fai é engadir y para x,

1264
01:18:28,650 --> 01:18:31,820
que é a mesma cousa que avanzar na memoria moito.

1265
01:18:31,820 --> 01:18:34,930
E agora x + y dános algún tipo de enderezo,

1266
01:18:34,930 --> 01:18:37,570
e cancelar o enderezo ou siga a frecha

1267
01:18:37,570 --> 01:18:41,640
a onde que a localización na memoria é e obtemos o valor que a ubicación na memoria.

1268
01:18:41,640 --> 01:18:43,720
Entón, así que estes dous son exactamente a mesma cousa.

1269
01:18:43,720 --> 01:18:45,840
É só un azucre sintático.

1270
01:18:45,840 --> 01:18:48,090
Eles fan o mesmo. Son só sintática diferentes para cada outro.

1271
01:18:51,500 --> 01:18:57,590
>> Entón, o que pode dar mal con punteiros? Como, moito. Okay. Entón, as cousas malas.

1272
01:18:57,590 --> 01:19:02,410
Algunhas cousas malas que pode facer non está comprobando a súa chamada malloc retorna nulo, non?

1273
01:19:02,410 --> 01:19:06,560
Neste caso, eu estou pedindo o sistema para me dar - o que é ese número?

1274
01:19:06,560 --> 01:19:11,200
Como 2 millóns de veces 4, porque o tamaño dun enteiro é 4 bytes.

1275
01:19:11,200 --> 01:19:13,810
Estou preguntando iso para como 8 mil millóns de bytes.

1276
01:19:13,810 --> 01:19:17,270
Está claro que o meu ordenador non vai ser capaz de dar iso de volta moita memoria.

1277
01:19:17,270 --> 01:19:20,960
E nós non comprobar se este é nulo, por iso, cando tentamos eliminar a referencia que alí -

1278
01:19:20,960 --> 01:19:24,270
siga a frecha cara a onde vai - non temos esa memoria.

1279
01:19:24,270 --> 01:19:27,150
Isto é o que chamamos dereferencing un punteiro nulo.

1280
01:19:27,150 --> 01:19:29,710
E iso esencialmente fai que segfault.

1281
01:19:29,710 --> 01:19:31,790
Esta é unha das formas que pode segfault.

1282
01:19:34,090 --> 01:19:38,090
Outras cousas malas que pode facer - oh ben.

1283
01:19:38,090 --> 01:19:40,650
Que foi dereferencing un punteiro nulo. Okay.

1284
01:19:40,650 --> 01:19:45,160
Outras cousas malas - ben, para fixar que acaba de poñer un cheque alí

1285
01:19:45,160 --> 01:19:46,980
que comprobar se o punteiro é nulo

1286
01:19:46,980 --> 01:19:51,000
e saír do programa, se acontece que malloc retorna un punteiro nulo.

1287
01:19:55,110 --> 01:19:59,850
Ese é o cómico xkcd. As persoas entenden agora. Máis ou menos.

1288
01:20:06,120 --> 01:20:09,350
>> Así, memoria. E eu fun por iso.

1289
01:20:09,350 --> 01:20:12,000
Estamos chamando malloc en un loop, pero cada vez que chamar malloc

1290
01:20:12,000 --> 01:20:14,370
estamos perdendo a noción de onde este punteiro está apuntando,

1291
01:20:14,370 --> 01:20:15,750
porque estamos a sobrepasar-lo.

1292
01:20:15,750 --> 01:20:18,410
Así, a chamada inicial para malloc me dá memoria aquí.

1293
01:20:18,410 --> 01:20:19,990
Meus punteiros punteiro para este.

1294
01:20:19,990 --> 01:20:23,020
Agora, eu non libera-lo, entón agora eu chamar malloc novo.

1295
01:20:23,020 --> 01:20:26,070
Agora apunta aquí. Agora, a miña memoria está a apuntar aquí.

1296
01:20:26,070 --> 01:20:27,640
Apuntando aquí. Apuntando aquí.

1297
01:20:27,640 --> 01:20:31,820
Pero eu perdín o control dos enderezos de toda a memoria aquí que eu alocado.

1298
01:20:31,820 --> 01:20:35,100
E agora eu non teño ningunha referencia a eles máis.

1299
01:20:35,100 --> 01:20:37,230
Entón, eu non podo liberalo los fora deste circuíto.

1300
01:20:37,230 --> 01:20:39,390
E así, a fin de corrixir algo como isto,

1301
01:20:39,390 --> 01:20:42,250
Se esquecer de memoria libre e recibe ese baleirado de memoria,

1302
01:20:42,250 --> 01:20:45,810
Ten que liberar a memoria dentro deste ciclo, unha vez que fixo con el.

1303
01:20:45,810 --> 01:20:51,400
Ben, iso é o que pasa. Sei que moitos de vostedes odian iso.

1304
01:20:51,400 --> 01:20:55,270
Pero agora - yay! Comeza como 44.000 kilobytes.

1305
01:20:55,270 --> 01:20:57,110
Así, é liberar-lo ao final do ciclo,

1306
01:20:57,110 --> 01:20:59,770
e que só liberar a memoria de cada vez.

1307
01:20:59,770 --> 01:21:03,620
Esencialmente, o programa non ten un baleirado de memoria máis.

1308
01:21:03,620 --> 01:21:08,150
>> E agora outra cousa que podes facer é liberar memoria que pediu dúas veces.

1309
01:21:08,150 --> 01:21:11,060
Neste caso, algo malloc, cambia o seu valor.

1310
01:21:11,060 --> 01:21:13,140
Vostede libertá-lo de novo, porque dixo que estaba feito con el.

1311
01:21:13,140 --> 01:21:14,940
Pero, entón, liberou-lo de novo.

1312
01:21:14,940 --> 01:21:16,730
Iso é algo que é moi malo.

1313
01:21:16,730 --> 01:21:18,820
El non vai inicialmente segfault,

1314
01:21:18,820 --> 01:21:23,350
pero despois dun tempo o que iso fai é dobre liberación corrompe a súa estrutura de pila,

1315
01:21:23,350 --> 01:21:27,200
e vai aprender un pouco máis sobre iso, se vostede optar por ter unha aula de como CS61.

1316
01:21:27,200 --> 01:21:30,000
Pero, esencialmente, despois dun tempo o ordenador vai ficar confuso

1317
01:21:30,000 --> 01:21:33,010
sobre o que posicións de memoria onde e onde é almacenado -

1318
01:21:33,010 --> 01:21:34,800
onde os datos son almacenados na memoria.

1319
01:21:34,800 --> 01:21:38,080
E así liberar un punteiro dúas veces é unha cousa ruín que non quere facer.

1320
01:21:38,080 --> 01:21:41,600
>> Outras cousas que poden dar mal non está a usar sizeof.

1321
01:21:41,600 --> 01:21:44,460
Entón, neste caso, malloc 8 bytes,

1322
01:21:44,460 --> 01:21:46,700
e iso é o mesmo que dous enteiros, non?

1323
01:21:46,700 --> 01:21:49,580
Entón, iso é perfectamente seguro, pero é el?

1324
01:21:49,580 --> 01:21:52,160
Ben, como Lucas falou en diferentes arquitecturas,

1325
01:21:52,160 --> 01:21:54,220
enteiros son de lonxitudes diferentes.

1326
01:21:54,220 --> 01:21:57,970
Entón, o aparello que está a usar, enteiros son preto de 4 bytes,

1327
01:21:57,970 --> 01:22:02,370
pero en algún outro sistema que pode ser de 8 bytes ou poden ser de 16 bytes.

1328
01:22:02,370 --> 01:22:05,680
Entón, se eu usar este número aquí,

1329
01:22:05,680 --> 01:22:07,310
este programa pode funcionar no dispositivo,

1330
01:22:07,310 --> 01:22:10,360
pero non vai reservar suficiente memoria nalgún outro sistema.

1331
01:22:10,360 --> 01:22:14,020
Neste caso, é iso que o operador sizeof é usado para.

1332
01:22:14,020 --> 01:22:16,880
Cando chamamos sizeof (int), o que iso fai é

1333
01:22:16,880 --> 01:22:21,910
 nos dá o tamaño dun enteiro no sistema que o programa está en execución.

1334
01:22:21,910 --> 01:22:25,490
Así, neste caso, sizeof (int) volverá 4 sobre algo como o aparello,

1335
01:22:25,490 --> 01:22:29,980
e agora esa vontade 4 * 2, que é de 8,

1336
01:22:29,980 --> 01:22:32,330
que é só a cantidade de espazo necesario para dous enteiros.

1337
01:22:32,330 --> 01:22:36,710
Nun sistema diferente, un int é como 16 bytes ou 8 bytes,

1338
01:22:36,710 --> 01:22:39,380
el só vai voltar máis suficientes para almacenar esa cantidade.

1339
01:22:41,830 --> 01:22:45,310
>> E, finalmente, estruturas.

1340
01:22:45,310 --> 01:22:48,340
Entón, se quere gardar unha tarxeta de sudoku na memoria, como podemos facer iso?

1341
01:22:48,340 --> 01:22:51,570
Podes pensar como unha variable para o primeiro,

1342
01:22:51,570 --> 01:22:53,820
unha variable para a segunda cousa, unha variable para a terceira cousa,

1343
01:22:53,820 --> 01:22:56,420
unha variable para a cuarta cousa - malo, non?

1344
01:22:56,420 --> 01:23:00,750
Entón, unha mellora que pode facer encima deste é facer un 9 x 9 matriz.

1345
01:23:00,750 --> 01:23:04,480
Isto é bo, pero o que si quixo asociar outras cousas coa tarxeta de sudoku

1346
01:23:04,480 --> 01:23:06,490
gusto do que a dificultade do Consello,

1347
01:23:06,490 --> 01:23:11,740
ou, por exemplo, o que é a súa puntuación, ou canto tempo el é levado para solucionar este foro?

1348
01:23:11,740 --> 01:23:14,970
Ben, o que pode facer é que pode crear unha estrutura.

1349
01:23:14,970 --> 01:23:18,910
O que eu estou dicindo basicamente é que eu estou definindo esa estrutura aquí,

1350
01:23:18,910 --> 01:23:23,230
e estou definindo un bordo sudoku que consiste nunha placa que é de 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> E o que ten iso ten punteiros para o nome do nivel.

1352
01:23:26,650 --> 01:23:30,730
Tamén ten X e Y, que son as coordenadas de onde estou agora.

1353
01:23:30,730 --> 01:23:35,980
Tamén ten o tempo gastado [inintelixible], e ten o número total de xogadas que introducidos ata o momento.

1354
01:23:35,980 --> 01:23:40,010
E por iso, neste caso, podo agrupar unha morea de datos en só unha estrutura

1355
01:23:40,010 --> 01:23:42,790
en vez de telo como voar en torno a como as distintas variables

1356
01:23:42,790 --> 01:23:44,540
que eu realmente non podo seguir.

1357
01:23:44,540 --> 01:23:49,720
E isto nos permite ter só unha sintaxe agradable para tipo de referenciar cousas distintas dentro desta estrutura.

1358
01:23:49,720 --> 01:23:53,430
Eu só podo facer board.board, e teño a tarxeta sudoku volta.

1359
01:23:53,430 --> 01:23:56,320
Board.level, eu recibín como é duro.

1360
01:23:56,320 --> 01:24:00,540
Board.x e board.y me dar as coordenadas de onde eu podería estar na tarxeta.

1361
01:24:00,540 --> 01:24:04,730
E así eu estou accedendo o que chamamos campos na estrutura.

1362
01:24:04,730 --> 01:24:08,840
Isto define sudokuBoard, que é un tipo que eu teño.

1363
01:24:08,840 --> 01:24:14,800
E agora estamos aquí. Eu teño unha variable chamada "tarxeta" de sudokuBoard tipo.

1364
01:24:14,800 --> 01:24:18,820
E agora podo acceder todos os campos que compoñen esta estrutura aquí.

1365
01:24:20,830 --> 01:24:22,450
>> Calquera dúbida sobre estruturas? Si?

1366
01:24:22,450 --> 01:24:25,890
[Estudante] Para int x, y, se declarou tanto nunha liña? >> [Joseph] Uh-Huh.

1367
01:24:25,890 --> 01:24:27,400
[Estudante] Entón, vostede podería só facer iso con todos eles?

1368
01:24:27,400 --> 01:24:31,200
Gústalle en x, y veces coma que o total?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Si, definitivamente podería facelo, pero a razón de eu poñer x e y na mesma liña -

1370
01:24:34,460 --> 01:24:36,330
ea cuestión é por iso que podemos simplemente facelo na mesma liña?

1371
01:24:36,330 --> 01:24:38,600
Por que non imos só poñer todos estes na mesma liña é

1372
01:24:38,600 --> 01:24:42,090
x e y son relacionados uns cos outros,

1373
01:24:42,090 --> 01:24:44,780
e este é só estilisticamente máis correcto, en certo sentido,

1374
01:24:44,780 --> 01:24:46,600
porque é a agrupación de dúas cousas na mesma liña

1375
01:24:46,600 --> 01:24:49,340
este tipo de como se relacionan co mesmo.

1376
01:24:49,340 --> 01:24:51,440
E eu só dividir estes separados. É só unha cousa de estilo.

1377
01:24:51,440 --> 01:24:53,720
Funcionalmente, non fai diferenza algunha.

1378
01:24:58,150 --> 01:24:59,270
Calquera outras preguntas sobre estruturas?

1379
01:25:03,030 --> 01:25:06,620
Podes establecer unha Pokédex cunha estrutura.

1380
01:25:06,620 --> 01:25:11,720
Un Pokémon ten un número e ten unha letra, un propietario, un tipo.

1381
01:25:11,720 --> 01:25:16,990
E entón, se ten unha serie de Pokémon, pode facer unha Pokédex, non?

1382
01:25:16,990 --> 01:25:20,810
Ok, legal. Así, cuestións sobre estruturas. Esas son relacionadas ás structs.

1383
01:25:20,810 --> 01:25:25,270
>> Finalmente, GDB. O que o GDB deixar facer? El permite que depurar o programa.

1384
01:25:25,270 --> 01:25:27,650
E se non ten usado o GDB, eu sería recomendable asistir o curta

1385
01:25:27,650 --> 01:25:31,250
e só vai sobre o GDB é, como traballa con el, como pode usalo,

1386
01:25:31,250 --> 01:25:32,900
e proba-lo en un programa.

1387
01:25:32,900 --> 01:25:37,400
E así o GDB permite facer é que permite deter a [inintelixible] o seu programa

1388
01:25:37,400 --> 01:25:38,920
e unha liña de práctica.

1389
01:25:38,920 --> 01:25:42,600
Por exemplo, quero facer unha pausa durante a execución como a liña 3 do meu programa,

1390
01:25:42,600 --> 01:25:46,010
E mentres eu estou na liña 3 eu poida imprimir os valores que están alí.

1391
01:25:46,010 --> 01:25:49,710
E entón o que chamamos como Pausa nunha liña

1392
01:25:49,710 --> 01:25:52,350
é chamamos iso de poñer un punto de interrupción na liña que

1393
01:25:52,350 --> 01:25:55,920
e entón podemos imprimir as variables no estado do programa na época.

1394
01:25:55,920 --> 01:25:58,990
>> Podemos, entón, a partir de aí percorrer o programa de liña a liña.

1395
01:25:58,990 --> 01:26:03,200
E entón podemos ollar para o estado da pila no momento.

1396
01:26:03,200 --> 01:26:08,600
E así, a fin de utilizar o GDB, o que nós facemos é chamar bumbum no arquivo C,

1397
01:26:08,600 --> 01:26:11,290
pero temos que pasar a bandeira ggdb.

1398
01:26:11,290 --> 01:26:15,850
E xa que estamos a facer que só executar o gdb no ficheiro de saída resultante.

1399
01:26:15,850 --> 01:26:18,810
E para que obteña unha masa como texto coma este,

1400
01:26:18,810 --> 01:26:21,990
pero realmente todo o que precisa facer é escribir ordes no inicio.

1401
01:26:21,990 --> 01:26:24,250
Romper principal coloca un punto de interrupción na principal.

1402
01:26:24,250 --> 01:26:28,470
Lista de 400 lista as liñas de código en torno á liña 400.

1403
01:26:28,470 --> 01:26:31,410
E así, neste caso, pode só ollar ao redor e dicir, oh,

1404
01:26:31,410 --> 01:26:34,360
Quero establecer un punto de interrupción na liña 397, que é esta liña,

1405
01:26:34,360 --> 01:26:37,170
e, a continuación, o programa é executado en que paso e que vai romper.

1406
01:26:37,170 --> 01:26:41,120
Vai parar alí, e pode imprimir, por exemplo, o valor de baixa ou alta.

1407
01:26:41,120 --> 01:26:46,410
E así hai unha morea de comandos que precisa saber,

1408
01:26:46,410 --> 01:26:48,660
e este Presentación vai subir na web,

1409
01:26:48,660 --> 01:26:54,000
por iso, se quere só facer referencia a estes ou como poñer-los nas súas cabulas, Sinto-se a liberdade.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Iso foi Quiz Revisión 0, e imos estar por aquí, se tes algunha dúbida.

1411
01:27:00,650 --> 01:27:03,850
Todo ben.

1412
01:27:03,850 --> 01:27:09,030
>>  [Aplausos]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]