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

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

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

4
00:00:08,000 --> 00:00:10,000
>> Hey, todo el mundo.

5
00:00:10,000 --> 00:00:15,000
Bienvenidos a la sesión de revisión para Quiz 0, que se celebra este miércoles.

6
00:00:15,000 --> 00:00:19,000
Lo que vamos a hacer esta noche, estoy con 3 otros FF,

7
00:00:19,000 --> 00:00:24,000
y juntos vamos a ir a través de una revisión de lo que hemos hecho en el curso hasta el momento.

8
00:00:24,000 --> 00:00:27,000
No va a ser 100% completo, pero debe darle una idea mejor

9
00:00:27,000 --> 00:00:31,000
de lo que ya tiene y por lo que todavía tiene que estudiar antes del miércoles.

10
00:00:31,000 --> 00:00:34,000
Y no dude en levantar la mano con preguntas como vamos a lo largo,

11
00:00:34,000 --> 00:00:38,000
pero tenga en cuenta que también vamos a tener un poco de tiempo al final-

12
00:00:38,000 --> 00:00:41,000
si conseguimos a través de unos minutos de sobra para hacer preguntas generales,

13
00:00:41,000 --> 00:00:47,000
así que tenlo en mente, así que vamos a empezar desde el principio con la Semana 0.

14
00:00:47,000 --> 00:00:50,000
>> [Concurso 0 Review!] [Parte 0] [Lexi Ross] Pero antes de hacer eso vamos a hablar de

15
00:00:50,000 --> 00:00:53,000
la logística de la prueba.

16
00:00:53,000 --> 00:00:55,000
>> [Logística] [Concurso tendrá lugar el miércoles 10/10 en lugar de la conferencia]

17
00:00:55,000 --> 00:00:57,000
>> [(Ver http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf para más detalles)] Es el miércoles, 10 de octubre.

18
00:00:57,000 --> 00:01:00,000
>> Eso es este miércoles, y si vas a esta URL aquí

19
00:01:00,000 --> 00:01:03,000
que también es accesible desde CS50.net-ahí 's un enlace a ella-

20
00:01:03,000 --> 00:01:06,000
puede ver información acerca de dónde ir sobre la base de

21
00:01:06,000 --> 00:01:10,000
su apellido o afiliación escolar, así como

22
00:01:10,000 --> 00:01:14,000
se habla exactamente lo que la prueba incluirá y los tipos de preguntas que usted va a obtener.

23
00:01:14,000 --> 00:01:19,000
Tenga en cuenta que usted también tendrá la oportunidad de revisar el cuestionario en la sección,

24
00:01:19,000 --> 00:01:21,000
por lo que sus TFS debe ir sobre algunos problemas de la práctica,

25
00:01:21,000 --> 00:01:29,000
y esa es otra buena oportunidad para ver de dónde usted todavía tiene que estudiar para el examen.

26
00:01:29,000 --> 00:01:32,000
Vamos a empezar desde el principio con bytes 'n' Bits.

27
00:01:32,000 --> 00:01:35,000
Recuerde que un bit es un 0 o un 1,

28
00:01:35,000 --> 00:01:38,000
y un byte es una colección de 8 de estos bits.

29
00:01:38,000 --> 00:01:42,000
Echemos un vistazo a esta colección de bits aquí.

30
00:01:42,000 --> 00:01:44,000
Debemos ser capaces de averiguar cuántos bits hay.

31
00:01:44,000 --> 00:01:48,000
Donde se cuenta que hay sólo 8 de ellos, ocho 0 ó 1 unidades.

32
00:01:48,000 --> 00:01:51,000
Y puesto que hay 8 bits, eso es 1 byte,

33
00:01:51,000 --> 00:01:53,000
y vamos a convertir a hexadecimal.

34
00:01:53,000 --> 00:01:58,000
Hexadecimal es base 16, y es bastante fácil de convertir

35
00:01:58,000 --> 00:02:01,000
en un número binario, que es lo que es, a un número en hexadecimal.

36
00:02:01,000 --> 00:02:04,000
Todo lo que hacemos es mirar en grupos de 4,

37
00:02:04,000 --> 00:02:07,000
y convertirlos al dígito hexadecimal correspondiente.

38
00:02:07,000 --> 00:02:11,000
Comenzamos con el grupo de más a la derecha de 4, así que 0011.

39
00:02:11,000 --> 00:02:16,000
Eso va a ser un 1 y un 2, por lo que en conjunto hace 3.

40
00:02:16,000 --> 00:02:19,000
Y luego vamos a ver el otro bloque de 4.

41
00:02:19,000 --> 00:02:24,000
1101. Eso va a ser un 1, un 4 y un 8.

42
00:02:24,000 --> 00:02:28,000
Junto eso va a ser de 13, lo que hace D.

43
00:02:28,000 --> 00:02:32,000
Y vamos a recordar que en hexadecimal no nos limitamos a ir del 0 al 9.

44
00:02:32,000 --> 00:02:36,000
Vamos 0 a F, por lo que después de 9, 10 corresponde a A,

45
00:02:36,000 --> 00:02:40,000
11 a B, etcétera, donde F es 15.

46
00:02:40,000 --> 00:02:44,000
Aquí 13 es una D,

47
00:02:44,000 --> 00:02:49,000
por lo que para convertir a decimal todo lo que hacemos es en realidad

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

49
00:02:52,000 --> 00:02:58,000
Esa es una de 1, un 2, cero 4s, 8s cero, uno 16, etcétera,

50
00:02:58,000 --> 00:03:03,000
y es un poco difícil de calcular en la cabeza, pero si vamos a la siguiente diapositiva

51
00:03:03,000 --> 00:03:05,000
podemos ver la respuesta a eso.

52
00:03:05,000 --> 00:03:09,000
>> Esencialmente vamos al otro lado de la derecha de nuevo a la izquierda,

53
00:03:09,000 --> 00:03:14,000
y estamos multiplicando cada dígito por la correspondiente potencia de 2.

54
00:03:14,000 --> 00:03:19,000
Y recuerda, para hexadecimal que denotan estas cifras con 0x al principio

55
00:03:19,000 --> 00:03:23,000
así que no lo confunda con un número decimal.

56
00:03:23,000 --> 00:03:29,000
Continuando, esta es una tabla ASCII,

57
00:03:29,000 --> 00:03:35,000
y lo que utilice ASCII para es mapear de caracteres a valores numéricos.

58
00:03:35,000 --> 00:03:39,000
Recuerde que en el conjunto de procesadores criptografía hemos hecho un uso extensivo de la tabla ASCII

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

60
00:03:43,000 --> 00:03:47,000
el César y el cifrado de Vigenère, para convertir letras diferentes

61
00:03:47,000 --> 00:03:52,000
en una cadena de acuerdo con la clave proporcionada por el usuario.

62
00:03:52,000 --> 00:03:56,000
Vamos a ver un poco de matemáticas ASCII.

63
00:03:56,000 --> 00:04:02,000
En cuanto a 'P' + 1, en formato de caracteres que sería Q,

64
00:04:02,000 --> 00:04:07,000
y recuerda que '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
Y cómo podríamos convertir entre estas 2 formas?

66
00:04:10,000 --> 00:04:13,000
No es en realidad demasiado dura.

67
00:04:13,000 --> 00:04:16,000
Con el fin de obtener 5 restamos '0 '

68
00:04:16,000 --> 00:04:20,000
porque hay 5 lugares entre el 0 y el '5 '.

69
00:04:20,000 --> 00:04:23,000
Con el fin de ir hacia el otro que sólo tiene que añadir el 0,

70
00:04:23,000 --> 00:04:25,000
por lo que es una especie de aritmética regular.

71
00:04:25,000 --> 00:04:29,000
Sólo recuerde que cuando algo tiene comillas alrededor de él que es un personaje

72
00:04:29,000 --> 00:04:37,000
y por lo tanto corresponde a un valor en la tabla ASCII.

73
00:04:37,000 --> 00:04:40,000
Entrando en temas más generales de informática.

74
00:04:40,000 --> 00:04:43,000
Nos enteramos de lo que un algoritmo es y cómo se utiliza la programación

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

76
00:04:45,000 --> 00:04:48,000
Algunos ejemplos de algoritmos son algo realmente simple, como

77
00:04:48,000 --> 00:04:51,000
comprobar si un número es par o impar.

78
00:04:51,000 --> 00:04:54,000
Para los que se acuerdan de nosotros mod el número por 2 y comprobar si el resultado es 0.

79
00:04:54,000 --> 00:04:57,000
Si es así, es aún. Si no es así, es extraño.

80
00:04:57,000 --> 00:04:59,000
Y eso es un ejemplo de un algoritmo muy básico.

81
00:04:59,000 --> 00:05:02,000
>> Un poco de una mayor participación es la búsqueda binaria,

82
00:05:02,000 --> 00:05:05,000
que vamos a repasar más tarde en la sesión de revisión.

83
00:05:05,000 --> 00:05:09,000
Y la programación es el término que usamos para tomar un algoritmo

84
00:05:09,000 --> 00:05:15,000
y la conversión a codificar el ordenador puede leer.

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

86
00:05:20,000 --> 00:05:22,000
que es lo que hicimos en la semana 0.

87
00:05:22,000 --> 00:05:25,000
A pesar de que en realidad no se escribe el código es una forma de implementar

88
00:05:25,000 --> 00:05:29,000
este algoritmo, que es la impresión de los números 1-10,

89
00:05:29,000 --> 00:05:32,000
y aquí hacemos lo mismo en el lenguaje de programación C.

90
00:05:32,000 --> 00:05:41,000
Estos son funcionalmente equivalentes, acaba de escribir en diferentes idiomas o de sintaxis.

91
00:05:41,000 --> 00:05:44,000
Después nos enteramos acerca de las expresiones booleanas,

92
00:05:44,000 --> 00:05:48,000
y un booleano es un valor que es verdadero o falso,

93
00:05:48,000 --> 00:05:51,000
y aquí muchas veces expresiones booleanas

94
00:05:51,000 --> 00:05:55,000
ir dentro de las condiciones, así que si (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
bueno, ya establecer x = 5, por lo que el estado se va a evaluar en true.

96
00:06:00,000 --> 00:06:03,000
Y si es verdadero, todo el código está por debajo de la condición

97
00:06:03,000 --> 00:06:08,000
va a ser evaluado por el ordenador, de modo que cadena se va a imprimir

98
00:06:08,000 --> 00:06:12,000
la salida estándar, y la condición de término

99
00:06:12,000 --> 00:06:16,000
se refiere a todo lo que está dentro de los paréntesis de la instrucción if.

100
00:06:16,000 --> 00:06:20,000
Recuerde que todos los operadores.

101
00:06:20,000 --> 00:06:26,000
Recuerda que es && y | | cuando estamos tratando de combinar 2 o más condiciones,

102
00:06:26,000 --> 00:06:30,000
== No = para comprobar si dos cosas son iguales.

103
00:06:30,000 --> 00:06:36,000
Recuerde que es = para la asignación mientras == es un operador booleano.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ y luego la final 2 son fáciles de entender.

105
00:06:41,000 --> 00:06:45,000
Una revisión general de la lógica booleana aquí.

106
00:06:45,000 --> 00:06:48,000
Y expresiones booleanas son también importantes en bucles,

107
00:06:48,000 --> 00:06:50,000
que vamos a repasar ahora.

108
00:06:50,000 --> 00:06:56,000
Aprendimos unas 3 tipos de bucles en lo que va CS50, for, while y do tiempo.

109
00:06:56,000 --> 00:06:59,000
Y es importante saber que mientras para la mayoría de los propósitos

110
00:06:59,000 --> 00:07:02,000
de hecho podemos utilizar cualquier tipo de bucle en general

111
00:07:02,000 --> 00:07:06,000
hay ciertos tipos de propósitos o patrones comunes

112
00:07:06,000 --> 00:07:09,000
en la programación que específicamente llamar a uno de estos bucles

113
00:07:09,000 --> 00:07:13,000
hacer que el. más eficiente o elegante para codificar de esa manera

114
00:07:13,000 --> 00:07:18,000
Vamos a repasar lo que cada uno de estos bucles se suele utilizar para más frecuencia.

115
00:07:18,000 --> 00:07:21,000
>> En un bucle for por lo general, ya sé cuántas veces queremos repetir.

116
00:07:21,000 --> 00:07:24,000
Eso es lo que ponemos en la condición.

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

118
00:07:28,000 --> 00:07:31,000
Ya sabemos que queremos hacer algo 10 veces.

119
00:07:31,000 --> 00:07:34,000
Ahora, por un bucle while, por lo general, no necesariamente

120
00:07:34,000 --> 00:07:36,000
sé cuántas veces queremos que el bucle se ejecute.

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

122
00:07:39,000 --> 00:07:41,000
siempre es verdadera o siempre falsa.

123
00:07:41,000 --> 00:07:44,000
Por ejemplo, mientras que se establece.

124
00:07:44,000 --> 00:07:46,000
Digamos que es una variable booleana.

125
00:07:46,000 --> 00:07:48,000
Si bien es cierto que queremos que el código para evaluar,

126
00:07:48,000 --> 00:07:52,000
así que un poco más extensible, un poco más general que un bucle for,

127
00:07:52,000 --> 00:07:55,000
pero para cualquier bucle también se puede convertir en un bucle while.

128
00:07:55,000 --> 00:08:00,000
Por último, hacer bucles while, que pueden ser los más difíciles de comprender de inmediato,

129
00:08:00,000 --> 00:08:04,000
se utiliza a menudo cuando queremos evaluar el primer código

130
00:08:04,000 --> 00:08:06,000
antes de la primera vez que compruebe el estado.

131
00:08:06,000 --> 00:08:09,000
Un caso de uso común que un ciclo do while

132
00:08:09,000 --> 00:08:12,000
es cuando se desea conseguir la entrada del usuario, y usted sabe que usted quiere preguntar al usuario

133
00:08:12,000 --> 00:08:15,000
para la entrada de por lo menos una vez, pero si no te dan una buena entrada de inmediato

134
00:08:15,000 --> 00:08:18,000
quiere seguir preguntando hasta que te dan la buena entrada.

135
00:08:18,000 --> 00:08:21,000
Ese es el uso más común de un bucle Do While,

136
00:08:21,000 --> 00:08:23,000
y echemos un vistazo a la estructura real de estos bucles.

137
00:08:23,000 --> 00:08:27,000
Por lo general siempre tienden a seguir estos patrones.

138
00:08:27,000 --> 00:08:30,000
>> En el bucle para el interior tiene 3 componentes:

139
00:08:30,000 --> 00:08:35,000
inicialización, por lo general algo como int i = 0 donde i es el contador,

140
00:08:35,000 --> 00:08:40,000
condición, donde queremos decir para ejecutar este bucle, siempre que esta situación todavía se mantiene,

141
00:08:40,000 --> 00:08:44,000
como i <10, y, por último, la actualización, que es la forma en que incrementa

142
00:08:44,000 --> 00:08:47,000
la variable de contador en cada punto en el bucle.

143
00:08:47,000 --> 00:08:50,000
Una cosa común ver sólo hay i + +,

144
00:08:50,000 --> 00:08:52,000
lo que significa incrementar i en 1 cada vez.

145
00:08:52,000 --> 00:08:55,000
También se podría hacer algo como i + = 2,

146
00:08:55,000 --> 00:08:58,000
lo que significa añadir 2 a i cada vez que vaya a través del bucle.

147
00:08:58,000 --> 00:09:03,000
Y a continuación, el hacer esto sólo se refiere a cualquier código que realmente se ejecuta como parte del bucle.

148
00:09:03,000 --> 00:09:09,000
Y por un bucle while, esta vez en realidad tenemos la inicialización fuera del bucle,

149
00:09:09,000 --> 00:09:12,000
así por ejemplo, digamos que estamos tratando de hacer el mismo tipo de bucle, como acabo de describir.

150
00:09:12,000 --> 00:09:16,000
Diríamos int i = 0 antes del bucle comienza.

151
00:09:16,000 --> 00:09:20,000
Entonces podríamos decir que mientras i <10 hacer esto,

152
00:09:20,000 --> 00:09:22,000
por lo que el mismo bloque de código como antes,

153
00:09:22,000 --> 00:09:26,000
y esta vez la parte de actualización del código, por ejemplo, i + +,

154
00:09:26,000 --> 00:09:29,000
en realidad va dentro del bucle.

155
00:09:29,000 --> 00:09:33,000
Y por último, para hacer un rato, es similar al bucle while,

156
00:09:33,000 --> 00:09:36,000
pero tenemos que recordar que el código se evaluará una vez

157
00:09:36,000 --> 00:09:40,000
antes de que la condición se comprueba, por lo que tiene mucho más sentido

158
00:09:40,000 --> 00:09:44,000
si nos fijamos en ella con el fin de arriba a abajo.

159
00:09:44,000 --> 00:09:49,000
En una, do while evalúa el código, incluso antes de ver la condición mientras

160
00:09:49,000 --> 00:09:55,000
mientras que un bucle while, comprueba en primer lugar.

161
00:09:55,000 --> 00:09:59,000
Las declaraciones y variables.

162
00:09:59,000 --> 00:10:04,000
Cuando queremos crear una nueva variable que primero desea inicializar.

163
00:10:04,000 --> 00:10:07,000
>> Por ejemplo, la barra int inicializa la variable bar,

164
00:10:07,000 --> 00:10:10,000
pero no le da un valor, entonces ¿cuál es el valor de la barra ahora?

165
00:10:10,000 --> 00:10:12,000
No lo sé.

166
00:10:12,000 --> 00:10:14,000
Podría ser un valor basura que estaba previamente almacenado en la memoria allí,

167
00:10:14,000 --> 00:10:16,000
y no queremos usar esa variable

168
00:10:16,000 --> 00:10:19,000
hasta que realmente le dan un valor,

169
00:10:19,000 --> 00:10:21,000
así lo declaramos aquí.

170
00:10:21,000 --> 00:10:24,000
Luego inicializamos a ser 42.

171
00:10:24,000 --> 00:10:28,000
Ahora, por supuesto, sabemos que esto se puede hacer en una sola línea, bar int = 42.

172
00:10:28,000 --> 00:10:30,000
Pero para ser claros los múltiples pasos que se están produciendo,

173
00:10:30,000 --> 00:10:34,000
la declaración e inicialización están sucediendo aquí por separado.

174
00:10:34,000 --> 00:10:38,000
Esto ocurre en un solo paso, y el siguiente, int = bar baz + 1,

175
00:10:38,000 --> 00:10:44,000
esta declaración de abajo, que baz incrementos, por lo que al final de este bloque de código

176
00:10:44,000 --> 00:10:48,000
si tuviéramos que imprimir el valor de baz sería 44

177
00:10:48,000 --> 00:10:52,000
porque declarar e inicializar a ser de 1 bar>,

178
00:10:52,000 --> 00:10:58,000
y luego lo incrementa una vez más con el + +.

179
00:10:58,000 --> 00:11:02,000
Repasamos brevemente esta bonita, pero es bueno tener un general

180
00:11:02,000 --> 00:11:04,000
comprensión de lo que las discusiones y los eventos son.

181
00:11:04,000 --> 00:11:06,000
Principalmente nos hizo esto en Scratch,

182
00:11:06,000 --> 00:11:09,000
así que usted puede pensar en temas como varias secuencias de código

183
00:11:09,000 --> 00:11:11,000
ejecutando al mismo tiempo.

184
00:11:11,000 --> 00:11:14,000
En realidad, es probable que no se está ejecutando al mismo tiempo,

185
00:11:14,000 --> 00:11:17,000
sino una especie de forma abstracta, podemos pensar en él de esa manera.

186
00:11:17,000 --> 00:11:20,000
>> En Scratch, por ejemplo, tuvimos los sprites múltiples.

187
00:11:20,000 --> 00:11:22,000
Se podría ejecutar código diferente al mismo tiempo.

188
00:11:22,000 --> 00:11:26,000
Uno podía caminar mientras que el otro está diciendo algo

189
00:11:26,000 --> 00:11:29,000
en una parte diferente de la pantalla.

190
00:11:29,000 --> 00:11:34,000
Los eventos son otra manera de separar la lógica

191
00:11:34,000 --> 00:11:37,000
entre los diferentes elementos de su código,

192
00:11:37,000 --> 00:11:40,000
y en Scratch hemos sido capaces de simular los eventos utilizando la difusión,

193
00:11:40,000 --> 00:11:43,000
y que en realidad es cuando recibo, no cuando oigo,

194
00:11:43,000 --> 00:11:47,000
pero en esencia se trata de una forma de transmitir información

195
00:11:47,000 --> 00:11:49,000
de un sprite a otro.

196
00:11:49,000 --> 00:11:52,000
Por ejemplo, es posible que desee transmitir más de juego,

197
00:11:52,000 --> 00:11:56,000
y cuando otro duende recibe más de juego,

198
00:11:56,000 --> 00:11:58,000
que responde de una manera determinada.

199
00:11:58,000 --> 00:12:03,000
Es un modelo importante para entender la programación.

200
00:12:03,000 --> 00:12:07,000
Sólo para pasar la Semana básico 0, lo que hemos ido hasta ahora,

201
00:12:07,000 --> 00:12:10,000
echemos un vistazo a este programa C simple.

202
00:12:10,000 --> 00:12:14,000
El texto puede ser un poco más pequeña de aquí, pero voy a ir sobre ella muy rápido.

203
00:12:14,000 --> 00:12:20,000
Estamos incluyendo dos archivos de cabecera en la parte superior cs50.h y stdio.h.

204
00:12:20,000 --> 00:12:23,000
Estamos entonces definir un límite constante llamado a ser 100.

205
00:12:23,000 --> 00:12:26,000
Estamos entonces la implementación de nuestra función principal.

206
00:12:26,000 --> 00:12:29,000
Debido a que no utiliza argumentos de línea de comandos aquí tenemos que poner vacío

207
00:12:29,000 --> 00:12:32,000
como los argumentos a favor principal.

208
00:12:32,000 --> 00:12:38,000
Vemos int arriba principal. Ese es el tipo de retorno, por lo tanto, devolver 0 en la parte inferior.

209
00:12:38,000 --> 00:12:41,000
Y estamos usando la función de biblioteca CS50 conseguir int

210
00:12:41,000 --> 00:12:45,000
solicitar al usuario datos, y la almacenamos en esta variable x,

211
00:12:45,000 --> 00:12:51,000
por lo que declaramos x arriba, y lo inicializa con x = getInt.

212
00:12:51,000 --> 00:12:53,000
>> A continuación, comprobar para ver si el usuario nos dio buena entrada.

213
00:12:53,000 --> 00:12:59,000
Si se trata de LIMIT ≥ queremos devolver un código de error de 1 y mostrará un mensaje de error.

214
00:12:59,000 --> 00:13:02,000
Y, por último, si el usuario nos ha dado buenos aportes

215
00:13:02,000 --> 00:13:08,000
vamos a cuadrar el número e imprimir el resultado.

216
00:13:08,000 --> 00:13:11,000
Sólo para asegurarse de que todos los afectados casa

217
00:13:11,000 --> 00:13:17,000
se puede ver las etiquetas de diferentes partes del código aquí.

218
00:13:17,000 --> 00:13:19,000
Mencioné archivos constantes de cabecera.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Asegúrese de recordar que es una variable local.

220
00:13:21,000 --> 00:13:24,000
Esto contrasta de una variable global, lo que vamos a hablar de

221
00:13:24,000 --> 00:13:27,000
un poco más adelante en la sesión de revisión,

222
00:13:27,000 --> 00:13:30,000
y estamos llamando a la función de biblioteca printf,

223
00:13:30,000 --> 00:13:34,000
así que si no había incluido el archivo de cabecera stdio.h

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

225
00:13:37,000 --> 00:13:42,000
Y creo que la flecha que se cortó aquí está apuntando a la d%

226
00:13:42,000 --> 00:13:45,000
que es una cadena de formato de printf.

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

228
00:13:52,000 --> 00:13:58,000
Y que es la Semana de 0.

229
00:13:58,000 --> 00:14:06,000
Ahora Lucas va a continuar.

230
00:14:06,000 --> 00:14:08,000
Hey, chicos. Mi nombre es Lucas.

231
00:14:08,000 --> 00:14:10,000
Soy un estudiante de segundo año en la mejor casa en el campus, Mather,

232
00:14:10,000 --> 00:14:14,000
y voy a hablar un poco sobre la Semana 1 y 2,1.

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

234
00:14:16,000 --> 00:14:19,000
Como Lexi estaba diciendo, cuando empezamos a traducir el código desde cero en C

235
00:14:19,000 --> 00:14:23,000
una de las cosas que hemos notado es que se puede no sólo

236
00:14:23,000 --> 00:14:26,000
escribir el código y ejecutarlo con una bandera verde más.

237
00:14:26,000 --> 00:14:30,000
En realidad, usted tiene que utilizar algunos pasos para hacer su programa en C

238
00:14:30,000 --> 00:14:33,000
convertirse en un archivo ejecutable.

239
00:14:33,000 --> 00:14:36,000
Básicamente lo que haces cuando estás escribiendo un programa es que

240
00:14:36,000 --> 00:14:40,000
traducir su idea en un lenguaje que un compilador puede entender,

241
00:14:40,000 --> 00:14:44,000
así que cuando usted está escribiendo un programa en C

242
00:14:44,000 --> 00:14:47,000
lo que estás haciendo es escribir realmente algo que el compilador va a entender,

243
00:14:47,000 --> 00:14:50,000
y el compilador va a traducir ese código

244
00:14:50,000 --> 00:14:53,000
en algo que su equipo va a entender.

245
00:14:53,000 --> 00:14:55,000
>> Y la cosa es que el equipo es realmente muy tonto.

246
00:14:55,000 --> 00:14:57,000
El equipo sólo se puede entender 0s y 1s,

247
00:14:57,000 --> 00:15:01,000
lo que en realidad en los primeros ordenadores gente suele programarse

248
00:15:01,000 --> 00:15:04,000
con 0 y 1, pero ya no, gracias a Dios.

249
00:15:04,000 --> 00:15:07,000
No tenemos que memorizar las secuencias de 0s y 1s

250
00:15:07,000 --> 00:15:10,000
para un bucle o para un bucle while y así sucesivamente.

251
00:15:10,000 --> 00:15:13,000
Es por eso que tenemos un compilador.

252
00:15:13,000 --> 00:15:17,000
Lo que un compilador hace es que básicamente se traduce el código C,

253
00:15:17,000 --> 00:15:21,000
en nuestro caso, a un idioma que el equipo va a entender,

254
00:15:21,000 --> 00:15:25,000
que es el código objeto, y el compilador que estamos utilizando

255
00:15:25,000 --> 00:15:30,000
se llama sonido metálico, así que esto es realmente el símbolo de sonido metálico.

256
00:15:30,000 --> 00:15:33,000
Cuando usted tiene su programa, usted tiene que hacer 2 cosas.

257
00:15:33,000 --> 00:15:37,000
En primer lugar, usted tiene que compilar el programa, y ​​luego se va a ejecutar el programa.

258
00:15:37,000 --> 00:15:41,000
Para compilar el programa tiene un montón de opciones para hacerlo.

259
00:15:41,000 --> 00:15:44,000
La primera de ellas tiene que ver program.c clang

260
00:15:44,000 --> 00:15:47,000
en qué programa es el nombre del programa.

261
00:15:47,000 --> 00:15:51,000
En este caso se puede ver que están diciendo "Hey, compilar mi programa".

262
00:15:51,000 --> 00:15:56,000
Usted no está diciendo "Quiero que este nombre para mi programa", ni nada.

263
00:15:56,000 --> 00:15:58,000
>> La segunda opción es dar un nombre a su programa.

264
00:15:58,000 --> 00:16:02,000
Se puede decir clang-o y luego el nombre que desea

265
00:16:02,000 --> 00:16:06,000
el archivo ejecutable para ser nombrado como y, a continuación program.c.

266
00:16:06,000 --> 00:16:11,000
Y también se puede hacer hacer el programa, y ​​ver cómo en los primeros 2 casos

267
00:16:11,000 --> 00:16:15,000
Puse. C, y en el tercero sólo tengo programas?

268
00:16:15,000 --> 00:16:18,000
Sí, en realidad no debería poner. C cuando se utiliza hacer.

269
00:16:18,000 --> 00:16:22,000
De lo contrario el compilador es en realidad va a gritar a usted.

270
00:16:22,000 --> 00:16:24,000
Y también, no sé si ustedes recuerdan,

271
00:16:24,000 --> 00:16:29,000
pero muchas veces también usamos lcs50-o-lm.

272
00:16:29,000 --> 00:16:31,000
Eso se llama enlace.

273
00:16:31,000 --> 00:16:35,000
Simplemente le dice al compilador que va a utilizar las bibliotecas allí mismo,

274
00:16:35,000 --> 00:16:39,000
así que si usted desea utilizar cs50.h que realmente tiene que escribir

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

276
00:16:43,000 --> 00:16:45,000
Si no lo hace, el compilador no va a saber

277
00:16:45,000 --> 00:16:50,000
que está utilizando estas funciones en cs50.h.

278
00:16:50,000 --> 00:16:52,000
Y cuando se quiere ejecutar el programa tiene 2 opciones.

279
00:16:52,000 --> 00:16:57,000
Si usted hizo program.c clang usted no dio un nombre a su programa.

280
00:16:57,000 --> 00:17:01,000
Usted tiene que ejecutar con. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out es un nombre estándar que le da a su sonido metálico programa si no le damos un nombre.

282
00:17:06,000 --> 00:17:11,000
De lo contrario, vamos a hacer. / Programa si usted le dio un nombre a su programa,

283
00:17:11,000 --> 00:17:15,000
y también si lo has hecho hacer el programa el nombre de un programa que se va a poner

284
00:17:15,000 --> 00:17:23,000
ya va a ser programado con el mismo nombre que el archivo c.

285
00:17:23,000 --> 00:17:26,000
Luego hablamos de tipos de datos y los datos.

286
00:17:26,000 --> 00:17:31,000
>> Básicamente los tipos de datos son la misma cosa como pequeñas cajas que utilizan

287
00:17:31,000 --> 00:17:35,000
para almacenar los valores, por lo que los tipos de datos son en realidad como Pokémons.

288
00:17:35,000 --> 00:17:39,000
Vienen en todos los tamaños y tipos.

289
00:17:39,000 --> 00:17:43,000
No sé si esa analogía tiene sentido.

290
00:17:43,000 --> 00:17:46,000
El tamaño de los datos depende en realidad de la arquitectura de la máquina.

291
00:17:46,000 --> 00:17:49,000
Todos los tamaños de datos que voy a mostrar aquí

292
00:17:49,000 --> 00:17:53,000
son en realidad para una máquina de 32-bit, que es el caso de nuestro aparato,

293
00:17:53,000 --> 00:17:56,000
pero si usted está realmente codificación de su Mac o en Windows también

294
00:17:56,000 --> 00:17:59,000
Probablemente usted va a tener un equipo de 64 bits,

295
00:17:59,000 --> 00:18:03,000
así que recuerde que los tamaños de los datos que voy a mostrar aquí

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

297
00:18:06,000 --> 00:18:08,000
El primero que vimos fue un int,

298
00:18:08,000 --> 00:18:10,000
que es bastante sencillo.

299
00:18:10,000 --> 00:18:13,000
Utilice int para almacenar un entero.

300
00:18:13,000 --> 00:18:16,000
También vimos el carácter, el char.

301
00:18:16,000 --> 00:18:20,000
Si desea utilizar una letra o un símbolo poco usted está probablemente va a utilizar un char.

302
00:18:20,000 --> 00:18:26,000
Un char tiene 1 byte, es decir 8 bits, como dijo Lexi.

303
00:18:26,000 --> 00:18:31,000
Básicamente tenemos una tabla ASCII que tiene 256

304
00:18:31,000 --> 00:18:34,000
las posibles combinaciones de 0s y 1s,

305
00:18:34,000 --> 00:18:37,000
y luego, cuando se escribe una charla va a traducir

306
00:18:37,000 --> 00:18:44,000
el carácter que las entradas que un número que tiene en la tabla ASCII, como dijo Lexi.

307
00:18:44,000 --> 00:18:48,000
También tenemos el flotador, que utilizamos para almacenar números decimales.

308
00:18:48,000 --> 00:18:53,000
Si usted quiere elegir 3.14, por ejemplo, usted va a utilizar un flotador

309
00:18:53,000 --> 00:18:55,000
o un doble que tiene más precisión.

310
00:18:55,000 --> 00:18:57,000
Un flotador tiene 4 bytes.

311
00:18:57,000 --> 00:19:01,000
Un doble tiene 8 bytes, por lo que la única diferencia es la precisión.

312
00:19:01,000 --> 00:19:04,000
También tenemos un largo que se utiliza para los números enteros,

313
00:19:04,000 --> 00:19:09,000
y se puede ver una máquina de 32-bit un int y un largo tienen el mismo tamaño,

314
00:19:09,000 --> 00:19:13,000
por lo que en realidad no tiene sentido utilizar un largo en una máquina de 32-bit.

315
00:19:13,000 --> 00:19:17,000
>> Pero si usted está usando un Mac y de 64 bits, en realidad una larga tiene un tamaño de 8,

316
00:19:17,000 --> 00:19:19,000
así que realmente depende de la arquitectura.

317
00:19:19,000 --> 00:19:22,000
Para que la máquina 32-bit no tiene sentido usar un largo realidad.

318
00:19:22,000 --> 00:19:25,000
Y luego un largo tiempo, por otro lado, tiene 8 bytes,

319
00:19:25,000 --> 00:19:30,000
por lo que es muy bueno si usted quiere tener un entero largo.

320
00:19:30,000 --> 00:19:34,000
Y por último, tenemos cadena, que es en realidad un char *,

321
00:19:34,000 --> 00:19:37,000
que es un puntero a un char.

322
00:19:37,000 --> 00:19:40,000
Es muy fácil pensar que el tamaño de la cadena va a ser como

323
00:19:40,000 --> 00:19:42,000
el número de caracteres que tiene allí,

324
00:19:42,000 --> 00:19:45,000
pero en realidad el propio char *

325
00:19:45,000 --> 00:19:49,000
tiene el tamaño de un puntero a un char, que es 4 bytes.

326
00:19:49,000 --> 00:19:52,000
El tamaño de un char * es de 4 bytes.

327
00:19:52,000 --> 00:19:56,000
No importa si usted tiene una pequeña palabra o una letra o nada.

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

329
00:19:58,000 --> 00:20:01,000
También hemos aprendido un poco acerca de casting,

330
00:20:01,000 --> 00:20:04,000
Así como usted puede ver, si usted tiene, por ejemplo, un programa que dice:

331
00:20:04,000 --> 00:20:08,000
int x = 3 y luego printf ("% d", x / 2)

332
00:20:08,000 --> 00:20:12,000
¿Ustedes saben lo que va a imprimir en la pantalla?

333
00:20:12,000 --> 00:20:14,000
>> ¿Alguien? >> [Los estudiantes] 2.

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

335
00:20:16,000 --> 00:20:20,000
Al hacer 3/2 que va a obtener 1,5,

336
00:20:20,000 --> 00:20:24,000
pero ya que estamos usando un número entero que va a hacer caso omiso de la parte decimal,

337
00:20:24,000 --> 00:20:26,000
y vas a tener 1.

338
00:20:26,000 --> 00:20:29,000
Si usted no quiere que eso suceda lo que puede hacer, por ejemplo,

339
00:20:29,000 --> 00:20:33,000
Se declara un flotador y = x.

340
00:20:33,000 --> 00:20:40,000
Entonces x que antes eran 3 ahora va a ser 3,000 en y.

341
00:20:40,000 --> 00:20:44,000
Y entonces usted puede imprimir el a / 2.

342
00:20:44,000 --> 00:20:50,000
En realidad, yo debería tener un 2. por allí.

343
00:20:50,000 --> 00:20:55,000
Va a hacer 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
y vas a obtener 1,5.

345
00:20:58,000 --> 00:21:06,000
Y nosotros tenemos este f 0.2 sólo para pedir 2 unidades decimales de la parte decimal.

346
00:21:06,000 --> 00:21:12,000
Si tiene .3 f que va a tener realmente 1.500.

347
00:21:12,000 --> 00:21:16,000
Si se trata de dos que va a ser 1,50.

348
00:21:16,000 --> 00:21:18,000
También tenemos este caso.

349
00:21:18,000 --> 00:21:22,000
Si lo hace float x = 3,14 x y entonces usted printf

350
00:21:22,000 --> 00:21:24,000
usted va a obtener 3,14.

351
00:21:24,000 --> 00:21:29,000
Y si lo hace x = int x,

352
00:21:29,000 --> 00:21:34,000
lo que significa tratar a x como un entero y se imprime x ahora

353
00:21:34,000 --> 00:21:36,000
usted va a tener 3,00.

354
00:21:36,000 --> 00:21:38,000
¿Eso tiene sentido?

355
00:21:38,000 --> 00:21:41,000
Debido a que usted está tratando primeramente x como un entero, por lo que está haciendo caso omiso de la parte decimal,

356
00:21:41,000 --> 00:21:45,000
y luego imprime x.

357
00:21:45,000 --> 00:21:47,000
Y, por último, también se puede hacer esto,

358
00:21:47,000 --> 00:21:52,000
int x = 65, y entonces se declara un char c = x,

359
00:21:52,000 --> 00:21:56,000
y luego, si se imprime el c estás realmente va a conseguir

360
00:21:56,000 --> 00:21:59,000
A, así que básicamente lo que estás haciendo aquí

361
00:21:59,000 --> 00:22:02,000
está traduciendo el entero en el carácter,

362
00:22:02,000 --> 00:22:05,000
al igual que la tabla ASCII hace.

363
00:22:05,000 --> 00:22:08,000
También hablamos de los operadores matemáticos.

364
00:22:08,000 --> 00:22:14,000
La mayoría de ellos son bastante sencillos, por lo que +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
y también hablamos de mod, que es el resto de una división de dos números.

366
00:22:20,000 --> 00:22:23,000
Si tiene 10% 3, por ejemplo,

367
00:22:23,000 --> 00:22:27,000
que significa dividir 10 por 3, y lo que es el resto?

368
00:22:27,000 --> 00:22:30,000
Va a ser 1, por lo que es realmente muy útil para muchos de los programas.

369
00:22:30,000 --> 00:22:38,000
Para Vigenère y César estoy bastante seguro de que todos ustedes utilizan mod.

370
00:22:38,000 --> 00:22:43,000
Operadores matemáticos, tenga mucho cuidado al combinar * y /.

371
00:22:43,000 --> 00:22:48,000
>> Por ejemplo, si usted hace (3/2) * 2 ¿Qué vas a conseguir?

372
00:22:48,000 --> 00:22:50,000
[Los estudiantes] 2.

373
00:22:50,000 --> 00:22:54,000
Sí, 2, porque 3/2 va a ser 1,5,

374
00:22:54,000 --> 00:22:57,000
pero ya que estamos haciendo operaciones entre dos números enteros

375
00:22:57,000 --> 00:22:59,000
en realidad estás sólo va a tener en cuenta 1,

376
00:22:59,000 --> 00:23:03,000
y luego 1 * 2 va a ser de 2, así que ten mucho cuidado

377
00:23:03,000 --> 00:23:07,000
al hacer aritmética con números enteros porque

378
00:23:07,000 --> 00:23:12,000
usted puede ser que consiga que 2 = 3, en ese caso.

379
00:23:12,000 --> 00:23:14,000
Y también tener mucho cuidado con prioridad.

380
00:23:14,000 --> 00:23:21,000
Generalmente, usted debe usar paréntesis para estar seguro de que usted sabe lo que está haciendo.

381
00:23:21,000 --> 00:23:27,000
Algunos atajos útiles, por supuesto, se trata de i + + o i + = 1

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

383
00:23:30,000 --> 00:23:34,000
Esto es lo mismo que hacer i = i + 1.

384
00:23:34,000 --> 00:23:39,000
También puedo hacer - o i - = 1,

385
00:23:39,000 --> 00:23:42,000
que es lo mismo que i = i -1,

386
00:23:42,000 --> 00:23:46,000
algo que ustedes usar en los bucles for, al menos.

387
00:23:46,000 --> 00:23:52,000
Además, para *, si utiliza * = y si lo hace, por ejemplo,

388
00:23:52,000 --> 00:23:57,000
i * = 2 es lo mismo que decir i = i * 2,

389
00:23:57,000 --> 00:23:59,000
y lo mismo para la división.

390
00:23:59,000 --> 00:24:08,000
Si lo hace i / = 2 es lo mismo que i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Ahora, acerca de las funciones.

392
00:24:10,000 --> 00:24:13,000
Ustedes aprendieron que las funciones son una estrategia muy buena para guardar el código

393
00:24:13,000 --> 00:24:16,000
mientras que usted está programando, así que si usted desea llevar a cabo la misma tarea

394
00:24:16,000 --> 00:24:20,000
en el código una y otra vez, probablemente desee utilizar una función

395
00:24:20,000 --> 00:24:25,000
sólo para que usted no tiene que copiar y pegar el código una y otra vez.

396
00:24:25,000 --> 00:24:28,000
En realidad, la principal es una función, y cuando te muestran el formato de una función

397
00:24:28,000 --> 00:24:32,000
vas a ver que eso es bastante obvio.

398
00:24:32,000 --> 00:24:35,000
También utilizamos las funciones de algunas bibliotecas,

399
00:24:35,000 --> 00:24:39,000
por ejemplo, printf, Getin, que es de la biblioteca CS50,

400
00:24:39,000 --> 00:24:43,000
y otras funciones como toupper.

401
00:24:43,000 --> 00:24:46,000
Todas estas funciones se llevan a la práctica otras bibliotecas,

402
00:24:46,000 --> 00:24:49,000
y cuando se pone los archivos de sujeción al principio de su programa

403
00:24:49,000 --> 00:24:53,000
que dices puede darme el código para las funciones

404
00:24:53,000 --> 00:24:57,000
así que no tienes que ponerlas en práctica por mí mismo?

405
00:24:57,000 --> 00:25:00,000
Y usted también puede escribir sus propias funciones, por lo que al iniciar la programación

406
00:25:00,000 --> 00:25:04,000
te das cuenta de que las bibliotecas no tienen todas las funciones que usted necesita.

407
00:25:04,000 --> 00:25:10,000
Para el conjunto de procesadores pasado, por ejemplo, escribimos dibujar, lucha y búsqueda,

408
00:25:10,000 --> 00:25:13,000
y es muy, muy importante ser capaz de escribir funciones

409
00:25:13,000 --> 00:25:17,000
porque son útiles, y los usamos todo el tiempo en la programación,

410
00:25:17,000 --> 00:25:19,000
y se ahorra una gran cantidad de código.

411
00:25:19,000 --> 00:25:21,000
El formato de una función es éste.

412
00:25:21,000 --> 00:25:24,000
Contamos con tipo de retorno al principio. ¿Cuál es el tipo de cambio?

413
00:25:24,000 --> 00:25:27,000
Es sólo cuando su función se va a devolver.

414
00:25:27,000 --> 00:25:29,000
Si dispone de una función, por ejemplo, factorial,

415
00:25:29,000 --> 00:25:31,000
que se va a calcular un factorial de un número entero,

416
00:25:31,000 --> 00:25:34,000
es probable que lo va a devolver un entero también.

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

418
00:25:37,000 --> 00:25:41,000
Printf en realidad tiene un tipo de retorno void

419
00:25:41,000 --> 00:25:43,000
porque no se está volviendo algo.

420
00:25:43,000 --> 00:25:45,000
No eres más que la impresión de las cosas a la pantalla

421
00:25:45,000 --> 00:25:48,000
y salida de la función después.

422
00:25:48,000 --> 00:25:51,000
Entonces usted tiene el nombre de la función que usted puede elegir.

423
00:25:51,000 --> 00:25:55,000
Usted debe ser un poco razonable, al igual que no elige un nombre como xyz

424
00:25:55,000 --> 00:25:58,000
o como x2F.

425
00:25:58,000 --> 00:26:02,000
Trate de hacer un nombre que tenga sentido.

426
00:26:02,000 --> 00:26:04,000
>> Por ejemplo, si es factorial, digamos factorial.

427
00:26:04,000 --> 00:26:08,000
Si se trata de una función que se va a dibujar algo, el nombre de dibujar.

428
00:26:08,000 --> 00:26:11,000
Y luego tenemos a los parámetros, que también se llaman argumentos,

429
00:26:11,000 --> 00:26:14,000
que son como los recursos que necesita su función

430
00:26:14,000 --> 00:26:17,000
a partir de su código para realizar su tarea.

431
00:26:17,000 --> 00:26:20,000
Si desea calcular el factorial de un número

432
00:26:20,000 --> 00:26:23,000
Probablemente es necesario tener un número para calcular un factorial.

433
00:26:23,000 --> 00:26:27,000
Uno de los argumentos que vamos a tener es el propio número.

434
00:26:27,000 --> 00:26:31,000
Y luego se va a hacer algo y devolver el valor al final

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

436
00:26:35,000 --> 00:26:37,000
Veamos un ejemplo.

437
00:26:37,000 --> 00:26:40,000
Si quiero escribir una función que sume todos los números en una matriz de enteros,

438
00:26:40,000 --> 00:26:43,000
en primer lugar, el tipo de retorno va a ser int

439
00:26:43,000 --> 00:26:46,000
porque tengo una matriz de enteros.

440
00:26:46,000 --> 00:26:51,000
Y entonces me voy a tener el nombre de la función como sumArray,

441
00:26:51,000 --> 00:26:54,000
y entonces va a tener el mismo array, int nums a,

442
00:26:54,000 --> 00:26:58,000
y entonces la longitud de la matriz, así que sé la cantidad de números que hay que sumar.

443
00:26:58,000 --> 00:27:02,000
Entonces tiene que inicializar una variable llamada suma, por ejemplo, a 0,

444
00:27:02,000 --> 00:27:08,000
y cada vez que veo a un elemento de la matriz que debería añadir a la suma, así que hice un bucle for.

445
00:27:08,000 --> 00:27:15,000
Como dijo Lexi, ¿verdad int i = 0, i longitud <y + + i.

446
00:27:15,000 --> 00:27:20,000
Y por cada elemento de la matriz que hice suma + = nums [i],

447
00:27:20,000 --> 00:27:24,000
y luego me devolvió la suma, por lo que es muy simple, y se ahorra una gran cantidad de código

448
00:27:24,000 --> 00:27:28,000
si usted está utilizando esta función un montón de veces.

449
00:27:28,000 --> 00:27:32,000
A continuación, echamos un vistazo a las condiciones.

450
00:27:32,000 --> 00:27:38,000
Tenemos if, else, y si otra cosa.

451
00:27:38,000 --> 00:27:42,000
Vamos a ver cuál es la diferencia entre ellos.

452
00:27:42,000 --> 00:27:45,000
Echa un vistazo a estos 2 códigos. ¿Cuál es la diferencia entre ellos?

453
00:27:45,000 --> 00:27:49,000
El primero ha-básicamente los códigos que le digas a

454
00:27:49,000 --> 00:27:51,000
si un número es +, -, o 0.

455
00:27:51,000 --> 00:27:55,000
La primera de ellas dice que si es> 0, entonces es positivo.

456
00:27:55,000 --> 00:28:00,000
Si es = a 0, entonces es 0, y si es <0, entonces es negativo.

457
00:28:00,000 --> 00:28:04,000
>> Y el otro está haciendo si, else if, else.

458
00:28:04,000 --> 00:28:07,000
La diferencia entre los dos es que éste es en realidad va a

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

460
00:28:13,000 --> 00:28:17,000
así que si usted tiene el número 2, por ejemplo, va a venir aquí y decir

461
00:28:17,000 --> 00:28:21,000
if (x> 0), y que va a decir que sí, así que imprimir positivo.

462
00:28:21,000 --> 00:28:25,000
Pero aunque sé que es> 0 y que no va a ser 0 o <0

463
00:28:25,000 --> 00:28:29,000
Todavía voy a hacer es 0, es <0,

464
00:28:29,000 --> 00:28:33,000
así que estoy realmente va dentro de IFS que yo no tenía que

465
00:28:33,000 --> 00:28:38,000
porque ya sabemos que no va a satisfacer alguna de estas condiciones.

466
00:28:38,000 --> 00:28:41,000
Puedo usar el if, else if, else declaración.

467
00:28:41,000 --> 00:28:45,000
Básicamente dice que si x = 0 imprimo lo positivo.

468
00:28:45,000 --> 00:28:48,000
Si no es así, voy a probar esto también.

469
00:28:48,000 --> 00:28:51,000
Si es 2, no voy a hacer esto.

470
00:28:51,000 --> 00:28:54,000
Básicamente si tuviera x = 2 le diría

471
00:28:54,000 --> 00:28:57,000
if (x> 0), sí, así que imprimir esto.

472
00:28:57,000 --> 00:29:00,000
Ahora que sé que es> 0 y que satisface la primera, si

473
00:29:00,000 --> 00:29:02,000
Yo ni siquiera voy a ejecutar este código.

474
00:29:02,000 --> 00:29:09,000
El código se ejecuta más rápido, en realidad, tres veces más rápido si los usas.

475
00:29:09,000 --> 00:29:11,000
También aprendimos sobre AND y OR.

476
00:29:11,000 --> 00:29:15,000
No voy a pasar por esto porque Lexi ya hablaba de ellos.

477
00:29:15,000 --> 00:29:17,000
Es sólo el && y | operador |.

478
00:29:17,000 --> 00:29:21,000
>> Lo único que voy a decir es tener cuidado cuando usted tiene 3 condiciones.

479
00:29:21,000 --> 00:29:24,000
Utilice paréntesis porque es muy confuso cuando usted tiene una condición

480
00:29:24,000 --> 00:29:27,000
y otro o uno al otro.

481
00:29:27,000 --> 00:29:30,000
Utilice paréntesis para estar seguro de que sus condiciones de tener sentido

482
00:29:30,000 --> 00:29:34,000
porque en ese caso, por ejemplo, se puede imaginar que

483
00:29:34,000 --> 00:29:38,000
podría ser la primera condición y una o la otra

484
00:29:38,000 --> 00:29:41,000
o las dos condiciones combinadas en una y

485
00:29:41,000 --> 00:29:45,000
o el tercero, así que ten cuidado.

486
00:29:45,000 --> 00:29:48,000
Y por último, hemos hablado acerca de los modificadores.

487
00:29:48,000 --> 00:29:53,000
Un interruptor es muy útil cuando se tiene una variable.

488
00:29:53,000 --> 00:29:55,000
Digamos que usted tiene una variable como n

489
00:29:55,000 --> 00:29:59,000
que puede ser 0, 1, o 2, y para cada uno de los casos

490
00:29:59,000 --> 00:30:01,000
usted va a realizar una tarea.

491
00:30:01,000 --> 00:30:04,000
Se puede decir cambiar la variable, e indica que

492
00:30:04,000 --> 00:30:08,000
entonces el valor de valor1 es como voy a hacer esto,

493
00:30:08,000 --> 00:30:12,000
y luego rompo, lo que significa que no voy a mirar en cualquiera de los otros casos

494
00:30:12,000 --> 00:30:15,000
porque ya convencido de que el caso

495
00:30:15,000 --> 00:30:20,000
y luego valor2 y así sucesivamente, y también puede tener un interruptor predeterminado.

496
00:30:20,000 --> 00:30:24,000
Eso significa que si no satisface cualquiera de los casos que he tenido

497
00:30:24,000 --> 00:30:29,000
que voy a hacer otra cosa, pero eso es opcional.

498
00:30:29,000 --> 00:30:36,000
Eso es todo para mí. Ahora vamos a Tommy.

499
00:30:36,000 --> 00:30:41,000
Muy bien, esto va a ser la semana 3-ish.

500
00:30:41,000 --> 00:30:45,000
Estos son algunos de los temas que trataremos, crypto, alcance, matrices, etc.

501
00:30:45,000 --> 00:30:49,000
Sólo un breve comentario sobre criptografía. No vamos a recalcar este.

502
00:30:49,000 --> 00:30:52,000
>> Lo hicimos en conjunto de procesadores 2, pero para la prueba asegúrate de saber la diferencia

503
00:30:52,000 --> 00:30:54,000
entre el cifrado César y el cifrado Vigenère,

504
00:30:54,000 --> 00:30:57,000
cómo ambos funcionan esas cifras y lo que es para cifrar

505
00:30:57,000 --> 00:30:59,000
y descifrar el texto usando esos 2 cifras.

506
00:30:59,000 --> 00:31:03,000
Recuerde, el cifrado César simplemente rota cada personaje en la misma cantidad,

507
00:31:03,000 --> 00:31:06,000
asegurándose de mod por el número de letras en el alfabeto.

508
00:31:06,000 --> 00:31:09,000
Y el cifrado de Vigenère, por otro lado, hace girar cada carácter

509
00:31:09,000 --> 00:31:12,000
por un monto diferente, así que en lugar de decir

510
00:31:12,000 --> 00:31:15,000
cada personaje gira por 3 Vigenère rotará cada personaje

511
00:31:15,000 --> 00:31:17,000
por una cantidad diferente dependiendo de alguna palabra clave

512
00:31:17,000 --> 00:31:20,000
donde cada letra de la palabra clave representa una cierta cantidad diferente

513
00:31:20,000 --> 00:31:26,000
para girar el texto claro.

514
00:31:26,000 --> 00:31:28,000
Vamos a hablar primero de alcance variable.

515
00:31:28,000 --> 00:31:30,000
Hay 2 tipos diferentes de variables.

516
00:31:30,000 --> 00:31:33,000
Tenemos las variables locales, y estos van a ser definidos

517
00:31:33,000 --> 00:31:36,000
fuera de principal o fuera de cualquier función o bloque,

518
00:31:36,000 --> 00:31:39,000
y estos serán accesibles en cualquier parte de su programa.

519
00:31:39,000 --> 00:31:41,000
Si usted tiene una función y que en función de un bucle while

520
00:31:41,000 --> 00:31:44,000
la variable global grande es accesible en todas partes.

521
00:31:44,000 --> 00:31:48,000
Una variable local, por otra parte, tiene como alcance el lugar en el que está definida.

522
00:31:48,000 --> 00:31:53,000
>> Si usted tiene una función aquí, por ejemplo, tenemos esta función g,

523
00:31:53,000 --> 00:31:56,000
y en el interior de g no es una variable llamada aquí y,

524
00:31:56,000 --> 00:31:58,000
y eso significa que se trata de una variable local.

525
00:31:58,000 --> 00:32:00,000
A pesar de que esta variable se llama y

526
00:32:00,000 --> 00:32:03,000
y esta variable se denomina Y Estas 2 funciones

527
00:32:03,000 --> 00:32:06,000
no tienen idea de lo que los demás son variables locales.

528
00:32:06,000 --> 00:32:10,000
Por otra parte, aquí se dice int x = 5,

529
00:32:10,000 --> 00:32:12,000
y esto está fuera del alcance de cualquier función.

530
00:32:12,000 --> 00:32:16,000
Está fuera del alcance de la principal, por lo que esta es una variable global.

531
00:32:16,000 --> 00:32:20,000
Eso significa que dentro de estas 2 funciones cuando digo x - x + + o

532
00:32:20,000 --> 00:32:26,000
Estoy accediendo a la misma por lo que este x y y esto son variables diferentes.

533
00:32:26,000 --> 00:32:30,000
Esa es la diferencia entre una variable global y una variable local.

534
00:32:30,000 --> 00:32:33,000
En lo que a diseño se refiere, a veces es probablemente una mejor idea

535
00:32:33,000 --> 00:32:37,000
para mantener las variables locales siempre que sea posible

536
00:32:37,000 --> 00:32:39,000
ya que tener un montón de variables globales se puede volver muy confuso.

537
00:32:39,000 --> 00:32:42,000
Si usted tiene un montón de funciones modificando todo la misma cosa

538
00:32:42,000 --> 00:32:45,000
es posible que olvide lo que si esta función accidentalmente modifica este mundial,

539
00:32:45,000 --> 00:32:47,000
y esta otra función que no sabe nada de ella,

540
00:32:47,000 --> 00:32:50,000
y que se pone bastante confuso a medida que más código.

541
00:32:50,000 --> 00:32:53,000
Mantener las variables locales siempre que sea posible

542
00:32:53,000 --> 00:32:56,000
es sólo un buen diseño.

543
00:32:56,000 --> 00:33:00,000
Arrays, recordemos, son simplemente listas de elementos del mismo tipo.

544
00:33:00,000 --> 00:33:04,000
Dentro de CI no se puede tener una lista como 1, 2,0, hola.

545
00:33:04,000 --> 00:33:06,000
No podemos hacer eso.

546
00:33:06,000 --> 00:33:11,000
>> Cuando se declara una matriz C en todos los elementos tienen que ser del mismo tipo.

547
00:33:11,000 --> 00:33:14,000
Aquí tengo una matriz de 3 enteros.

548
00:33:14,000 --> 00:33:18,000
Aquí tengo la longitud de la matriz, pero si yo sólo lo estoy declarando en esta sintaxis

549
00:33:18,000 --> 00:33:21,000
donde puedo especificar lo que todos los elementos son técnicamente yo no necesito esto 3.

550
00:33:21,000 --> 00:33:25,000
El compilador es suficientemente inteligente como para saber el tamaño de la matriz debe ser.

551
00:33:25,000 --> 00:33:28,000
Ahora cuando quiero obtener o establecer el valor de una matriz

552
00:33:28,000 --> 00:33:30,000
esta es la sintaxis para hacerlo.

553
00:33:30,000 --> 00:33:33,000
En realidad, esto modificará el segundo elemento de la matriz porque, recordar,

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

555
00:33:36,000 --> 00:33:42,000
Si quiero leer ese valor lo que puedo decir algo como int x = array [1].

556
00:33:42,000 --> 00:33:44,000
O si desea establecer ese valor, como que estoy haciendo aquí,

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

558
00:33:47,000 --> 00:33:50,000
Que el tiempo para acceder a los elementos por su índice

559
00:33:50,000 --> 00:33:52,000
o su posición o donde están en la matriz,

560
00:33:52,000 --> 00:33:57,000
y que la lista comienza en 0.

561
00:33:57,000 --> 00:34:00,000
También podemos tener matrices de matrices,

562
00:34:00,000 --> 00:34:03,000
y esto se llama una matriz multi-dimensional.

563
00:34:03,000 --> 00:34:05,000
Cuando tenemos una matriz multi-dimensional

564
00:34:05,000 --> 00:34:07,000
eso significa que podemos tener algo como filas y columnas,

565
00:34:07,000 --> 00:34:11,000
y esto es sólo una forma de visualizar esto o pensar en ello.

566
00:34:11,000 --> 00:34:14,000
Cuando tengo una matriz multi-dimensional que significa que voy a empezar a necesitar

567
00:34:14,000 --> 00:34:17,000
más de un índice porque si tengo una red

568
00:34:17,000 --> 00:34:19,000
Sólo digo lo que está en la fila no nos da un número.

569
00:34:19,000 --> 00:34:22,000
Eso es realmente sólo nos va a dar una lista de números.

570
00:34:22,000 --> 00:34:25,000
Digamos que tengo esta serie aquí.

571
00:34:25,000 --> 00:34:30,000
Tengo una matriz llamada cuadrícula, y yo estoy diciendo que es 2 filas y 3 columnas,

572
00:34:30,000 --> 00:34:32,000
por lo que esta es una forma de visualizarlo.

573
00:34:32,000 --> 00:34:37,000
Cuando digo que quiero obtener el elemento en [1] [2]

574
00:34:37,000 --> 00:34:41,000
que significa que debido a que estas son las filas primera y luego columnas

575
00:34:41,000 --> 00:34:44,000
Voy a saltar a la fila 1 ya he dicho 1.

576
00:34:44,000 --> 00:34:49,000
>> Entonces me voy a venir aquí a la columna 2, y voy a obtener el valor 6.

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

578
00:34:51,000 --> 00:34:55,000
Multi-dimensionales, recordemos, son técnicamente sólo un conjunto de matrices.

579
00:34:55,000 --> 00:34:57,000
Podemos tener arrays de arrays de arrays.

580
00:34:57,000 --> 00:35:00,000
Podemos seguir adelante, pero en realidad una forma de pensar

581
00:35:00,000 --> 00:35:03,000
cómo se está expuesto y lo que pasa es visualizarlo

582
00:35:03,000 --> 00:35:09,000
en una red como ésta.

583
00:35:09,000 --> 00:35:12,000
Al pasar matrices a funciones, que van a comportarse

584
00:35:12,000 --> 00:35:16,000
un poco diferente que cuando pasamos variables regulares a las funciones

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

586
00:35:18,000 --> 00:35:21,000
Cuando pasamos en un tipo int o char o cualquiera de estos otros datos

587
00:35:21,000 --> 00:35:24,000
nos lo tomamos un vistazo a si la función modifica

588
00:35:24,000 --> 00:35:28,000
el valor de dicha variable de que el cambio no se va a propagar hasta

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

590
00:35:32,000 --> 00:35:35,000
Con una matriz, por otro lado, que va a pasar.

591
00:35:35,000 --> 00:35:39,000
Si paso en una matriz a una función y que la función cambia algunos de los elementos,

592
00:35:39,000 --> 00:35:43,000
cuando vuelva a la función que se llama

593
00:35:43,000 --> 00:35:47,000
mi matriz ahora va a ser diferente, y el vocabulario para que

594
00:35:47,000 --> 00:35:50,000
es arrays se pasan por referencia, como veremos más adelante.

595
00:35:50,000 --> 00:35:53,000
Esto se relaciona con cómo funcionan los punteros, donde estos tipos de datos básicos,

596
00:35:53,000 --> 00:35:55,000
Por otra parte, se pasan por valor.

597
00:35:55,000 --> 00:35:59,000
>> Podemos pensar que a medida que se hace una copia de una variable y luego pasar en la copia.

598
00:35:59,000 --> 00:36:01,000
No importa lo que hagamos con esa variable.

599
00:36:01,000 --> 00:36:06,000
La función de llamada no se dará cuenta de que se ha cambiado.

600
00:36:06,000 --> 00:36:10,000
Las matrices son un poco diferentes en ese sentido.

601
00:36:10,000 --> 00:36:13,000
Por ejemplo, como acabamos de ver, la principal es simplemente una función

602
00:36:13,000 --> 00:36:15,000
que puede tomar en dos argumentos.

603
00:36:15,000 --> 00:36:20,000
El primer argumento de la función principal es argc, o el número de argumentos,

604
00:36:20,000 --> 00:36:23,000
y el segundo argumento se llama argv,

605
00:36:23,000 --> 00:36:27,000
y esos son los valores reales de esos argumentos.

606
00:36:27,000 --> 00:36:30,000
Digamos que tienen un programa llamado this.c,

607
00:36:30,000 --> 00:36:34,000
y yo digo que esto, y voy a correr esto en la línea de comandos.

608
00:36:34,000 --> 00:36:38,000
Ahora, para pasar algunos argumentos para mi programa que se llama esto,

609
00:36:38,000 --> 00:36:42,000
Podría decir algo así como. / Esto es cs 50.

610
00:36:42,000 --> 00:36:45,000
Esto es lo que nos imaginamos a David a hacer todos los días a la terminal.

611
00:36:45,000 --> 00:36:48,000
Pero ahora la función principal dentro de ese programa

612
00:36:48,000 --> 00:36:52,000
tiene estos valores, por lo que argc es 4.

613
00:36:52,000 --> 00:36:56,000
Puede ser un poco confuso porque en realidad sólo estamos pasando es cs 50.

614
00:36:56,000 --> 00:36:58,000
Eso es sólo 3.

615
00:36:58,000 --> 00:37:02,000
Pero recuerda que el primer elemento de argv o el primer argumento

616
00:37:02,000 --> 00:37:05,000
es el nombre de la función en sí.

617
00:37:05,000 --> 00:37:07,190
Así que eso significa que hay 4 cosas aquí,

618
00:37:07,190 --> 00:37:10,530
y el primer elemento va a ser. / este.

619
00:37:10,530 --> 00:37:12,970
Y esto se representa como una cadena.

620
00:37:12,970 --> 00:37:18,590
A continuación, los elementos restantes son lo que escribió en el después del nombre del programa.

621
00:37:18,590 --> 00:37:22,720
Así que, en un aparte, ya que es probable que vi en pset 2,

622
00:37:22,720 --> 00:37:28,780
recordar que la cadena 50 es el número entero ≠ 50.

623
00:37:28,780 --> 00:37:32,520
Así que no podemos decir algo como, 'int x = argv 3.

624
00:37:32,520 --> 00:37:36,470
>> Eso no va a tener sentido, porque esto es una cadena, y este es un entero.

625
00:37:36,470 --> 00:37:38,510
Así que si usted desea convertir entre los dos, recuerda, vamos a

626
00:37:38,510 --> 00:37:40,810
tiene esta función mágica llamada atoi.

627
00:37:40,810 --> 00:37:46,270
Para eso se necesita una cadena y devuelve el entero representado dentro de esa cadena.

628
00:37:46,270 --> 00:37:48,360
Así que eso es un error fácil de hacer en el concurso,

629
00:37:48,360 --> 00:37:51,590
pensando que este será automáticamente el tipo correcto.

630
00:37:51,590 --> 00:37:53,860
Pero sólo sé que estos siempre serán cadenas

631
00:37:53,860 --> 00:38:00,920
incluso si la cadena sólo contiene un número entero o un carácter o un flotador.

632
00:38:00,920 --> 00:38:03,380
Así que ahora vamos a hablar de tiempo de ejecución.

633
00:38:03,380 --> 00:38:06,700
Cuando tengamos todos estos algoritmos que hacen todas estas cosas locas,

634
00:38:06,700 --> 00:38:11,580
se hace muy útil para hacer la pregunta, "¿Cuánto tiempo tomará?"

635
00:38:11,580 --> 00:38:15,500
Representamos a que, con algo que se llama notación asintótica.

636
00:38:15,500 --> 00:38:18,430
Así que esto significa que - bueno, vamos a decir que le damos nuestro algoritmo

637
00:38:18,430 --> 00:38:20,840
algunas entradas muy, muy, muy grande.

638
00:38:20,840 --> 00:38:23,840
Queremos hacer la pregunta, "¿Cuánto tiempo va a tomar?

639
00:38:23,840 --> 00:38:26,370
¿Cuántos pasos se tarda en nuestro algoritmo para ejecutar

640
00:38:26,370 --> 00:38:29,980
como una función del tamaño de la entrada? "

641
00:38:29,980 --> 00:38:33,080
Así que la primera forma podemos describir el tiempo de ejecución es de gran O.

642
00:38:33,080 --> 00:38:35,380
Y este es el peor de los casos el tiempo de funcionamiento.

643
00:38:35,380 --> 00:38:38,590
Así que si queremos ordenar un array, y damos nuestro algoritmo de una matriz

644
00:38:38,590 --> 00:38:41,000
eso es en orden descendente, cuando debería estar en orden ascendente,

645
00:38:41,000 --> 00:38:43,130
que va a ser el peor de los casos.

646
00:38:43,130 --> 00:38:49,800
Este es nuestro límite superior de la duración máxima del tiempo de nuestro algoritmo tomará.

647
00:38:49,800 --> 00:38:54,740
Por otra parte, este Ω se va a describir mejor de los casos el tiempo de funcionamiento.

648
00:38:54,740 --> 00:38:58,210
Así que si le damos un arreglo ya está ordenado a un algoritmo de clasificación,

649
00:38:58,210 --> 00:39:00,940
¿cuánto tiempo se tarda en resolverlo?

650
00:39:00,940 --> 00:39:06,610
Y esto, a continuación, se describe un límite inferior en tiempo de ejecución.

651
00:39:06,610 --> 00:39:10,980
Así que aquí son sólo algunas palabras que describen algunos momentos comunes de funcionamiento.

652
00:39:10,980 --> 00:39:13,120
Estos son en orden ascendente.

653
00:39:13,120 --> 00:39:16,060
El mejor tiempo de funcionamiento que tenemos se llama constante.

654
00:39:16,060 --> 00:39:19,800
>> Eso significa que no importa cuántos elementos damos nuestro algoritmo,

655
00:39:19,800 --> 00:39:22,280
no importa lo grande que es nuestra matriz, su clasificación

656
00:39:22,280 --> 00:39:26,510
o hacer lo que estamos haciendo a la matriz siempre tendrá la misma cantidad de tiempo.

657
00:39:26,510 --> 00:39:30,270
Por lo tanto, puede representar que sólo con un 1, que es una constante.

658
00:39:30,270 --> 00:39:32,410
También nos fijamos en tiempo de ejecución logarítmica.

659
00:39:32,410 --> 00:39:34,800
Así que algo como la búsqueda binaria es logarítmica,

660
00:39:34,800 --> 00:39:37,140
donde cortamos el problema a la mitad cada vez

661
00:39:37,140 --> 00:39:40,970
y entonces las cosas sólo llegar más alto desde allí.

662
00:39:40,970 --> 00:39:43,580
Y si alguna vez escribir una O de cualquier algoritmo factorial,

663
00:39:43,580 --> 00:39:47,850
es probable que no deben considerar esto como su trabajo del día.

664
00:39:47,850 --> 00:39:53,910
Al comparar los tiempos de ejecución, es importante tener en cuenta estas cosas.

665
00:39:53,910 --> 00:39:57,760
Así que si tengo un algoritmo que es O (n), y otra persona

666
00:39:57,760 --> 00:40:03,590
tiene un algoritmo de O (2n) son en realidad asintóticamente equivalente.

667
00:40:03,590 --> 00:40:06,590
Así que si nos imaginamos n sea un número grande como ciento once mil millones:

668
00:40:06,590 --> 00:40:13,090
así que cuando estamos comparando ciento once mil millones a algo así como ciento once millones + 3,

669
00:40:13,090 --> 00:40:17,640
que de repente tres en realidad no hacen una gran diferencia ya.

670
00:40:17,640 --> 00:40:20,980
Es por eso que vamos a empezar a considerar estas cosas como equivalentes.

671
00:40:20,980 --> 00:40:24,220
Así que cosas como estas constantes aquí, hay 2 x esto, o la adición de un 3,

672
00:40:24,220 --> 00:40:27,180
estos son sólo constantes, y estos van a caer hacia arriba.

673
00:40:27,180 --> 00:40:32,480
Así que por eso todos los 3 de estos tiempos de funcionamiento son los mismos que dicen que son O (n).

674
00:40:32,480 --> 00:40:37,490
Del mismo modo, si tenemos 2 tiempos de ejecución otros, digamos O (n + 2n ³ ²), podemos añadir

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, y luego tenemos otro tiempo de ejecución que es sólo O (³ n).

676
00:40:42,070 --> 00:40:46,290
de nuevo, se trata de lo mismo, porque estos - estos no son los mismos.

677
00:40:46,290 --> 00:40:49,840
Estas son las cosas mismas, lo siento. Así que estos son los mismos porque

678
00:40:49,840 --> 00:40:53,090
Este ³ n va a dominar esta ² 2n.

679
00:40:53,090 --> 00:40:59,130
>> Lo que no es lo mismo es que si se nos ha acabado veces como O (³ n) y O (n ²)

680
00:40:59,130 --> 00:41:02,820
porque este ³ n es mucho mayor que esta ² n.

681
00:41:02,820 --> 00:41:05,470
Así que si tenemos exponentes, de repente esta se inicia a la materia,

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

683
00:41:08,280 --> 00:41:12,810
entonces no va a importar, ya que sólo se va a abandonar.

684
00:41:12,810 --> 00:41:16,760
Echemos un vistazo a algunos de los algoritmos que hemos visto hasta ahora

685
00:41:16,760 --> 00:41:19,260
y hablar de su tiempo de ejecución.

686
00:41:19,260 --> 00:41:23,850
La primera forma de buscar un número en una lista, que vimos, era la búsqueda lineal.

687
00:41:23,850 --> 00:41:26,950
Y la aplicación de búsqueda lineal es super sencillo.

688
00:41:26,950 --> 00:41:30,490
Sólo tenemos una lista, y vamos a ver cada elemento de la lista

689
00:41:30,490 --> 00:41:34,260
hasta encontrar el número que estamos buscando.

690
00:41:34,260 --> 00:41:38,370
Eso significa que en el peor de los casos, este O (n).

691
00:41:38,370 --> 00:41:40,860
Y el peor de los casos aquí podría ser si el elemento está

692
00:41:40,860 --> 00:41:45,710
el último elemento, a continuación, utilizando una búsqueda lineal que tenemos que mirar a cada elemento

693
00:41:45,710 --> 00:41:50,180
hasta llegar a la última con el fin de saber que en realidad estaba en la lista.

694
00:41:50,180 --> 00:41:52,910
No podemos abandonar a mitad de camino y decir: "Probablemente no sea allí".

695
00:41:52,910 --> 00:41:55,980
Con la búsqueda lineal que tenemos que mirar a todo el asunto.

696
00:41:55,980 --> 00:41:59,090
El tiempo de ejecución del mejor caso, en cambio, es constante

697
00:41:59,090 --> 00:42:04,200
porque en el mejor de los casos el elemento que estamos buscando es sólo el primero de la lista.

698
00:42:04,200 --> 00:42:08,930
Así que va a llevarnos exactamente un paso, no importa lo grande que la lista es

699
00:42:08,930 --> 00:42:12,140
si estamos buscando el primer elemento cada vez.

700
00:42:12,140 --> 00:42:15,390
>> Así que cuando usted busca, recordemos, no se requiere que la lista esté ordenada.

701
00:42:15,390 --> 00:42:19,430
Porque estamos simplemente va a mirar por encima de cada elemento, y no importa realmente

702
00:42:19,430 --> 00:42:23,560
qué orden los elementos se in

703
00:42:23,560 --> 00:42:28,110
Un algoritmo de búsqueda más inteligente es algo así como la búsqueda binaria.

704
00:42:28,110 --> 00:42:31,500
Recuerde, la aplicación de búsqueda binaria es cuando usted va a

705
00:42:31,500 --> 00:42:34,320
seguir buscando en la mitad de la lista.

706
00:42:34,320 --> 00:42:38,000
Y debido a que está buscando en el medio, es necesario que la lista está ordenada

707
00:42:38,000 --> 00:42:40,580
o de lo que no sabemos donde el centro es, y tenemos que mirar por encima de

708
00:42:40,580 --> 00:42:44,480
toda la lista para encontrarla, y entonces en ese punto estamos perdiendo el tiempo.

709
00:42:44,480 --> 00:42:48,480
Así que si tenemos una lista ordenada y nos encontramos con el medio, vamos a comparar el medio

710
00:42:48,480 --> 00:42:51,590
para el elemento que estamos buscando.

711
00:42:51,590 --> 00:42:54,640
Si es demasiado alto, entonces nos podemos olvidar de la mitad derecha

712
00:42:54,640 --> 00:42:57,810
porque sabemos que si nuestra elemento ya es demasiado alto

713
00:42:57,810 --> 00:43:01,080
y todo a la derecha de este elemento es aún mayor,

714
00:43:01,080 --> 00:43:02,760
entonces no es necesario mirar allí.

715
00:43:02,760 --> 00:43:05,430
Cuando por el contrario, si nuestro elemento es demasiado bajo,

716
00:43:05,430 --> 00:43:08,700
lo sabemos todo a la izquierda del elemento que también es demasiado baja,

717
00:43:08,700 --> 00:43:11,390
por lo que no tiene mucho sentido mirar allí, tampoco.

718
00:43:11,390 --> 00:43:15,760
De esta manera, con cada paso y cada vez que nos fijamos en el punto medio de la lista,

719
00:43:15,760 --> 00:43:19,060
vamos a reducir nuestro problema a la mitad porque de pronto sabemos

720
00:43:19,060 --> 00:43:23,040
un montón de números que no pueden ser la que estamos buscando.

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

722
00:43:26,950 --> 00:43:30,990
y porque estamos cortando la lista por la mitad cada vez,

723
00:43:30,990 --> 00:43:34,920
nuestros peores saltos de tiempo de ejecución de lineal a logarítmica.

724
00:43:34,920 --> 00:43:39,260
Así que de repente se tiene log-in pasos con el fin de encontrar un elemento en una lista.

725
00:43:39,260 --> 00:43:42,460
El tiempo de ejecución mejor de los casos, sin embargo, sigue siendo constante

726
00:43:42,460 --> 00:43:45,180
porque ahora, vamos a decir que el elemento que estamos buscando es

727
00:43:45,180 --> 00:43:48,380
siempre el centro exacto de la lista original.

728
00:43:48,380 --> 00:43:52,080
Así que podemos hacer crecer nuestra lista tan grande como queramos, pero si el elemento que estamos buscando está en el medio,

729
00:43:52,080 --> 00:43:54,910
entonces sólo va a llevarnos un paso.

730
00:43:54,910 --> 00:44:00,920
Así que por eso estamos O (log n) y Ω (1) o constante.

731
00:44:00,920 --> 00:44:04,510
Vamos a ejecutar realmente la búsqueda binaria en esta lista.

732
00:44:04,510 --> 00:44:08,020
Así que digamos que estamos buscando el elemento 164.

733
00:44:08,020 --> 00:44:11,650
Lo primero que vamos a hacer es encontrar el punto medio de esta lista.

734
00:44:11,650 --> 00:44:15,060
Lo que pasa es que el punto medio se va a caer en medio de estos dos números,

735
00:44:15,060 --> 00:44:18,960
así que vamos a decir arbitrariamente, cada vez que el punto medio se sitúa entre dos números,

736
00:44:18,960 --> 00:44:21,150
vamos a reunir.

737
00:44:21,150 --> 00:44:24,330
Sólo tenemos que asegurarnos de que hacemos esto cada paso del camino.

738
00:44:24,330 --> 00:44:29,040
Así que nos vamos a reunir y vamos a decir que 161 es el centro de nuestra lista.

739
00:44:29,040 --> 00:44:34,640
Así 161 <164, y cada elemento a la izquierda de 161

740
00:44:34,640 --> 00:44:39,120
También es <164, por lo que sabemos que no nos va a ayudar en absoluto

741
00:44:39,120 --> 00:44:42,690
para empezar a buscar por aquí porque el elemento que estamos buscando no puede estar allí.

742
00:44:42,690 --> 00:44:47,060
Así que lo que podemos hacer es simplemente podemos olvidar que la mitad de toda la izquierda de la lista,

743
00:44:47,060 --> 00:44:51,700
y ahora sólo tienen en cuenta desde la derecha de la década de 161.

744
00:44:51,700 --> 00:44:54,050
>> Así que de nuevo, este es el punto medio, vamos a redondear.

745
00:44:54,050 --> 00:44:56,260
Ahora 175 es demasiado grande.

746
00:44:56,260 --> 00:44:59,180
Así que sabemos que no va a ayudarnos a buscar aquí o aquí,

747
00:44:59,180 --> 00:45:06,610
por lo que sólo se puede tirar eso, y al final nos va a golpear el 164.

748
00:45:06,610 --> 00:45:10,560
Cualquier pregunta sobre la búsqueda binaria?

749
00:45:10,560 --> 00:45:14,180
Vamos a pasar de buscar a través de una lista ya ordenada-

750
00:45:14,180 --> 00:45:17,660
para realmente teniendo una lista de números en cualquier orden

751
00:45:17,660 --> 00:45:20,960
y hacer que la lista en orden ascendente.

752
00:45:20,960 --> 00:45:24,060
El primer algoritmo vimos fue llamado tipo burbuja.

753
00:45:24,060 --> 00:45:27,300
Y esto sería más simple de los algoritmos que vimos.

754
00:45:27,300 --> 00:45:32,970
Ordenamiento de burbuja, dice que cuando cualquiera de los 2 elementos dentro de la lista están fuera de lugar,

755
00:45:32,970 --> 00:45:36,500
es decir, hay un número superior a la izquierda de un número más bajo,

756
00:45:36,500 --> 00:45:40,190
entonces vamos a cambiar, porque eso significa que la lista será

757
00:45:40,190 --> 00:45:42,860
"Más ordenada" de lo que era antes.

758
00:45:42,860 --> 00:45:45,180
Y sólo vamos a continuar con este proceso una y otra vez y otra vez

759
00:45:45,180 --> 00:45:52,100
hasta que, finalmente, el tipo de elementos burbuja a su ubicación correcta y tenemos una lista ordenada.

760
00:45:52,100 --> 00:45:57,230
>> El tiempo de ejecución de que esto va a ser O (n ²). ¿Por qué?

761
00:45:57,230 --> 00:46:00,370
Bueno, pues en el peor de los casos, vamos a tomar cada elemento, y

762
00:46:00,370 --> 00:46:04,570
vamos a terminar comparándolo con cualquier otro elemento en la lista.

763
00:46:04,570 --> 00:46:08,030
Pero en el mejor de los casos, tenemos una lista ya ordenada, burbuja tipo de

764
00:46:08,030 --> 00:46:12,230
sólo va a pasar por una vez, diga "Nope. Yo no hice ningún swaps, así que he terminado."

765
00:46:12,230 --> 00:46:17,410
Así que tenemos un tiempo mejor de los casos el funcionamiento de Ω (n).

766
00:46:17,410 --> 00:46:20,680
Vamos a correr especie de burbuja en una lista.

767
00:46:20,680 --> 00:46:23,560
O vamos a mirar algunos pseudocódigo muy rápido.

768
00:46:23,560 --> 00:46:28,160
Queremos decir que queremos perder de vista, en cada iteración del bucle,

769
00:46:28,160 --> 00:46:32,190
hacer un seguimiento de si podemos o no cambiar ningún elemento.

770
00:46:32,190 --> 00:46:37,610
Así que la razón de esto es, que vamos a parar cuando no hemos cambiado ningún elemento.

771
00:46:37,610 --> 00:46:41,980
Así que al principio de nuestro bucle no hemos cambiado nada, así que voy a decir que es falso.

772
00:46:41,980 --> 00:46:47,170
Ahora, vamos a ir por la lista y comparar elemento a elemento i i + 1

773
00:46:47,170 --> 00:46:50,310
y si es el caso que hay un número más grande a la izquierda de un número más pequeño,

774
00:46:50,310 --> 00:46:52,310
entonces sólo vamos a intercambiarlas.

775
00:46:52,310 --> 00:46:54,490
>> Y luego vamos a recordar que nos cambiado un elemento.

776
00:46:54,490 --> 00:46:58,900
Eso significa que tenemos que pasar por la lista al menos una vez más

777
00:46:58,900 --> 00:47:02,160
porque la condición en la que se detiene cuando toda la lista ya está ordenada,

778
00:47:02,160 --> 00:47:04,890
lo que significa que no han hecho ningún swaps.

779
00:47:04,890 --> 00:47:09,960
Así que por eso nuestra condición aquí es ", mientras que algunos elementos han sido cambiados.

780
00:47:09,960 --> 00:47:13,720
Así que ahora vamos a ver esto que se ejecuta en una lista.

781
00:47:13,720 --> 00:47:16,640
Tengo la lista 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Ordenamiento de burbuja va a comenzar todo el camino a la izquierda, y va a comparar

783
00:47:19,850 --> 00:47:24,700
Los elementos que, de modo 0 a i + 1, que es el elemento 1.

784
00:47:24,700 --> 00:47:29,020
Va a decir, bueno 5> 0, pero en este momento 5 es a la izquierda,

785
00:47:29,020 --> 00:47:32,500
así que tengo que cambiar el 5 y el 0.

786
00:47:32,500 --> 00:47:35,470
Cuando les intercambiar, de repente me sale este lista diferente.

787
00:47:35,470 --> 00:47:38,260
Ahora 5> 1, por lo que vamos a intercambiarlas.

788
00:47:38,260 --> 00:47:42,160
5 no es> 6, por lo que no tiene que hacer nada aquí.

789
00:47:42,160 --> 00:47:46,690
Pero 6> 4, por lo que tenemos que cambiar.

790
00:47:46,690 --> 00:47:49,740
Una vez más, tenemos que repasar la lista entera para descubrir finalmente

791
00:47:49,740 --> 00:47:52,330
que éstas están fuera de servicio, nos cambiarlos,

792
00:47:52,330 --> 00:47:57,120
y en este momento tenemos que pasar por la lista 1 hora más

793
00:47:57,120 --> 00:48:05,390
para asegurarse de que todo está en su orden, y en este tipo burbuja punto ha terminado.

794
00:48:05,390 --> 00:48:10,720
Un algoritmo diferente para tomar algunos elementos y ordenarlos es una especie de selección.

795
00:48:10,720 --> 00:48:15,740
La idea detrás de ordenación por selección es que vamos a construir una parte ordenada de la lista

796
00:48:15,740 --> 00:48:18,150
1 elemento a la vez.

797
00:48:18,150 --> 00:48:23,170
>> Y la forma en que vamos a hacerlo es construyendo el segmento izquierdo de la lista.

798
00:48:23,170 --> 00:48:27,510
Y en el fondo, todos - en cada paso, vamos a tener el más mínimo elemento que nos queda

799
00:48:27,510 --> 00:48:32,310
que no ha sido aún ordenado, y nos vamos a mover en ese segmento ordenada.

800
00:48:32,310 --> 00:48:35,850
Eso significa que tenemos que encontrar continuamente el elemento mínimo sin clasificar

801
00:48:35,850 --> 00:48:40,720
y luego tomar ese elemento mínimo e intercambiarlo con lo

802
00:48:40,720 --> 00:48:45,090
dejó a la mayoría de elementos que no está ordenada.

803
00:48:45,090 --> 00:48:50,890
El tiempo de ejecución de que esto va a ser O (n ²) porque en el peor de los casos

804
00:48:50,890 --> 00:48:55,070
tenemos que comparar cada elemento a todos los demás elementos.

805
00:48:55,070 --> 00:48:59,250
Debido a que estamos diciendo que si empezamos en la mitad izquierda de la lista, es necesario

806
00:48:59,250 --> 00:49:02,970
ir a través de todo el segmento derecho para encontrar el elemento más pequeño.

807
00:49:02,970 --> 00:49:05,430
Y entonces, de nuevo, tenemos que ir sobre el segmento de la derecha y todo

808
00:49:05,430 --> 00:49:08,210
seguir repitiendo una y otra y otra vez.

809
00:49:08,210 --> 00:49:11,350
Eso va a ser ² n. Vamos a necesitar un lazo para el interior de otro bucle for

810
00:49:11,350 --> 00:49:13,350
lo que sugiere ² n.

811
00:49:13,350 --> 00:49:16,530
En el pensamiento mejor de los casos, vamos a decir que le damos una lista ya ordenada;

812
00:49:16,530 --> 00:49:19,270
que en realidad no hacen nada mejor que ² n.

813
00:49:19,270 --> 00:49:21,730
Por tipo de selección no tiene manera de saber que

814
00:49:21,730 --> 00:49:25,540
el elemento mínimo es el que sucede a mirar.

815
00:49:25,540 --> 00:49:28,970
Todavía necesita para asegurarse de que esto es realmente mínimo.

816
00:49:28,970 --> 00:49:31,670
>> Y la única manera de asegurarse de que es el mínimo, utilizando este algoritmo,

817
00:49:31,670 --> 00:49:34,640
es mirar cada elemento nuevo.

818
00:49:34,640 --> 00:49:38,420
Así que en realidad, si le dan - si se le da una lista de ordenación por selección ya clasificada,

819
00:49:38,420 --> 00:49:42,720
que no va a hacer nada mejor que darle una lista que no está ordenada todavía.

820
00:49:42,720 --> 00:49:46,320
Por cierto, si pasa a ser el caso de que algo es O (algo)

821
00:49:46,320 --> 00:49:50,640
y el omega de algo, sólo puedo decir más brevemente que es θ de algo.

822
00:49:50,640 --> 00:49:52,760
Así que si ves que surgen en cualquier parte, eso es lo que eso significa.

823
00:49:52,760 --> 00:49:57,580
>> Si algo es theta de ² n, es a la vez grande O (n ²) y Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Así que lo mejor y el peor caso, no hace ninguna diferencia,

825
00:49:59,790 --> 00:50:04,400
el algoritmo se va a hacer la misma cosa cada vez.

826
00:50:04,400 --> 00:50:06,610
Así que esto es lo que pseudocódigo para ordenar selección podría ser similar.

827
00:50:06,610 --> 00:50:10,630
Estamos básicamente va a decir que quiero para iterar sobre la lista

828
00:50:10,630 --> 00:50:15,180
de izquierda a derecha, y en cada iteración del bucle, voy a mover

829
00:50:15,180 --> 00:50:19,780
el elemento mínimo en esta porción de la lista ordenada.

830
00:50:19,780 --> 00:50:23,260
Y una vez que me muevo algo allí, no tengo que mirar a ese elemento nuevo.

831
00:50:23,260 --> 00:50:28,600
Porque tan pronto como cambiar un elemento en el segmento izquierdo de la lista, se ordenan

832
00:50:28,600 --> 00:50:32,600
porque estamos haciendo todo en orden ascendente utilizando mínimos.

833
00:50:32,600 --> 00:50:38,740
Entonces dijimos, bueno, estamos en la posición i, y tenemos que mirar todos los elementos

834
00:50:38,740 --> 00:50:42,260
a la derecha de i con el fin de encontrar el mínimo.

835
00:50:42,260 --> 00:50:46,150
Así que eso significa que queremos mirar desde i + 1 hasta el final de la lista.

836
00:50:46,150 --> 00:50:51,610
Y ahora, si el elemento que estamos mirando es menor que nuestro mínimo hasta el momento,

837
00:50:51,610 --> 00:50:54,190
que, recordemos, estamos empezando el descuento mínimo para ser justo

838
00:50:54,190 --> 00:50:57,020
cualquier elemento que estamos actualmente, voy a asumir que es el mínimo.

839
00:50:57,020 --> 00:51:00,270
Si encuentro un elemento que es más pequeño que eso, entonces yo voy a decir, bueno,

840
00:51:00,270 --> 00:51:02,700
Bueno, he encontrado un nuevo mínimo.

841
00:51:02,700 --> 00:51:06,080
Voy a recordar dónde estaba ese mínimo.

842
00:51:06,080 --> 00:51:09,560
>> Así que ahora, una vez que haya pasado por ese segmento sin clasificar derecho,

843
00:51:09,560 --> 00:51:16,690
Puedo decir que voy a cambiar el elemento mínimo con el elemento que se encuentra en la posición i.

844
00:51:16,690 --> 00:51:21,100
Eso va a construir mi lista, mi porción ordenada de la lista de izquierda a derecha,

845
00:51:21,100 --> 00:51:25,190
y no alguna vez tiene que ver un elemento de nuevo una vez que esté en esa parte.

846
00:51:25,190 --> 00:51:27,930
Una vez que lo hemos cambiado.

847
00:51:27,930 --> 00:51:30,260
Así que vamos a ejecutar la ordenación por selección en esta lista.

848
00:51:30,260 --> 00:51:38,220
El elemento azul aquí va a ser la i, y el elemento rojo va a ser el elemento mínimo.

849
00:51:38,220 --> 00:51:41,570
Así que comienza todo el camino a la izquierda de la lista, por lo menos 5.

850
00:51:41,570 --> 00:51:44,610
Ahora tenemos que encontrar el elemento unsorted mínimo.

851
00:51:44,610 --> 00:51:49,480
Por eso decimos 0 <5, por lo que 0 es mi nuevo mínimo.

852
00:51:49,480 --> 00:51:53,820
>> Pero no puede quedarse ahí, porque aunque podemos reconocer que 0 es el más pequeño,

853
00:51:53,820 --> 00:51:59,390
tenemos que pasar por todos los demás elementos de la lista para asegurarse.

854
00:51:59,390 --> 00:52:01,760
Así 1 es más grande, es más grande 6, 4 es más grande.

855
00:52:01,760 --> 00:52:05,850
Esto significa que después de ver todos estos elementos, he determinado 0 es el más pequeño.

856
00:52:05,850 --> 00:52:09,800
Así que voy a cambiar el 5 y el 0.

857
00:52:09,800 --> 00:52:15,480
Una vez que cambie eso, me voy a poner una nueva lista, y sé que nunca tengo que mirar en ese 0 de nuevo

858
00:52:15,480 --> 00:52:19,380
porque una vez que lo he cambiado, lo he clasificado y ya está.

859
00:52:19,380 --> 00:52:22,730
Ahora da la casualidad de que el elemento azul vuelve a ser el 5,

860
00:52:22,730 --> 00:52:26,030
y tenemos que mirar a la 1, la 6 y la 4 para determinar que una

861
00:52:26,030 --> 00:52:31,520
Es el elemento más pequeño de menos, así que vamos a cambiar el 1 y el 5.

862
00:52:31,520 --> 00:52:36,890
Una vez más, tenemos que mirar - comparar el 5 y el 6 y el 4,

863
00:52:36,890 --> 00:52:39,830
y vamos a cambiar el 4 y el 5, y, finalmente, comparar,

864
00:52:39,830 --> 00:52:45,740
esos 2 números e intercambiarlos hasta que tengamos nuestra lista ordenada.

865
00:52:45,740 --> 00:52:49,730
Cualquier pregunta sobre tipo de selección?

866
00:52:49,730 --> 00:52:56,420
Bien. Pasemos al último tema aquí, y que es la recursividad.

867
00:52:56,420 --> 00:52:59,810
>> La recursividad, recuerde, es esta cosa meta realmente donde una función

868
00:52:59,810 --> 00:53:02,740
repetidamente se llama.

869
00:53:02,740 --> 00:53:05,620
Entonces, en algún momento, mientras que nuestro succion en repetidas ocasiones que se hace llamar,

870
00:53:05,620 --> 00:53:10,100
tiene que haber algún punto en el que dejamos de llamarnos.

871
00:53:10,100 --> 00:53:13,670
Porque si no hacemos eso, entonces sólo vamos a seguir haciendo esto para siempre,

872
00:53:13,670 --> 00:53:16,660
y nuestro programa no sólo va a terminar.

873
00:53:16,660 --> 00:53:19,200
Llamamos a esta condición, el caso base.

874
00:53:19,200 --> 00:53:22,570
Y el caso base, dice, en lugar de llamar a una función más,

875
00:53:22,570 --> 00:53:25,330
Sólo voy a volver algún valor.

876
00:53:25,330 --> 00:53:28,080
Así que una vez que hemos devuelto un valor, hemos dejado de llamar a nosotros mismos,

877
00:53:28,080 --> 00:53:32,550
y el resto de las llamadas que hemos hecho hasta ahora también pueden regresar.

878
00:53:32,550 --> 00:53:36,050
Lo contrario de la hipótesis de base es el caso recursivo.

879
00:53:36,050 --> 00:53:39,050
Y aquí es cuando queremos hacer otra llamada a la función que se encuentra,

880
00:53:39,050 --> 00:53:44,690
Y es probable que, aunque no siempre, se desea utilizar diferentes argumentos.

881
00:53:44,690 --> 00:53:48,940
>> Así que si tenemos una función llamada f, y f acaba de llamar a tomar un argumento,

882
00:53:48,940 --> 00:53:52,010
y nos siguen llamando f (1), f (1), f (1), y da la casualidad de que

883
00:53:52,010 --> 00:53:56,510
el argumento cae en un caso recursivo, estamos todavía nunca va a parar.

884
00:53:56,510 --> 00:54:01,620
Incluso si tenemos un caso base, hay que asegurarse de que a la larga nos va a golpear ese caso base.

885
00:54:01,620 --> 00:54:04,250
No nos limitamos a seguir permaneciendo en este caso recursivo.

886
00:54:04,250 --> 00:54:09,870
Por lo general, cuando nos llame, nosotros probablemente vamos a tener un argumento diferente cada vez.

887
00:54:09,870 --> 00:54:12,700
He aquí una función recursiva realmente simple.

888
00:54:12,700 --> 00:54:15,090
Así que esto va a calcular el factorial de un número.

889
00:54:15,090 --> 00:54:17,790
Encima de la tapa aquí tenemos a nuestro caso base.

890
00:54:17,790 --> 00:54:22,330
En el caso de que n ≤ 1, no vamos a llamar a factorial de nuevo.

891
00:54:22,330 --> 00:54:26,490
Vamos a parar, sólo vamos a devolver algún valor.

892
00:54:26,490 --> 00:54:30,170
Si esto no fuera cierto, entonces vamos a golpear nuestro caso recursivo.

893
00:54:30,170 --> 00:54:33,550
Nótese aquí que no sólo estamos llamando factorial (n), porque eso no sería muy útil.

894
00:54:33,550 --> 00:54:36,810
Vamos a llamar a factorial de otra cosa.

895
00:54:36,810 --> 00:54:40,850
>> Y para que pueda ver, con el tiempo si pasamos algo factorial (5) o,

896
00:54:40,850 --> 00:54:45,900
vamos a llamar a factorial (4) y así sucesivamente, y al final nos va a golpear este caso base.

897
00:54:45,900 --> 00:54:51,730
Así que esto tiene buena pinta. Vamos a ver qué pasa cuando realmente ejecutar este.

898
00:54:51,730 --> 00:54:57,840
Se trata de la pila, y digamos que principal va a llamar a esta función con un argumento (4).

899
00:54:57,840 --> 00:55:02,200
Así que una vez factorial ve y = 4, factorial se llamará.

900
00:55:02,200 --> 00:55:05,010
Ahora, de repente, tenemos factorial (3).

901
00:55:05,010 --> 00:55:10,780
Así pues, estas funciones se va a seguir creciendo hasta que finalmente llegamos a nuestro caso base.

902
00:55:10,780 --> 00:55:17,830
En este punto, el valor de retorno de ello es el retorno (nx el valor de retorno de esta),

903
00:55:17,830 --> 00:55:21,290
el valor de retorno de esta nx es el valor de retorno de esta.

904
00:55:21,290 --> 00:55:23,290
Finalmente, tenemos que llegar a algún número.

905
00:55:23,290 --> 00:55:26,560
En la parte superior aquí, decimos return 1.

906
00:55:26,560 --> 00:55:30,650
Esto significa que una vez que regrese a ese número, que puede hacer estallar este de la pila.

907
00:55:30,650 --> 00:55:36,570
Así que este factorial (1) está hecho.

908
00:55:36,570 --> 00:55:41,190
Cuando uno regresa, esta factoriales (1) devoluciones, este retorno a 1.

909
00:55:41,190 --> 00:55:46,910
El valor de retorno de esta, recordemos, era nx el valor de retorno de esta.

910
00:55:46,910 --> 00:55:50,720
Entonces, de repente, este hombre sabe que quiero volver 2.

911
00:55:50,720 --> 00:55:55,910
>> Así que recuerda, devolver el valor de esto es sólo el valor de retorno nx aquí.

912
00:55:55,910 --> 00:56:01,160
Así que ahora podemos decir 3 x 2, y, por último, aquí podemos decir

913
00:56:01,160 --> 00:56:04,010
esto va a ser de 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
Y una vez que esto vuelva, nos ponemos manos a un solo número entero dentro del principal.

915
00:56:09,570 --> 00:56:15,460
¿Tiene preguntas sobre la recursividad?

916
00:56:15,460 --> 00:56:17,090
Está bien. Así que no hay más tiempo para preguntas al final,

917
00:56:17,090 --> 00:56:23,360
pero ahora Joseph cubrirá los temas restantes.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] De acuerdo. Así que ahora que hemos hablado de recurrencias,

919
00:56:25,590 --> 00:56:27,840
vamos a hablar un poco sobre lo que merge sort es.

920
00:56:27,840 --> 00:56:31,740
Combinar tipo es básicamente otra manera de ordenar una lista de números.

921
00:56:31,740 --> 00:56:36,430
Y la forma en que funciona es, con una especie de mezcla tiene una lista, y es lo que hacemos

922
00:56:36,430 --> 00:56:39,120
decimos, vamos a dividirla en dos mitades.

923
00:56:39,120 --> 00:56:42,750
En primer lugar, se quedará sin fundirse de nuevo tipo en la mitad izquierda,

924
00:56:42,750 --> 00:56:45,040
entonces vamos a correr merge sort en la mitad derecha,

925
00:56:45,040 --> 00:56:50,240
y eso nos da ahora dos mitades que se ordenan, y ahora vamos a combinar las mitades.

926
00:56:50,240 --> 00:56:55,010
Es un poco difícil de ver sin un ejemplo, así que vamos a seguir todo el procedimiento y ver qué pasa.

927
00:56:55,010 --> 00:56:59,590
Así que empezar con esta lista, se lo divide en dos mitades.

928
00:56:59,590 --> 00:57:02,300
Corremos merge sort en la mitad izquierda primero.

929
00:57:02,300 --> 00:57:06,660
Así que esa es la mitad izquierda, y ahora ejecuta a través de esta lista otra vez

930
00:57:06,660 --> 00:57:09,800
que se pasa en una especie de mezcla, y luego nos vemos, de nuevo,

931
00:57:09,800 --> 00:57:13,270
en el lado izquierdo de esta lista y se corre fusionar tipo sobre el mismo.

932
00:57:13,270 --> 00:57:15,880
Ahora, nos ponemos manos a una lista de números 2,

933
00:57:15,880 --> 00:57:19,010
y ahora la mitad izquierda es sólo un elemento de largo, y no podemos

934
00:57:19,010 --> 00:57:23,380
dividir una lista que es sólo un elemento en la mitad, por lo que acaba de decir, una vez que tengamos 50,

935
00:57:23,380 --> 00:57:26,400
que es sólo un elemento, ya está solucionado.

936
00:57:26,400 --> 00:57:29,860
>> Una vez que hayamos terminado con esto, podemos ver que podemos

937
00:57:29,860 --> 00:57:32,230
pasar a la parte derecha de esta lista,

938
00:57:32,230 --> 00:57:36,480
y 3 también se clasifican, por lo que ahora que las dos mitades de esta lista están ordenadas

939
00:57:36,480 --> 00:57:39,080
podemos unir estos números de nuevo juntos.

940
00:57:39,080 --> 00:57:45,320
Así que vemos 50 y 3; 3 es menor que 50, lo que va en primer lugar y luego 50 entra

941
00:57:45,320 --> 00:57:49,340
Ahora, eso está hecho, volvemos a esa lista y ordenar es la mitad derecha.

942
00:57:49,340 --> 00:57:52,440
42 es su propio número, así que ya ordenados.

943
00:57:52,440 --> 00:57:57,850
Así que ahora comparamos estos 2 y 3 es menor que 42, por lo que se puso en primer lugar,

944
00:57:57,850 --> 00:58:02,340
ahora de 42 años se puso en, y el 50 se pone adentro

945
00:58:02,340 --> 00:58:07,220
Ahora, que está clasificado, vamos todo el camino hasta la cima, 1337 y 15.

946
00:58:07,220 --> 00:58:14,560
Bueno, ahora nos fijamos en la parte izquierda de esta lista; 1337 es por sí mismo lo que es ordenado y lo mismo con 15.

947
00:58:14,560 --> 00:58:19,020
Así que ahora combinamos estos dos números para ordenar la lista original, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
lo que va en primer lugar, a continuación, va in 1337

949
00:58:23,060 --> 00:58:26,640
Y ahora nos ordenan las dos mitades de la lista original hasta la parte superior.

950
00:58:26,640 --> 00:58:30,440
Y todo lo que tienes que hacer es combinar estos.

951
00:58:30,440 --> 00:58:36,890
Nos fijamos en los 2 primeros números de esta lista, 3 <15, por lo que entra en la matriz primero ordenar.

952
00:58:36,890 --> 00:58:44,460
15 <42, así que va pulg Ahora, 42 <1337, que va in

953
00:58:44,460 --> 00:58:51,010
50 <1337, por lo que va in Y note que sólo tardó 2 números fuera de esta lista.

954
00:58:51,010 --> 00:58:53,640
Así que no sólo estamos alternando entre las dos listas.

955
00:58:53,640 --> 00:58:56,050
Estamos viendo el principio, y estamos tomando el elemento

956
00:58:56,050 --> 00:59:00,270
que es más pequeño y luego ponerlo en nuestra matriz.

957
00:59:00,270 --> 00:59:04,080
Ahora hemos fusionado todos las mitades y ya está.

958
00:59:04,080 --> 00:59:07,780
>> Cualquier pregunta acerca de fusionar tipo? ¿Sí?

959
00:59:07,780 --> 00:59:14,190
[Estudiante] Si se trata de dividir en grupos diferentes, ¿por qué no acaba de dividir una vez

960
00:59:14,190 --> 00:59:19,970
y tiene 3 y 2 en un grupo? [Resto pregunta ininteligible]

961
00:59:19,970 --> 00:59:24,940
La razón - por lo que la pregunta es, ¿por qué no podemos simplemente combinarlos en ese primer paso después de que los tenemos?

962
00:59:24,940 --> 00:59:29,530
La razón por la que podemos hacer esto, comience en los elementos de izquierda-la mayoría de ambas partes,

963
00:59:29,530 --> 00:59:33,040
y luego tomar la más pequeña y la puso adentro, es que sabemos que estos

964
00:59:33,040 --> 00:59:35,290
listas individuales de los pedidos ordenados.

965
00:59:35,290 --> 00:59:37,290
Así que si estoy mirando a los elementos más a la izquierda de las dos mitades,

966
00:59:37,290 --> 00:59:40,490
Yo sé que van a ser los elementos más pequeños de esas listas.

967
00:59:40,490 --> 00:59:43,930
Así que puedo ponerlos en los lugares más pequeños elementos de esta larga lista.

968
00:59:43,930 --> 00:59:47,810
Por otro lado, si miro a esos dos listas en el segundo nivel de allá,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 y 15, los que no están ordenadas.

970
00:59:51,640 --> 00:59:55,770
Así que si miro a los 50 y 1337, me voy a poner 50 en mi primera lista.

971
00:59:55,770 --> 01:00:00,130
Pero eso no tiene mucho sentido, ya que 3 es el elemento más pequeño de todos ellos.

972
01:00:00,130 --> 01:00:04,390
Así que la única razón por la que podemos hacer este paso se debe a la combinación de nuestras listas ya están ordenados.

973
01:00:04,390 --> 01:00:07,010
Es por eso que tenemos que bajar todo el camino hasta el fondo

974
01:00:07,010 --> 01:00:09,800
porque cuando tenemos un solo número, usted sabe que un solo número

975
01:00:09,800 --> 01:00:14,120
en y de por sí ya es una lista ordenada.

976
01:00:14,120 --> 01:00:19,360
>> ¿Alguna pregunta? No?

977
01:00:19,360 --> 01:00:24,260
Complejidad? Bueno, se puede ver que en cada paso hay números finales,

978
01:00:24,260 --> 01:00:27,590
y podemos dividir una lista en el registro medio n veces,

979
01:00:27,590 --> 01:00:31,700
que es de donde se obtiene este log n x n complejidad.

980
01:00:31,700 --> 01:00:34,940
Y verás el mejor de los casos por tipo de combinación es n log n, y que sólo sucede así

981
01:00:34,940 --> 01:00:39,340
que el peor de los casos, o la Ω allá, también es n log n.

982
01:00:39,340 --> 01:00:42,480
Algo a tener en cuenta.

983
01:00:42,480 --> 01:00:45,750
Cambiando de tema, vamos a ir a algún archivo de súper básico I / O.

984
01:00:45,750 --> 01:00:48,830
Si se miraba en Scramble, te darás cuenta de que tenía algún tipo de sistema

985
01:00:48,830 --> 01:00:51,270
donde se puede escribir en un archivo de registro si usted lee a través del código.

986
01:00:51,270 --> 01:00:53,730
Vamos a ver cómo se puede hacer eso.

987
01:00:53,730 --> 01:00:57,450
Bueno, tenemos fprintf, que se puede considerar como justo printf,

988
01:00:57,450 --> 01:01:01,720
pero sólo imprimir a un archivo en lugar, y por lo tanto la f al principio.

989
01:01:01,720 --> 01:01:07,570
Este tipo de código hasta aquí, lo que hace es, como habrás visto en Scramble,

990
01:01:07,570 --> 01:01:12,310
pasa a través de la impresión matriz 2-dimensional fuera fila por fila cuáles son los números.

991
01:01:12,310 --> 01:01:17,850
En este caso, printf imprime a su terminal o lo que llamamos la salida estándar de sección.

992
01:01:17,850 --> 01:01:22,170
>> Y ahora, en este caso, lo único que tienes que hacer es reemplazar printf con fprintf,

993
01:01:22,170 --> 01:01:26,770
dicen que sobre el archivo que desea imprimir y, en este caso, sólo se imprime a ese archivo

994
01:01:26,770 --> 01:01:32,230
en lugar de ello imprimiendo a su terminal.

995
01:01:32,230 --> 01:01:36,500
Bueno, entonces eso nos lleva a la pregunta: ¿De dónde sacamos este tipo de archivo desde, ¿verdad?

996
01:01:36,500 --> 01:01:39,840
Pasamos identifícate para este fuction de fprintf, pero no teníamos idea de dónde vino.

997
01:01:39,840 --> 01:01:43,980
Bueno, al principio del código, lo que tuvimos fue este fragmento de código por aquí,

998
01:01:43,980 --> 01:01:48,340
que básicamente dice que se puede abrir el archivo log.txt llama.

999
01:01:48,340 --> 01:01:53,220
¿Qué hacemos después de eso es que tenemos que asegurarnos de que el archivo está realmente abierto con éxito.

1000
01:01:53,220 --> 01:01:57,070
Así que puede fallar por múltiples razones, usted no tiene suficiente espacio en su ordenador, por ejemplo.

1001
01:01:57,070 --> 01:01:59,790
Así que siempre es importante antes de hacer cualquier operación con el archivo

1002
01:01:59,790 --> 01:02:03,300
que comprobamos si ese archivo se abrió correctamente.

1003
01:02:03,300 --> 01:02:09,330
Así que lo que a, ese es un argumento a fopen, bueno, puede abrir un archivo de muchas maneras.

1004
01:02:09,330 --> 01:02:13,510
Lo que podemos hacer es que se lo puede transmitir w, lo que significa reemplazar el archivo si sale ya,

1005
01:02:13,510 --> 01:02:18,070
Podemos pasar una a, que añadir al final del archivo en lugar de que sea redefinido,

1006
01:02:18,070 --> 01:02:22,730
o podemos especificar r, es decir, vamos a abrir el archivo como de sólo lectura.

1007
01:02:22,730 --> 01:02:24,890
Así que si el programa intenta realizar cambios en el archivo,

1008
01:02:24,890 --> 01:02:30,140
gritar en ellos y no dejes que lo hagan.

1009
01:02:30,140 --> 01:02:33,320
Finalmente, una vez que hayamos terminado con el archivo, hecha realizar operaciones en él,

1010
01:02:33,320 --> 01:02:35,860
tenemos que asegurarnos de que cierre el archivo.

1011
01:02:35,860 --> 01:02:38,830
Y así, al final de su programa, que va a pasar de nuevo

1012
01:02:38,830 --> 01:02:42,120
el archivo que ha abierto, y simplemente cerrarla.

1013
01:02:42,120 --> 01:02:44,650
Así que esto es algo importante que hay que asegurarse de que usted lo hace.

1014
01:02:44,650 --> 01:02:47,180
Así que recuerde que puede abrir un archivo, entonces se puede escribir en el archivo,

1015
01:02:47,180 --> 01:02:51,270
realizar operaciones en el archivo, pero luego se va a cerrar el archivo al final.

1016
01:02:51,270 --> 01:02:53,270
>> Cualquier pregunta sobre el archivo de base de E / S? ¿Sí?

1017
01:02:53,270 --> 01:02:58,050
[Pregunta Estudiante, ininteligible]

1018
01:02:58,050 --> 01:03:02,480
Aquí mismo. La pregunta es, ¿de dónde viene este archivo log.txt aparecer?

1019
01:03:02,480 --> 01:03:07,890
Bueno, si sólo le dan log.txt, se crea en el mismo directorio que el ejecutable.

1020
01:03:07,890 --> 01:03:10,500
Así que si TU ESTAS - >> [pregunta Estudiante, ininteligible]

1021
01:03:10,500 --> 01:03:18,830
Sí. En la misma carpeta, o en el mismo directorio, como usted lo llama.

1022
01:03:18,830 --> 01:03:21,400
Ahora la memoria, pila y pila.

1023
01:03:21,400 --> 01:03:23,400
Entonces, ¿cómo es la memoria se establece en la computadora?

1024
01:03:23,400 --> 01:03:26,270
Bueno, se puede imaginar como una especie de memoria de este bloque aquí.

1025
01:03:26,270 --> 01:03:30,260
Y en la memoria que tenemos lo que se llama el montón atrapado allí, y la pila que está ahí abajo.

1026
01:03:30,260 --> 01:03:34,480
Y la pila crece hacia abajo y la pila crece hacia arriba.

1027
01:03:34,480 --> 01:03:38,620
Así como Tommy mencionó - oh, bueno, y tenemos estas otras 4 segmentos que voy a llegar en un segundo -

1028
01:03:38,620 --> 01:03:42,890
Como Tommy dicho antes, usted sabe cómo se llaman sus funciones y llamar a los demás?

1029
01:03:42,890 --> 01:03:44,930
Ellos construyen este tipo de marco de pila.

1030
01:03:44,930 --> 01:03:47,360
Bueno, si los principales llamadas foo, foo se ponen en la pila.

1031
01:03:47,360 --> 01:03:52,430
Foo llama bar, bar llegar a poner en la pila, y que se ponen en la pila después.

1032
01:03:52,430 --> 01:03:57,040
Y al regresar, cada uno de ellos se llevan de la pila.

1033
01:03:57,040 --> 01:04:00,140
¿Qué cada uno de estos lugares y mantener la memoria?

1034
01:04:00,140 --> 01:04:03,110
Pues bien, la parte superior, que es el segmento de texto, contiene el programa en sí.

1035
01:04:03,110 --> 01:04:06,390
Así que el código máquina, que está ahí, una vez que se compila el programa.

1036
01:04:06,390 --> 01:04:08,520
A continuación, cualquier inicializa las variables globales.

1037
01:04:08,520 --> 01:04:12,660
>> Así que hay variables globales en su programa, y ​​como usted dice, a = 5,

1038
01:04:12,660 --> 01:04:15,260
que se puso en ese segmento, y justo debajo de eso,

1039
01:04:15,260 --> 01:04:18,990
Tiene datos globales no inicializados, que se acaba de int a,

1040
01:04:18,990 --> 01:04:20,990
pero no te dicen que es igual a nada.

1041
01:04:20,990 --> 01:04:23,870
Darse cuenta de que estas son variables globales, por lo que están fuera de la principal.

1042
01:04:23,870 --> 01:04:28,560
Así que esto significa que las variables globales que se declaran pero no se inicializa.

1043
01:04:28,560 --> 01:04:32,310
Así que lo que está en el montón? La memoria asignada con malloc, que vamos a llegar a un poco.

1044
01:04:32,310 --> 01:04:35,990
Y, por último, con la pila tiene alguna variables locales

1045
01:04:35,990 --> 01:04:39,950
y cualquier otra función que se podría llamar en cualquiera de sus parámetros.

1046
01:04:39,950 --> 01:04:43,720
La última cosa que usted realmente no tiene que saber cuáles son las variables de entorno hacen,

1047
01:04:43,720 --> 01:04:46,700
pero cada vez que se ejecute el programa, hay algo asociado, al igual que

1048
01:04:46,700 --> 01:04:49,550
este es el nombre de la persona que ejecutó el programa.

1049
01:04:49,550 --> 01:04:51,550
Y eso va a ser una especie de en la parte inferior.

1050
01:04:51,550 --> 01:04:54,540
En términos de direcciones de memoria, que son valores hexadecimales,

1051
01:04:54,540 --> 01:04:58,170
los valores al comienzo superior a 0, y van todo el camino hasta el fondo.

1052
01:04:58,170 --> 01:05:00,440
En este caso, si usted está en el sistema de 32-bit,

1053
01:05:00,440 --> 01:05:05,390
la dirección al final va a ser 0x, seguido por af, porque eso es 32 bits,

1054
01:05:05,390 --> 01:05:10,890
que es de 8 bytes, y en este caso 8 bytes corresponde a 8 dígitos hexadecimales.

1055
01:05:10,890 --> 01:05:20,110
Así que aquí va a tener, como, 0xffffff, y allí vas a tener 0.

1056
01:05:20,110 --> 01:05:23,660
¿Cuáles son los punteros? Algunos de ustedes no han cubierto esto en la sección anterior.

1057
01:05:23,660 --> 01:05:26,660
pero sí que fuimos a través de ella en la conferencia, por lo que un puntero es sólo un tipo de datos

1058
01:05:26,660 --> 01:05:34,030
que almacena, en lugar de algún tipo de valor como 50, que almacena la dirección de algún lugar en la memoria.

1059
01:05:34,030 --> 01:05:36,020
Al igual que la memoria [ininteligible].

1060
01:05:36,020 --> 01:05:41,120
Así que en este caso, lo que tenemos es, tenemos un puntero a un entero o un int *,

1061
01:05:41,120 --> 01:05:46,210
y contiene la siguiente dirección hexadecimal de 0xLOQUESEA.

1062
01:05:46,210 --> 01:05:50,880
>> Así que lo que tenemos es, ahora, este puntero en algún lugar de la memoria,

1063
01:05:50,880 --> 01:05:56,020
y eso es sólo una, el valor 50 está en esta posición de memoria.

1064
01:05:56,020 --> 01:06:01,810
En algunos sistemas de 32-bit, en todos los sistemas de 32-bit, los punteros ocupan 32 bits o 4 bytes.

1065
01:06:01,810 --> 01:06:06,020
Pero, por ejemplo, en un sistema de 64-bit, los punteros son de 64 bits.

1066
01:06:06,020 --> 01:06:08,040
Así que eso es algo que usted querrá tener en cuenta.

1067
01:06:08,040 --> 01:06:12,310
Así en un sistema de extremo de bits, un puntero es cantoneras de largo.

1068
01:06:12,310 --> 01:06:17,320
Los punteros son un poco difícil de digerir sin cosas extras,

1069
01:06:17,320 --> 01:06:20,300
así que vamos a ir a través de un ejemplo de asignación de memoria dinámica.

1070
01:06:20,300 --> 01:06:25,130
¿Qué asignación de memoria dinámica hace por usted, o lo que llamamos malloc,

1071
01:06:25,130 --> 01:06:29,280
le permite asignar un tipo de datos fuera del set.

1072
01:06:29,280 --> 01:06:31,830
Así que este tipo de datos es más permanente para la duración del programa.

1073
01:06:31,830 --> 01:06:36,430
Porque, como usted sabe, si usted declara x dentro de una función, y que recupera el funcionamiento,

1074
01:06:36,430 --> 01:06:40,910
que ya no tienen acceso a los datos almacenados en x.

1075
01:06:40,910 --> 01:06:44,420
¿Qué indicadores vamos a hacer es que vamos a almacenar los valores de la memoria o la tienda

1076
01:06:44,420 --> 01:06:46,840
en un segmento diferente de la memoria, es decir, el montón.

1077
01:06:46,840 --> 01:06:49,340
Ahora, una vez que regresemos de la función, siempre que tenemos un puntero

1078
01:06:49,340 --> 01:06:54,960
a esa ubicación en la memoria, entonces lo que podemos hacer es simplemente podemos ver los valores allí.

1079
01:06:54,960 --> 01:06:58,020
Veamos un ejemplo: Este es nuestro nuevo diseño de la memoria.

1080
01:06:58,020 --> 01:07:00,050
Y tenemos esta función principal.

1081
01:07:00,050 --> 01:07:06,870
Lo que hace es - está bien, tan simple, derecho - int x = 5, que es sólo una variable en la pila en principal.

1082
01:07:06,870 --> 01:07:12,450
>> Por otro lado, ahora se declara un puntero que llama a los giveMeThreeInts función.

1083
01:07:12,450 --> 01:07:16,800
Y ahora entramos en esta función y se crea un nuevo marco de pila para ello.

1084
01:07:16,800 --> 01:07:20,440
Sin embargo, en este marco de pila, declaramos int * temp,

1085
01:07:20,440 --> 01:07:23,210
que en mallocs 3 enteros para nosotros.

1086
01:07:23,210 --> 01:07:25,880
Así que el tamaño de int nos dará la cantidad de bytes esto es int,

1087
01:07:25,880 --> 01:07:29,620
malloc y nos da que muchos bytes de espacio en el montón.

1088
01:07:29,620 --> 01:07:32,890
Así que en este caso, hemos creado un espacio suficiente para 3 números enteros,

1089
01:07:32,890 --> 01:07:36,830
y el montón está ahí arriba, y por eso lo he dibujado más arriba.

1090
01:07:36,830 --> 01:07:42,900
Una vez que hayas terminado, volvemos aquí, sólo necesita 3 enteros devueltos,

1091
01:07:42,900 --> 01:07:47,000
y devuelve la dirección, en este caso más que donde la memoria es.

1092
01:07:47,000 --> 01:07:51,250
Y nos pusimos puntero = interruptor, y allí tenemos más que otro puntero.

1093
01:07:51,250 --> 01:07:54,550
Pero lo que devuelve la función se apila aquí, y desaparece.

1094
01:07:54,550 --> 01:07:59,250
Así temperatura desaparece, pero todavía mantienen la dirección de donde

1095
01:07:59,250 --> 01:08:01,850
esos 3 números enteros se encuentran dentro de la red.

1096
01:08:01,850 --> 01:08:06,180
Así que en este juego, los punteros están en el ámbito local para el marco de apilado,

1097
01:08:06,180 --> 01:08:09,860
pero la memoria a la que se refieren es en el montón.

1098
01:08:09,860 --> 01:08:12,190
>> ¿Eso tiene sentido?

1099
01:08:12,190 --> 01:08:14,960
[Estudiante] ¿Podría repetir eso? >> [Joseph] Sí.

1100
01:08:14,960 --> 01:08:20,270
Así que si me vuelvo un poco, se ve que la temperatura asignada

1101
01:08:20,270 --> 01:08:23,500
parte de la memoria en el montón hasta allí.

1102
01:08:23,500 --> 01:08:28,680
Por eso, cuando esta función, giveMeThreeInts devoluciones, esta pila de aquí va a desaparecer.

1103
01:08:28,680 --> 01:08:35,819
Y con ello ninguna de las variables, en este caso, este puntero que se ha asignado en el marco de apilado.

1104
01:08:35,819 --> 01:08:39,649
Eso va a desaparecer, pero desde que regresamos temp

1105
01:08:39,649 --> 01:08:46,330
y nos pusimos puntero = temp, puntero ahora va a apuntar la misma memoria de la ubicación como la temperatura era.

1106
01:08:46,330 --> 01:08:50,370
Así que ahora, a pesar de que pierda temperatura, ese puntero local,

1107
01:08:50,370 --> 01:08:59,109
que aún conservan la dirección de memoria de lo que estaba señalando hacia el interior de ese indicador variable.

1108
01:08:59,109 --> 01:09:03,740
¿Preguntas? Eso puede ser un poco de un tema confuso si usted no ha pasado por encima de la sección.

1109
01:09:03,740 --> 01:09:09,240
Podemos, su TF duda alguna sobre el mismo y, por supuesto, podemos responder a las preguntas

1110
01:09:09,240 --> 01:09:11,500
al final de la sesión de revisión para esto.

1111
01:09:11,500 --> 01:09:14,220
Pero esto es una especie de un tema complejo, y no tengo más ejemplos que van a aparecer

1112
01:09:14,220 --> 01:09:18,790
que ayudará a aclarar lo que en realidad son punteros.

1113
01:09:18,790 --> 01:09:22,500
>> En este caso, los punteros son equivalentes a las matrices,

1114
01:09:22,500 --> 01:09:25,229
por lo que sólo puede utilizar este indicador como la misma cosa como una matriz int.

1115
01:09:25,229 --> 01:09:29,840
Así que estoy de indización en 0, y cambiando el primer número entero de 1,

1116
01:09:29,840 --> 01:09:39,689
cambiando el segundo número entero de 2, y el entero tercero a 3.

1117
01:09:39,689 --> 01:09:44,210
Así que más de punteros. Bueno, recuerdo Binky.

1118
01:09:44,210 --> 01:09:48,319
En este caso hemos asignado un puntero, o que declaramos un puntero,

1119
01:09:48,319 --> 01:09:52,760
pero al principio, cuando me acaba de declarar un puntero, no está apuntando a cualquier parte de la memoria.

1120
01:09:52,760 --> 01:09:54,930
Son sólo los valores de basura en el interior de la misma.

1121
01:09:54,930 --> 01:09:56,470
Así que no tengo idea de donde este indicador está apuntando.

1122
01:09:56,470 --> 01:10:01,630
Tiene una dirección que se acaba de llenar con 0 y 1, donde se declaró inicialmente.

1123
01:10:01,630 --> 01:10:04,810
No puedo hacer nada con esto hasta que yo llamo malloc en él

1124
01:10:04,810 --> 01:10:08,390
y luego me da un poco de espacio en el montón donde puedo poner los valores en el interior.

1125
01:10:08,390 --> 01:10:11,980
Por otra parte, yo no sé lo que hay dentro de esta memoria.

1126
01:10:11,980 --> 01:10:16,780
Así que lo primero que tienes que hacer es comprobar si el sistema tiene suficiente memoria

1127
01:10:16,780 --> 01:10:20,850
que me devuelva un número entero, en primer lugar, por lo que yo estoy haciendo esta comprobación.

1128
01:10:20,850 --> 01:10:25,020
Si el puntero es nulo, lo que significa que no tiene suficiente espacio o algún otro error,

1129
01:10:25,020 --> 01:10:26,320
así que debería salir de mi programa.

1130
01:10:26,320 --> 01:10:29,400
 Pero si se tuvo éxito, ahora puedo usar ese puntero

1131
01:10:29,400 --> 01:10:35,020
y lo que hace es * puntero se deduce que la dirección es

1132
01:10:35,020 --> 01:10:38,480
a donde ese valor es, y lo pone igual a 1.

1133
01:10:38,480 --> 01:10:41,850
Así que aquí, estamos comprobando si dicha memoria existido.

1134
01:10:41,850 --> 01:10:45,380
>> Una vez que se sabe que existe, puede poner en él

1135
01:10:45,380 --> 01:10:50,460
cuál es el valor que desea poner en él, en este caso 1.

1136
01:10:50,460 --> 01:10:53,060
Una vez que haya terminado con ella, la necesidad de liberar ese puntero

1137
01:10:53,060 --> 01:10:57,160
porque tenemos que volver al sistema que la memoria que usted solicitó en primer lugar.

1138
01:10:57,160 --> 01:10:59,690
Debido a que el equipo no sabe cuando hayamos terminado con él.

1139
01:10:59,690 --> 01:11:02,510
En este caso estamos diciendo explícitamente, está bien, hemos terminado con esa memoria.

1140
01:11:02,510 --> 01:11:10,780
Si algún otro proceso que necesita, algún otro programa que necesita, no dude en seguir adelante y tomarlo.

1141
01:11:10,780 --> 01:11:15,110
Lo que también se puede hacer es que sólo se puede obtener la dirección de las variables locales en el set.

1142
01:11:15,110 --> 01:11:19,080
Así int x está dentro del marco de apilado principal.

1143
01:11:19,080 --> 01:11:23,060
Y cuando utilizamos este signo, este y el operador, lo que hace es

1144
01:11:23,060 --> 01:11:27,310
Se tarda x, y x es sólo algunos datos en la memoria, pero que tiene una dirección.

1145
01:11:27,310 --> 01:11:33,790
Se encuentra ubicado en algún lugar. Entonces, llamando & x, lo que esto hace es que nos da la dirección de x.

1146
01:11:33,790 --> 01:11:38,430
Al hacer esto, estamos haciendo puntero al punto donde x está en la memoria.

1147
01:11:38,430 --> 01:11:41,710
Ahora sólo nos queda hacer algo como * x, vamos a llegar al 5 de vuelta.

1148
01:11:41,710 --> 01:11:43,820
La estrella se llama eliminación de referencias a él.

1149
01:11:43,820 --> 01:11:46,640
Siga la dirección y se obtiene el valor de la misma se almacena allí.

1150
01:11:51,000 --> 01:11:53,310
>> ¿Alguna pregunta? ¿Sí?

1151
01:11:53,310 --> 01:11:56,500
[Estudiante] Si usted no hace la cosa tres puntas, ¿sigue teniendo compilar?

1152
01:11:56,500 --> 01:11:59,490
Sí. Si usted no hace la cosa de 3-puntos, que todavía va a compilar,

1153
01:11:59,490 --> 01:12:02,720
pero te voy a mostrar lo que pasa en un segundo, y sin hacer eso,

1154
01:12:02,720 --> 01:12:04,860
eso es lo que llamamos una pérdida de memoria. Usted no está dando el sistema

1155
01:12:04,860 --> 01:12:07,850
copias de su memoria, así que después de un tiempo el programa se va a acumular

1156
01:12:07,850 --> 01:12:10,940
memoria que no está utilizando, y nada más pueda usarlo.

1157
01:12:10,940 --> 01:12:15,750
Si alguna vez has visto a Firefox con 1,5 millones de kilobytes en su computadora,

1158
01:12:15,750 --> 01:12:17,840
en el administrador de tareas, eso es lo que está pasando.

1159
01:12:17,840 --> 01:12:20,760
Usted tiene una pérdida de memoria en el programa que no está manejando.

1160
01:12:23,080 --> 01:12:26,240
Entonces, ¿cómo hace el trabajo puntero aritmética?

1161
01:12:26,240 --> 01:12:29,480
Bueno, la aritmética de punteros es una especie de indexación como en una matriz.

1162
01:12:29,480 --> 01:12:36,370
En este caso, tengo un puntero, y lo que yo hago es hacer punto puntero al primer elemento

1163
01:12:36,370 --> 01:12:42,100
de esta serie de tres números enteros que he asignado.

1164
01:12:42,100 --> 01:12:46,670
¿Y ahora qué hago, puntero estrella sólo cambia el primer elemento de la lista.

1165
01:12:46,670 --> 01:12:49,140
Estrella puntero +1 puntos aquí.

1166
01:12:49,140 --> 01:12:53,140
Así puntero está por aquí, un puntero es por aquí, puntero +2 es por aquí.

1167
01:12:53,140 --> 01:12:56,610
>> Así sólo añadir 1 es lo mismo que mover a lo largo de esta matriz.

1168
01:12:56,610 --> 01:12:59,880
Lo que hacemos es, cuando hacemos un puntero a obtener la dirección por aquí,

1169
01:12:59,880 --> 01:13:04,180
y con el fin de obtener el valor de aquí, se pone una estrella en toda la expresión de

1170
01:13:04,180 --> 01:13:05,990
para eliminación de referencias.

1171
01:13:05,990 --> 01:13:09,940
Así, en este caso, me estoy dando el primer lugar en esta matriz a 1,

1172
01:13:09,940 --> 01:13:13,970
ubicación a 2 segundos, y tercera ubicación a 3.

1173
01:13:13,970 --> 01:13:18,180
Entonces, ¿qué estoy haciendo aquí es que estoy imprimiendo nuestro puntero +1,

1174
01:13:18,180 --> 01:13:19,970
que sólo me da 2.

1175
01:13:19,970 --> 01:13:23,650
Ahora estoy incrementando puntero, por lo que es igual puntero puntero +1,

1176
01:13:23,650 --> 01:13:26,780
que se mueve hacia delante.

1177
01:13:26,780 --> 01:13:30,810
Y ahora si me imprima un puntero, puntero +1 es ahora 3 años,

1178
01:13:30,810 --> 01:13:33,990
que en este caso se imprime 3.

1179
01:13:33,990 --> 01:13:36,560
Y para algo gratis, el puntero que le doy

1180
01:13:36,560 --> 01:13:40,540
debe apuntar al principio de la matriz que volví de malloc.

1181
01:13:40,540 --> 01:13:43,430
Así que, en este caso, si yo tuviera que llamar 3 aquí, esto no sería correcto,

1182
01:13:43,430 --> 01:13:45,070
porque está en el centro de la matriz.

1183
01:13:45,070 --> 01:13:48,820
Tengo que resta para llegar a la ubicación original

1184
01:13:48,820 --> 01:13:50,420
el acto inicial antes de que pueda liberarlo.

1185
01:13:56,300 --> 01:13:58,450
Por lo tanto, aquí hay un ejemplo más complicado.

1186
01:13:58,450 --> 01:14:03,360
En este caso, estamos asignando 7 caracteres en una matriz de caracteres.

1187
01:14:03,360 --> 01:14:06,480
>> Y en este caso lo que estamos haciendo es que estamos recorrer los 6 primeros de ellos,

1188
01:14:06,480 --> 01:14:09,900
y los estamos estableciendo a la Z.

1189
01:14:09,900 --> 01:14:13,350
Así, por int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Por lo tanto, el puntero + i sólo nos dará, en este caso,

1191
01:14:16,220 --> 01:14:20,860
puntero, puntero +1, 2 puntero, puntero 3, y así sucesivamente y así sucesivamente en el bucle.

1192
01:14:20,860 --> 01:14:24,040
¿Qué va a hacer es que llegue esa dirección, desreferencia para obtener el valor,

1193
01:14:24,040 --> 01:14:27,440
y que los cambios a un valor Z.

1194
01:14:27,440 --> 01:14:30,350
Luego, al final recuerda que esto es una cadena, ¿no?

1195
01:14:30,350 --> 01:14:33,560
Todas las cadenas tienen que terminar con el carácter nulo de terminación.

1196
01:14:33,560 --> 01:14:38,620
Por lo tanto, lo que hago es en puntero 6 puse el carácter terminador nulo pulg

1197
01:14:38,620 --> 01:14:43,980
Y ahora lo que estoy haciendo básicamente aquí está implementando printf para una cadena, ¿no?

1198
01:14:43,980 --> 01:14:46,190
>> Así que, ¿cuándo printf ahora cuando se ha llegado al final de una cadena?

1199
01:14:46,190 --> 01:14:48,230
Cuando llegue el carácter nulo de terminación.

1200
01:14:48,230 --> 01:14:52,030
Así, en este caso, mis puntos puntero original al principio de esta matriz.

1201
01:14:52,030 --> 01:14:56,410
Puedo imprimir el carácter primero en salir. Lo muevo a través de uno.

1202
01:14:56,410 --> 01:14:58,420
Puedo imprimir ese personaje. Lo muevo de nuevo.

1203
01:14:58,420 --> 01:15:02,180
Y sigo haciendo esto hasta que llegue al final.

1204
01:15:02,180 --> 01:15:07,750
Y ahora el puntero * Final voluntad dereference esto y el carácter nulo de terminación de vuelta.

1205
01:15:07,750 --> 01:15:11,780
Y así mi bucle while se ejecuta sólo cuando ese valor no es el carácter nulo de terminación.

1206
01:15:11,780 --> 01:15:13,770
Así que, ahora salgo de este bucle.

1207
01:15:18,780 --> 01:15:21,180
Y por lo que si le resto 6 de este indicador,

1208
01:15:21,180 --> 01:15:22,860
Vuelvo hasta el final hasta el principio.

1209
01:15:22,860 --> 01:15:27,880
Recuerda, yo estoy haciendo esto porque tengo que ir al principio con el fin de liberarla.

1210
01:15:27,880 --> 01:15:30,270
>> Por lo tanto, sé que era mucho. ¿Hay alguna pregunta?

1211
01:15:30,270 --> 01:15:31,870
Por favor, ¿sí?

1212
01:15:31,870 --> 01:15:36,610
[Ininteligible pregunta Estudiante]

1213
01:15:36,610 --> 01:15:38,190
¿Se puede decir que más fuerte? Lo siento.

1214
01:15:38,190 --> 01:15:44,140
[Estudiante] En la última diapositiva justo antes de que liberó al puntero,

1215
01:15:44,140 --> 01:15:47,300
donde estabas realmente cambiar el valor del puntero?

1216
01:15:47,300 --> 01:15:50,370
[José] Por lo tanto, aquí mismo. >> [Estudiante] Oh, está bien.

1217
01:15:50,370 --> 01:15:51,890
[José] Por lo tanto, tengo un puntero menos negativo, derecha,

1218
01:15:51,890 --> 01:15:54,140
que mueve la cosa de nuevo, y luego lo libere,

1219
01:15:54,140 --> 01:15:57,000
porque este puntero tiene que ser señalado al principio de la matriz.

1220
01:15:57,000 --> 01:16:00,420
[Estudiante] Pero eso no sería necesario que se detuvo después de esa línea.

1221
01:16:00,420 --> 01:16:03,130
[José] Así que, si me hubiera detenido después de esto, esto sería considerado una pérdida de memoria,

1222
01:16:03,130 --> 01:16:04,810
porque no se ha ejecutado el programa gratuito.

1223
01:16:04,810 --> 01:16:11,290
[Estudiante] I [ininteligible] después de las tres primeras líneas donde tenías puntero +1 [ininteligible].

1224
01:16:11,290 --> 01:16:13,140
[José] Uh-huh. Entonces, ¿cuál es la pregunta que hay?

1225
01:16:13,140 --> 01:16:14,780
Lo siento. No, no. Vaya, vaya, por favor.

1226
01:16:14,780 --> 01:16:16,870
[Estudiante] Por lo tanto, no estamos cambiando el valor de punteros.

1227
01:16:16,870 --> 01:16:19,130
No habría tenido que hacer puntero menos negativo.

1228
01:16:19,130 --> 01:16:19,730
[José] Sí, exactamente.

1229
01:16:19,730 --> 01:16:21,890
Por lo tanto, cuando hago un puntero y el puntero +2,

1230
01:16:21,890 --> 01:16:24,410
No voy a hacer puntero es igual a un puntero.

1231
01:16:24,410 --> 01:16:27,260
Por lo tanto, el puntero sólo se queda apuntando al principio de la matriz.

1232
01:16:27,260 --> 01:16:31,460
Es sólo cuando lo hago plus plus que establece el valor de nuevo en el puntero,

1233
01:16:31,460 --> 01:16:33,550
que en realidad se mueve a lo largo de este.

1234
01:16:36,860 --> 01:16:37,780
Está bien.

1235
01:16:40,550 --> 01:16:42,030
Más preguntas?

1236
01:16:44,680 --> 01:16:47,790
>> Una vez más, si esto es una especie de insoportable, esto se tratará en la sesión.

1237
01:16:47,790 --> 01:16:50,710
Pregúntele a su compañero de enseñanza en ello, y podemos responder a las preguntas al final.

1238
01:16:53,510 --> 01:16:56,600
Y por lo general no nos gusta que hagas esto menos.

1239
01:16:56,600 --> 01:16:59,760
Esto tiene que me exigen hacer el seguimiento de lo mucho que he posición de la matriz.

1240
01:16:59,760 --> 01:17:04,520
Así que, en general, esto es sólo para explicar cómo funciona la aritmética de punteros.

1241
01:17:04,520 --> 01:17:07,970
Pero lo que normalmente queremos hacer es que nos gusta para crear una copia del puntero,

1242
01:17:07,970 --> 01:17:11,640
y luego vamos a utilizar esa copia cuando nos movemos alrededor de la cadena.

1243
01:17:11,640 --> 01:17:14,660
Por lo tanto, en estos casos se utiliza la copia para imprimir toda la cadena,

1244
01:17:14,660 --> 01:17:19,040
pero no tenemos que hacer como puntero menos 6 o llevar un registro de cuánto nos trasladamos en esto,

1245
01:17:19,040 --> 01:17:22,700
sólo porque sabemos que nuestro punto original sigue señaló el comienzo de la lista

1246
01:17:22,700 --> 01:17:25,340
y todo lo que fue alterado esta copia.

1247
01:17:25,340 --> 01:17:28,250
Así, en general, modificar las copias de su puntero original.

1248
01:17:28,250 --> 01:17:32,350
No trate de algo así como - no alterar las copias originales.

1249
01:17:32,350 --> 01:17:35,290
Tratar de alterar únicas copias de su original.

1250
01:17:41,540 --> 01:17:44,870
Así, se da cuenta cuando pasamos la cadena en printf

1251
01:17:44,870 --> 01:17:48,990
usted no tiene que poner una estrella en la frente de ella como lo hicimos con todos los desreferencia otros, ¿no?

1252
01:17:48,990 --> 01:17:54,180
Por lo tanto, si imprime la cadena s% espera que todo es una dirección,

1253
01:17:54,180 --> 01:17:57,610
y en este caso un puntero o en este caso como una matriz de caracteres.

1254
01:17:57,610 --> 01:18:00,330
>> Personajes, char * s, y las matrices son la misma cosa.

1255
01:18:00,330 --> 01:18:03,690
Pointer es caracteres y matrices de caracteres son la misma cosa.

1256
01:18:03,690 --> 01:18:05,720
Y así, todo lo que tenemos que hacer es pasar puntero.

1257
01:18:05,720 --> 01:18:08,150
No tenemos que pasar como puntero * ni nada de eso.

1258
01:18:13,110 --> 01:18:14,930
Por lo tanto, las matrices y los punteros son la misma cosa.

1259
01:18:14,930 --> 01:18:19,160
Cuando estás haciendo algo como x [y] por aquí por una matriz,

1260
01:18:19,160 --> 01:18:21,960
lo que está haciendo bajo el capó es lo que está diciendo, está bien, se trata de una matriz de caracteres,

1261
01:18:21,960 --> 01:18:23,690
por lo que es un puntero.

1262
01:18:23,690 --> 01:18:26,510
Y así, x son la misma cosa,

1263
01:18:26,510 --> 01:18:28,650
y por lo tanto lo que hace es que añade yax,

1264
01:18:28,650 --> 01:18:31,820
lo que es lo mismo que mover hacia adelante en la memoria que mucho.

1265
01:18:31,820 --> 01:18:34,930
Y ahora x + y nos da algún tipo de dirección,

1266
01:18:34,930 --> 01:18:37,570
y eliminar la referencia al domicilio o siga la flecha

1267
01:18:37,570 --> 01:18:41,640
a donde esa ubicación en la memoria es y obtenemos el valor de dicha ubicación en la memoria.

1268
01:18:41,640 --> 01:18:43,720
Así, por lo que estos dos son exactamente la misma cosa.

1269
01:18:43,720 --> 01:18:45,840
Es sólo una manera de expresar.

1270
01:18:45,840 --> 01:18:48,090
Ellos hacen lo mismo. Son sólo sintáctica diferentes entre sí.

1271
01:18:51,500 --> 01:18:57,590
>> Así que, ¿qué puede ir mal con punteros? Al igual, mucho. Bien. Así, las cosas malas.

1272
01:18:57,590 --> 01:19:02,410
Algunas de las cosas malas que puede hacer no está comprobando si su llamada malloc devuelve un valor nulo, ¿no?

1273
01:19:02,410 --> 01:19:06,560
En este caso, estoy pidiendo al sistema que me diera - ¿Cuál es ese número?

1274
01:19:06,560 --> 01:19:11,200
Como 2 mil millones de veces 4, debido a que el tamaño de un entero de 4 bytes.

1275
01:19:11,200 --> 01:19:13,810
Lo estoy pidiendo como 8 millones de bytes.

1276
01:19:13,810 --> 01:19:17,270
Por supuesto, mi equipo no va a ser capaz de darme vuelta que mucha memoria.

1277
01:19:17,270 --> 01:19:20,960
Y no comprobar si este es nulo, por lo que cuando tratamos de eliminar la referencia que allí -

1278
01:19:20,960 --> 01:19:24,270
siga la flecha a donde se va a - no tenemos esa memoria.

1279
01:19:24,270 --> 01:19:27,150
Esto es lo que llamamos la eliminación de referencias a un puntero nulo.

1280
01:19:27,150 --> 01:19:29,710
Y esto hace que esencialmente violación de segmento.

1281
01:19:29,710 --> 01:19:31,790
Esta es una de las formas en que puedes violación de segmento.

1282
01:19:34,090 --> 01:19:38,090
Otras cosas malas que usted puede hacer - bueno.

1283
01:19:38,090 --> 01:19:40,650
Eso fue desreferencia un puntero nulo. Bien.

1284
01:19:40,650 --> 01:19:45,160
Otras cosas malas - bueno, al fijar que usted acaba de poner un cheque en allí

1285
01:19:45,160 --> 01:19:46,980
que comprueba si el puntero es nulo

1286
01:19:46,980 --> 01:19:51,000
y salir del programa si ocurre que malloc devuelve un puntero nulo.

1287
01:19:55,110 --> 01:19:59,850
Ese es el cómic xkcd. La gente lo entiendo ahora. Casi.

1288
01:20:06,120 --> 01:20:09,350
>> Así, la memoria. Y me fui por esto.

1289
01:20:09,350 --> 01:20:12,000
Estamos llamando a malloc en un bucle, pero cada vez que llamamos a malloc

1290
01:20:12,000 --> 01:20:14,370
estamos perdiendo la pista de donde este indicador hace referencia,

1291
01:20:14,370 --> 01:20:15,750
porque lo estamos golpeando fuertemente.

1292
01:20:15,750 --> 01:20:18,410
Por lo tanto, la primera llamada a malloc me da memoria aquí.

1293
01:20:18,410 --> 01:20:19,990
Mis punteros punteros a esto.

1294
01:20:19,990 --> 01:20:23,020
Ahora, yo no lo liberará, así que ahora yo llamo malloc nuevo.

1295
01:20:23,020 --> 01:20:26,070
Ahora apunta hacia aquí. Ahora mi memoria apunta hasta aquí.

1296
01:20:26,070 --> 01:20:27,640
Apuntando hacia aquí. Apuntando hacia aquí.

1297
01:20:27,640 --> 01:20:31,820
Pero he perdido la cuenta de las direcciones de toda la memoria por aquí que me asignaron.

1298
01:20:31,820 --> 01:20:35,100
Y ahora no tengo ninguna referencia a ellos nunca más.

1299
01:20:35,100 --> 01:20:37,230
Por lo tanto, no puedo liberarlos fuera de este bucle.

1300
01:20:37,230 --> 01:20:39,390
Y así, con el fin de fijar algo como esto,

1301
01:20:39,390 --> 01:20:42,250
si se olvida de la memoria libre y se obtiene esta pérdida de memoria,

1302
01:20:42,250 --> 01:20:45,810
Hay que liberar la memoria dentro de este bucle una vez que haya terminado con él.

1303
01:20:45,810 --> 01:20:51,400
Bueno, esto es lo que sucede. Sé que muchos de ustedes odian esto.

1304
01:20:51,400 --> 01:20:55,270
Pero ahora - yay! Se obtiene como 44.000 kilobytes.

1305
01:20:55,270 --> 01:20:57,110
Así, que se libre en el extremo del bucle,

1306
01:20:57,110 --> 01:20:59,770
y eso va a liberar sólo la memoria cada vez.

1307
01:20:59,770 --> 01:21:03,620
En esencia, el programa no tiene una pérdida de memoria más.

1308
01:21:03,620 --> 01:21:08,150
>> Y ahora otra cosa que puedes hacer es liberar la memoria que usted ha pedido dos veces.

1309
01:21:08,150 --> 01:21:11,060
En este caso, es algo malloc, cambia su valor.

1310
01:21:11,060 --> 01:21:13,140
Usted se libre una vez porque dijiste que habías terminado con ella.

1311
01:21:13,140 --> 01:21:14,940
Pero luego lo liberó de nuevo.

1312
01:21:14,940 --> 01:21:16,730
Esto es algo que es bastante malo.

1313
01:21:16,730 --> 01:21:18,820
No va a violación de segmento al principio,

1314
01:21:18,820 --> 01:21:23,350
pero después de un rato lo que esto hace es liberar esta doble corrompe la estructura de montón,

1315
01:21:23,350 --> 01:21:27,200
y usted aprenderá un poco más sobre esto si usted decide tomar una clase como CS61.

1316
01:21:27,200 --> 01:21:30,000
Pero esencialmente después de un tiempo el equipo va a confundirse

1317
01:21:30,000 --> 01:21:33,010
acerca de lo que las posiciones de memoria donde están y hacia dónde se almacena -

1318
01:21:33,010 --> 01:21:34,800
donde los datos se almacenan en la memoria.

1319
01:21:34,800 --> 01:21:38,080
Y así liberar un puntero dos veces es una mala cosa que no quiero hacer.

1320
01:21:38,080 --> 01:21:41,600
>> Otras cosas que pueden salir mal no está usando sizeof.

1321
01:21:41,600 --> 01:21:44,460
Así que, en este caso malloc 8 bytes,

1322
01:21:44,460 --> 01:21:46,700
y eso es lo mismo que dos enteros, ¿no?

1323
01:21:46,700 --> 01:21:49,580
Entonces, eso es perfectamente seguro, pero lo es?

1324
01:21:49,580 --> 01:21:52,160
Bueno, como Lucas habló sobre diferentes arquitecturas,

1325
01:21:52,160 --> 01:21:54,220
enteros son de longitudes diferentes.

1326
01:21:54,220 --> 01:21:57,970
Por lo tanto, el aparato que está utilizando, los enteros son alrededor de 4 bytes,

1327
01:21:57,970 --> 01:22:02,370
pero en algún otro sistema que podría ser de 8 bytes o pueden ser 16 bytes.

1328
01:22:02,370 --> 01:22:05,680
Por lo tanto, si sólo utilizan este número para acá,

1329
01:22:05,680 --> 01:22:07,310
este programa puede trabajar en el aparato,

1330
01:22:07,310 --> 01:22:10,360
pero no va a asignar suficiente memoria en algún otro sistema.

1331
01:22:10,360 --> 01:22:14,020
En este caso, esto es lo que el operador sizeof se utiliza para.

1332
01:22:14,020 --> 01:22:16,880
Cuando llamamos a sizeof (int), lo que hace es

1333
01:22:16,880 --> 01:22:21,910
 que nos da el tamaño de un entero en el sistema que se ejecuta el programa.

1334
01:22:21,910 --> 01:22:25,490
Así, en este caso, sizeof (int) devolverá 4 en algo como el aparato,

1335
01:22:25,490 --> 01:22:29,980
y ahora esta voluntad 4 * 2, que es 8,

1336
01:22:29,980 --> 01:22:32,330
que es sólo la cantidad de espacio necesario para dos enteros.

1337
01:22:32,330 --> 01:22:36,710
En un sistema diferente, si un entero es como 16 bytes u 8 bytes

1338
01:22:36,710 --> 01:22:39,380
que sólo va a volver suficientes bytes para almacenar esa cantidad.

1339
01:22:41,830 --> 01:22:45,310
>> Y, por último, las estructuras.

1340
01:22:45,310 --> 01:22:48,340
Por lo tanto, si desea almacenar una tabla de sudoku en la memoria, ¿cómo podemos hacer esto?

1341
01:22:48,340 --> 01:22:51,570
Se podría pensar en como una variable para la primera cosa,

1342
01:22:51,570 --> 01:22:53,820
una variable para la segunda cosa, una variable para la tercera cosa,

1343
01:22:53,820 --> 01:22:56,420
una variable para la cuarta cosa - malo, ¿verdad?

1344
01:22:56,420 --> 01:23:00,750
Por lo tanto, una mejora que usted puede hacer sobre esto es hacer una matriz de 9 x 9.

1345
01:23:00,750 --> 01:23:04,480
Eso está bien, pero lo que si desea asociar otras cosas con la tarjeta de sudoku

1346
01:23:04,480 --> 01:23:06,490
como lo que la dificultad de la junta es,

1347
01:23:06,490 --> 01:23:11,740
o, por ejemplo, cuál es su puntaje es, o cuánto tiempo ha tomado usted para resolver este foro?

1348
01:23:11,740 --> 01:23:14,970
Bueno, lo que puedo hacer es que usted puede crear una estructura.

1349
01:23:14,970 --> 01:23:18,910
Lo que estoy diciendo es, básicamente, estoy definiendo esta estructura por aquí,

1350
01:23:18,910 --> 01:23:23,230
y estoy definiendo un tablero de sudoku que consiste en una placa que es 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> Y lo que tiene que tiene punteros a el nombre del nivel.

1352
01:23:26,650 --> 01:23:30,730
También cuenta con x e y, que son las coordenadas de donde estoy en estos momentos.

1353
01:23:30,730 --> 01:23:35,980
También ha tiempo pasado [ininteligible], y tiene el número total de movimientos que he ofrecida hasta ahora.

1354
01:23:35,980 --> 01:23:40,010
Y así, en este caso, puede agrupar una gran cantidad de datos en una sola estructura

1355
01:23:40,010 --> 01:23:42,790
en vez de tenerlo como volar alrededor de la misma distintas variables

1356
01:23:42,790 --> 01:23:44,540
que en realidad no puedo seguir la pista.

1357
01:23:44,540 --> 01:23:49,720
Y esto nos permite tener sólo sintaxis agradable para hacer referencia a una especie de cosas diferentes dentro de esta estructura.

1358
01:23:49,720 --> 01:23:53,430
Yo sólo puedo hacer board.board, y me sale el tablero sudoku espalda.

1359
01:23:53,430 --> 01:23:56,320
Board.level, me sale lo difícil que es.

1360
01:23:56,320 --> 01:24:00,540
Board.x board.y y me dan las coordenadas de dónde podría estar en el tablero.

1361
01:24:00,540 --> 01:24:04,730
Y, entonces, acceder a lo que llamamos campos de la estructura.

1362
01:24:04,730 --> 01:24:08,840
Esto define sudokuBoard, que es un tipo que tengo.

1363
01:24:08,840 --> 01:24:14,800
Y ahora estamos aquí. Tengo una variable llamada "junta" de sudokuBoard tipo.

1364
01:24:14,800 --> 01:24:18,820
Y así que ahora puedo acceder a todos los campos que componen esta estructura aquí.

1365
01:24:20,830 --> 01:24:22,450
>> Cualquier pregunta acerca de las estructuras? ¿Sí?

1366
01:24:22,450 --> 01:24:25,890
[Estudiante] Para int x, y, a la vez que declaró en una línea? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Estudiante] Así que, ¿puedes hacer eso con todos ellos?

1368
01:24:27,400 --> 01:24:31,200
Al igual que en x, Y coma veces que el total?

1369
01:24:31,200 --> 01:24:34,460
[José] Sí, definitivamente se puede hacer eso, pero la razón por la que poner x e y en la misma línea -

1370
01:24:34,460 --> 01:24:36,330
y la pregunta es ¿por qué sólo podemos hacer esto en la misma línea?

1371
01:24:36,330 --> 01:24:38,600
¿Por qué no sólo hay que poner todo esto en la misma línea es

1372
01:24:38,600 --> 01:24:42,090
x e y se relacionan entre sí,

1373
01:24:42,090 --> 01:24:44,780
y esto es sólo estilísticamente más correcto, en cierto sentido,

1374
01:24:44,780 --> 01:24:46,600
porque es agrupar dos cosas en la misma línea

1375
01:24:46,600 --> 01:24:49,340
ese tipo de como se refieren a la misma cosa.

1376
01:24:49,340 --> 01:24:51,440
Y me acaba de romper estos pedazos. Es sólo una cosa estilo.

1377
01:24:51,440 --> 01:24:53,720
Es funcionalmente no hace ninguna diferencia en absoluto.

1378
01:24:58,150 --> 01:24:59,270
Cualquier otra pregunta sobre las estructuras?

1379
01:25:03,030 --> 01:25:06,620
Se puede definir una Pokédex con una estructura.

1380
01:25:06,620 --> 01:25:11,720
Un Pokémon tiene un número y tiene una carta, un propietario, un tipo.

1381
01:25:11,720 --> 01:25:16,990
Y entonces, si usted tiene una gran variedad de Pokémon, usted puede hacer una Pokédex, ¿verdad?

1382
01:25:16,990 --> 01:25:20,810
De acuerdo, genial. Por lo tanto, las preguntas sobre las estructuras. Los que están relacionados con las estructuras.

1383
01:25:20,810 --> 01:25:25,270
>> Por último, el BGF. ¿Qué GDB permiten hacer? Le permite depurar el programa.

1384
01:25:25,270 --> 01:25:27,650
Y si usted no ha utilizado GDB, me recomendó ver el corto

1385
01:25:27,650 --> 01:25:31,250
y repasando lo que GDB es decir, cómo se trabaja con él, cómo puede usarlo,

1386
01:25:31,250 --> 01:25:32,900
y probarlo en un programa.

1387
01:25:32,900 --> 01:25:37,400
Y así lo GDB le permite hacer es que le permite pausar la [ininteligible] su programa

1388
01:25:37,400 --> 01:25:38,920
y una línea de práctica.

1389
01:25:38,920 --> 01:25:42,600
Por ejemplo, quiero hacer una pausa en la ejecución como la línea 3 de mi programa,

1390
01:25:42,600 --> 01:25:46,010
y ya que estoy en la línea 3 que puede imprimir todos los valores que están allí.

1391
01:25:46,010 --> 01:25:49,710
Y así lo que denominamos como una pausa en una línea

1392
01:25:49,710 --> 01:25:52,350
Se le llamamos poner un punto de interrupción en esa línea

1393
01:25:52,350 --> 01:25:55,920
y entonces podremos imprimir las variables en el estado del programa en ese momento.

1394
01:25:55,920 --> 01:25:58,990
>> Podemos entonces desde allí paso a paso el programa línea por línea.

1395
01:25:58,990 --> 01:26:03,200
Y entonces puede mirar en el estado de la pila en el momento.

1396
01:26:03,200 --> 01:26:08,600
Y así, con el fin de utilizar GDB, lo que hacemos es que llamamos sonido metálico en el archivo C,

1397
01:26:08,600 --> 01:26:11,290
pero tenemos que pasar la bandera ggdb.

1398
01:26:11,290 --> 01:26:15,850
Y una vez que hayas terminado con eso nos basta con ejecutar gdb en el archivo de salida resultante.

1399
01:26:15,850 --> 01:26:18,810
Y para que pueda obtener algo de masa como de texto como este,

1400
01:26:18,810 --> 01:26:21,990
pero en realidad lo único que tienes que hacer es introducir comandos en el principio.

1401
01:26:21,990 --> 01:26:24,250
Romper principal pone un punto de ruptura en principal.

1402
01:26:24,250 --> 01:26:28,470
Lista 400 enumera las líneas de código alrededor de la línea 400.

1403
01:26:28,470 --> 01:26:31,410
Y así, en este caso, sólo puede mirar alrededor y decir, oh,

1404
01:26:31,410 --> 01:26:34,360
Quiero establecer un punto de interrupción en la línea 397, que es esta línea,

1405
01:26:34,360 --> 01:26:37,170
y luego el programa se ejecuta en ese paso y que va a romper.

1406
01:26:37,170 --> 01:26:41,120
Se va a hacer una pausa allí, y usted puede imprimir, por ejemplo, el valor de baja o alta.

1407
01:26:41,120 --> 01:26:46,410
Y así hay un montón de opciones que necesita saber,

1408
01:26:46,410 --> 01:26:48,660
y esta presentación va a subir en el sitio web,

1409
01:26:48,660 --> 01:26:54,000
así que si lo que desea es hacer referencia a estos o similares las puso en tus hojas de trucos, no dude.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Eso fue Quiz Revisión 0, y vamos a quedar si tiene alguna pregunta.

1411
01:27:00,650 --> 01:27:03,850
Está bien.

1412
01:27:03,850 --> 01:27:09,030
>>  [Aplauso]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]