1
00:00:00,000 --> 00:00:02,742

2
00:00:02,742 --> 00:00:05,680
>> ALTAVOZ 1: Hola a todos.

3
00:00:05,680 --> 00:00:07,530
Vamos a empezar.

4
00:00:07,530 --> 00:00:09,330
Creo que la gente todavía va
para ser filtrado en.

5
00:00:09,330 --> 00:00:12,840
Sin embargo, en aras del tiempo, por lo que podemos
conseguir chicos de aquí a tiempo,

6
00:00:12,840 --> 00:00:14,110
vamos a empezar.

7
00:00:14,110 --> 00:00:18,780
Así que bienvenidos a la CS50 Cuestionario 0 opinión.

8
00:00:18,780 --> 00:00:23,020
Para aquellos de ustedes que no han realizado
sin embargo, usted tiene una pregunta para el Miércoles.

9
00:00:23,020 --> 00:00:25,700
Woo-hoo.

10
00:00:25,700 --> 00:00:29,780
>> Si usted no ha comenzado a estudiar todavía o
No se han dado cuenta de que esto existe, sin embargo,

11
00:00:29,780 --> 00:00:34,070
concursos anteriores y toda la información acerca de
su concurso están en cs50.net/quizzes.

12
00:00:34,070 --> 00:00:38,090
Hay un poco de cosas muy buenas allí,
concursos pasados ​​desde el último 10

13
00:00:38,090 --> 00:00:43,760
años, así como información
sobre esta prueba y temas

14
00:00:43,760 --> 00:00:46,250
que serán cubiertos.

15
00:00:46,250 --> 00:00:48,980
Así que vamos a empezar.

16
00:00:48,980 --> 00:00:54,240
>> Así que ustedes pueden recordar, la primera
día de clase David tenía esas lámparas en.

17
00:00:54,240 --> 00:00:59,650
Así que, esencialmente, todo lo que pasa
bajo el capó de un ordenador es

18
00:00:59,650 --> 00:01:00,860
hecho en binario.

19
00:01:00,860 --> 00:01:04,080
Binario significa lo que suena
como, 0 y 1s.

20
00:01:04,080 --> 00:01:09,290
Tiene dos valores que
puede ser representada.

21
00:01:09,290 --> 00:01:14,675
>> Así como en el primer día de la sección
cuando David encendió una luz

22
00:01:14,675 --> 00:01:21,990
bombilla para representar en, o 1, nuestro ordenador
entiende binario como 0 y de

23
00:01:21,990 --> 00:01:24,110
1 de, encendido o apagado.

24
00:01:24,110 --> 00:01:25,360
Fundamentos de la binaria.

25
00:01:25,360 --> 00:01:29,440

26
00:01:29,440 --> 00:01:32,470
Cada lugar está representado
en base dos.

27
00:01:32,470 --> 00:01:36,260
Así se agrega 2 a 0 al
1 a la 2 todo el camino hacia arriba.

28
00:01:36,260 --> 00:01:41,970
>> Para calcular lo que su binario es
decimal, sólo tienes que seguir esta ecuación

29
00:01:41,970 --> 00:01:42,840
tipo de cosa.

30
00:01:42,840 --> 00:01:49,510
Si usted tiene un 1 en cualquiera de esos lugares,
lo multiplicas por cualquier

31
00:01:49,510 --> 00:01:53,820
basar es en, agregar para arriba, y
a obtener el decimal.

32
00:01:53,820 --> 00:01:57,930
Así que esta es la forma de contar
a 5 en binario.

33
00:01:57,930 --> 00:02:01,400
Al igual que lo que estábamos haciendo en el
última diapositiva, así es como lo haría

34
00:02:01,400 --> 00:02:02,650
representar 1 a 5.

35
00:02:02,650 --> 00:02:05,320

36
00:02:05,320 --> 00:02:09,660
>> Del mismo modo, al igual que usted puede agregar y
restar en decimal o en base 10, o

37
00:02:09,660 --> 00:02:13,040
Realmente cualquier base, sobre puede agregar
y resta en binario.

38
00:02:13,040 --> 00:02:18,400
Exactamente lo que se puede esperar cuando se
añadir los dos arriba, si es igual a mayor

39
00:02:18,400 --> 00:02:24,220
que 1, usted lleva un 1, lo convierten en un 0,
y hacer la adición de esa manera, sólo

40
00:02:24,220 --> 00:02:29,910
como era de esperar con regularidad
decimal o cualquier otra base.

41
00:02:29,910 --> 00:02:30,970
Enfriar.

42
00:02:30,970 --> 00:02:35,140
>> Así que como he dicho antes, todo lo que
que pasa bajo el capó de nuestro ordenador

43
00:02:35,140 --> 00:02:37,560
se hace en de 0 y 1 de, o binario.

44
00:02:37,560 --> 00:02:43,470
Entonces, ¿cómo nos expresamos, por ejemplo,
letras o números o caracteres?

45
00:02:43,470 --> 00:02:45,560
Y la respuesta a eso es ASCII.

46
00:02:45,560 --> 00:02:49,380
>> ASCII es un mapeo entre caracteres
que normalmente veríamos en el

47
00:02:49,380 --> 00:02:53,360
Idioma Inglés como doctores, B,
De C, de subrayado, guiones y

48
00:02:53,360 --> 00:02:54,910
nada de eso.

49
00:02:54,910 --> 00:02:57,260
Y es que los mapas de un valor ASCII.

50
00:02:57,260 --> 00:03:03,080
Un valor ASCII es sólo un número que
puede ser entendido por el ordenador.

51
00:03:03,080 --> 00:03:07,430
Y al igual que puede hacer la suma y
resta con números, se puede hacer

52
00:03:07,430 --> 00:03:10,890
con valores ASCII.

53
00:03:10,890 --> 00:03:14,050
>> Así que en este ejemplo, lo que
será esta imprimir?

54
00:03:14,050 --> 00:03:26,790

55
00:03:26,790 --> 00:03:35,480
Sí, por lo que sólo un espacio espacio espacio B C
D. ¿A dónde fue mi ratón?

56
00:03:35,480 --> 00:03:39,200

57
00:03:39,200 --> 00:03:43,380
Observe que puede definir un int a 65.

58
00:03:43,380 --> 00:03:47,080
Y al imprimir que utilizando
ciento C, que va a interpretar eso como un

59
00:03:47,080 --> 00:03:49,330
carácter y se imprimirá A.

60
00:03:49,330 --> 00:03:52,800
>> Del mismo modo, se puede declarar
como un char.

61
00:03:52,800 --> 00:03:56,860
Y cuando lo imprima utilizando ciento
C, que va a interpretar eso como

62
00:03:56,860 --> 00:04:05,240
ciento D. Y al igual que se puede añadir un
número, usted puede agregar caracteres son

63
00:04:05,240 --> 00:04:06,878
Valores ASCII, en este caso.

64
00:04:06,878 --> 00:04:11,370

65
00:04:11,370 --> 00:04:16,130
>> Así que un poco de puntero para todo el mundo.

66
00:04:16,130 --> 00:04:19,610
5, como una cadena, ¿no
en realidad equivalen a 5.

67
00:04:19,610 --> 00:04:26,610
Así que ¿cómo podemos convertir el
cadena 5 al entero más 5?

68
00:04:26,610 --> 00:04:28,930
¿Alguna idea?

69
00:04:28,930 --> 00:04:31,630
Sí.

70
00:04:31,630 --> 00:04:36,720
>> Así que si tenemos 5 como una cadena,
podemos restar 0.

71
00:04:36,720 --> 00:04:37,820
Y eso nos dará 5.

72
00:04:37,820 --> 00:04:41,670
Y del mismo modo, si tenemos 5 como
entero, añadir que a la cadena de 0.

73
00:04:41,670 --> 00:04:43,112
Y eso nos da la cadena 5.

74
00:04:43,112 --> 00:04:46,350

75
00:04:46,350 --> 00:04:48,350
Enfriar.

76
00:04:48,350 --> 00:04:52,940
>> Ahora, recordar de nuevo a dar una conferencia en una
hablamos de algoritmos.

77
00:04:52,940 --> 00:04:57,260
Entonces, ¿cómo es lo que realmente queremos un ordenador
para hacer cosas interesantes?

78
00:04:57,260 --> 00:05:00,460
Ya sabes, sólo sumar y restar
números y cosas fuera de impresión no es

79
00:05:00,460 --> 00:05:01,730
que emocionante.

80
00:05:01,730 --> 00:05:04,620
Por lo general, queremos que nuestro ordenador para
realizar algún tipo de algoritmo.

81
00:05:04,620 --> 00:05:07,820
Algo un poco más complejo
que sólo la aritmética simple.

82
00:05:07,820 --> 00:05:11,930
>> Un algoritmo es sólo un paso a paso conjunto
de instrucciones de cómo realizar

83
00:05:11,930 --> 00:05:14,640
un cierto task--

84
00:05:14,640 --> 00:05:15,660
al igual que una receta.

85
00:05:15,660 --> 00:05:19,990
Puede que recuerde el primer día de
clase donde David había contarnos una habitación

86
00:05:19,990 --> 00:05:22,550
de las personas y cuántas personas
estaban en la habitación.

87
00:05:22,550 --> 00:05:24,480
Usted podría estar acostumbrado a recuento
uno por uno.

88
00:05:24,480 --> 00:05:25,860
1, 2, 3, 4.

89
00:05:25,860 --> 00:05:28,010
En ese caso, un algoritmo de tiempo lineal.

90
00:05:28,010 --> 00:05:31,710
>> Pero David introdujo un algoritmo para
que cuentes las personas en la habitación

91
00:05:31,710 --> 00:05:37,340
donde todo el mundo se pone de pie, usted dice que su
número a otra persona, añadir que

92
00:05:37,340 --> 00:05:39,200
número, y una persona se sienta.

93
00:05:39,200 --> 00:05:40,410
Y repites eso.

94
00:05:40,410 --> 00:05:42,910
Eso es un tipo de algoritmo.

95
00:05:42,910 --> 00:05:47,520
Podemos analizar una forma eficiente
algoritmo se basa en que es tiempo de ejecución.

96
00:05:47,520 --> 00:05:49,680
Pero vamos a hablar un poco
más sobre esto más adelante.

97
00:05:49,680 --> 00:05:52,740

98
00:05:52,740 --> 00:05:57,090
>> Así que todos los algoritmos también puede
escribirse en pseudocódigo.

99
00:05:57,090 --> 00:06:01,120
Pseudocódigo es sólo un Inglés como
sintaxis utiliza para representar

100
00:06:01,120 --> 00:06:02,420
un lenguaje de programación.

101
00:06:02,420 --> 00:06:06,070
Por ejemplo, si queríamos pedir un usuario
de adivinar mi número favorito, que

102
00:06:06,070 --> 00:06:08,390
podría tener pseudocódigo como tal.

103
00:06:08,390 --> 00:06:09,850
>> Obtener un usuarios adivinen.

104
00:06:09,850 --> 00:06:13,570
Si la suposición es correcta, dígales
si es correcta, de lo contrario les digo

105
00:06:13,570 --> 00:06:15,560
no son correctos.

106
00:06:15,560 --> 00:06:22,530
Y pseudocódigo es una manera de fácil
que representa una idea o un algoritmo.

107
00:06:22,530 --> 00:06:26,910
Así que ahora lo que se quiere realmente escribir
esto en el lenguaje que la computadora

108
00:06:26,910 --> 00:06:27,980
podría entender.

109
00:06:27,980 --> 00:06:35,660
Así que podemos escribir nuestro pseudocódigo y
interpretar que en el código fuente.

110
00:06:35,660 --> 00:06:41,320
>> Hasta ahora, el código fuente debe cumplir
a una cierta sintaxis de

111
00:06:41,320 --> 00:06:42,490
un lenguaje de programación.

112
00:06:42,490 --> 00:06:45,430
Y hasta ahora, en el CS50, tenemos
estado usando en su mayoría c.

113
00:06:45,430 --> 00:06:48,320
Así que esto podría ser el código fuente de c.

114
00:06:48,320 --> 00:06:51,440
Más tarde, en el curso, se llega la noche
en contacto con otros programas

115
00:06:51,440 --> 00:06:52,480
lenguajes como PHP.

116
00:06:52,480 --> 00:06:57,540
O si usted incluso tomar otras clases, que
podría hacer Java, Python, o incluso OCML.

117
00:06:57,540 --> 00:07:01,570
Pero en nuestro lenguaje de programación C, esto es
cómo podríamos escribir el código fuente de

118
00:07:01,570 --> 00:07:04,760
el algoritmo de pseudocódigo que
Que acabo de describir anteriormente.

119
00:07:04,760 --> 00:07:08,630

120
00:07:08,630 --> 00:07:11,430
>> Entonces, ¿cómo el equipo en realidad
entender eso?

121
00:07:11,430 --> 00:07:14,490
Como he dicho antes, en realidad sólo se
entiende ceros y unos.

122
00:07:14,490 --> 00:07:17,880
Entonces, ¿cómo llegar de la fuente
código para algo que puede ser

123
00:07:17,880 --> 00:07:18,960
entendido?

124
00:07:18,960 --> 00:07:22,920
Bueno, tenemos algo
llamado un compilador.

125
00:07:22,920 --> 00:07:28,450
>> Si usted recuerda de nuevo en la mayor parte de su
conjuntos de procesadores, que tenía algún tipo de programa

126
00:07:28,450 --> 00:07:30,370
escrito en un archivo de puntos c.

127
00:07:30,370 --> 00:07:32,550
Y entonces tendría que escribir make.

128
00:07:32,550 --> 00:07:35,970
Entonces, ¿qué está haciendo hacer?

129
00:07:35,970 --> 00:07:39,970
>> Puede escribir make para compilar su
programa porque alguien--

130
00:07:39,970 --> 00:07:42,730
quien escribió su conjunto p;
probablemente David--

131
00:07:42,730 --> 00:07:44,190
creado un archivo make.

132
00:07:44,190 --> 00:07:51,320
Y que dice que saber para ejecutar su
compilador, llamado sonido metálico, que la voluntad

133
00:07:51,320 --> 00:07:55,560
a continuación, compilar el código fuente de objetar
código, que es ceros y unos

134
00:07:55,560 --> 00:07:57,720
que el ordenador entiende.

135
00:07:57,720 --> 00:08:01,610
Pero un poco más tarde, nos dirigiremos
más a fondo acerca de los compiladores.

136
00:08:01,610 --> 00:08:05,640

137
00:08:05,640 --> 00:08:10,800
>> Así recordar pset 0, dónde-- sí,
usted tiene una pregunta?

138
00:08:10,800 --> 00:08:11,620
>> AUDIENCIA: [inaudible]?

139
00:08:11,620 --> 00:08:12,490
>> ALTAVOZ 1: Si.

140
00:08:12,490 --> 00:08:14,960
Creo que en realidad
debe estar en línea.

141
00:08:14,960 --> 00:08:15,120
Sí.

142
00:08:15,120 --> 00:08:16,572
>> AUDIENCIA: ¿Es como [inaudible]?

143
00:08:16,572 --> 00:08:19,476

144
00:08:19,476 --> 00:08:20,830
>> ALTAVOZ 1: No lo es.

145
00:08:20,830 --> 00:08:25,810
La están en cs50.net/quizzes.

146
00:08:25,810 --> 00:08:32,900
>> AUDIENCIA: concursos de Slash, slash 2013,
slash 0 y, simplemente haga clic a través de

147
00:08:32,900 --> 00:08:35,956
concursos 2013 y concurso 0,
Revise la sección de diapositivas.

148
00:08:35,956 --> 00:08:40,380
>> ALTAVOZ 1: Sí, así que si ustedes quieren
tire hacia arriba y mirar en su

149
00:08:40,380 --> 00:08:42,740
propio ordenador, eso está bien también.

150
00:08:42,740 --> 00:08:43,130
Dilo de nuevo.

151
00:08:43,130 --> 00:08:44,546
>> AUDIENCIA: [inaudible].

152
00:08:44,546 --> 00:08:48,780
>> ALTAVOZ 1: Sí, [inaudible]
es la variable dummy.

153
00:08:48,780 --> 00:08:49,644
Ah, sí?

154
00:08:49,644 --> 00:08:51,372
>> AUDIENCIA: [inaudible]?

155
00:08:51,372 --> 00:08:54,300
>> ALTAVOZ 1: No, huelgas
no están en el examen.

156
00:08:54,300 --> 00:08:55,950
Lo sentimos, la pregunta era, era
huelgas en el examen.

157
00:08:55,950 --> 00:08:59,530
Y no lo es.

158
00:08:59,530 --> 00:09:05,780
Así pset 0, ustedes debe tener toda
implementado algo con cero.

159
00:09:05,780 --> 00:09:13,100
Y aprendimos algo de programación básica
bloques de construcción que utilizan los arañazos.

160
00:09:13,100 --> 00:09:15,590
>> Así que echemos un vistazo a algunos
de estos bloques de construcción

161
00:09:15,590 --> 00:09:18,170
que conforman un programa.

162
00:09:18,170 --> 00:09:20,570
En primer lugar es la expresión de Boole.

163
00:09:20,570 --> 00:09:24,540
Las expresiones booleanas son queridos y
0 de o todo lo que tiene

164
00:09:24,540 --> 00:09:25,700
dos valores posibles.

165
00:09:25,700 --> 00:09:30,320
En este caso, verdadera o falsa,
dentro o fuera, y sí o no.

166
00:09:30,320 --> 00:09:35,390
Un ejemplo de un simple, muy simple,
programa que utiliza un booleano

167
00:09:35,390 --> 00:09:39,140
expresión aquí.

168
00:09:39,140 --> 00:09:43,220
>> Así que para que las expresiones booleanas a
ser útil, tenemos operadores booleanos.

169
00:09:43,220 --> 00:09:48,920
Estos son los operadores que se pueden utilizar
para comparar ciertos valores.

170
00:09:48,920 --> 00:09:52,820
Así que tenemos y o no igual a, menor
o igual que, mayor que o

171
00:09:52,820 --> 00:09:55,130
igual a, y menos de
o mayor que.

172
00:09:55,130 --> 00:09:59,060
Sin embargo, estos operadores no son muy útiles
a menos que podamos combinarlos en

173
00:09:59,060 --> 00:10:00,320
condiciones.

174
00:10:00,320 --> 00:10:04,370
>> Así que ustedes podrían recordar a partir de cero
y de su p establece que

175
00:10:04,370 --> 00:10:05,400
tenía condiciones.

176
00:10:05,400 --> 00:10:09,710
Ellos son, en esencia, como tenedores en
la lógica de su programa que

177
00:10:09,710 --> 00:10:12,670
ejecuta dependiendo de si
se cumple una condición.

178
00:10:12,670 --> 00:10:18,150
Así que una de las condiciones que teníamos
utilizado muchas veces en este curso es el

179
00:10:18,150 --> 00:10:21,470
if, else, si, y las condiciones lo demás.

180
00:10:21,470 --> 00:10:24,060
>> He aquí un ejemplo de cómo
usted puede usar eso.

181
00:10:24,060 --> 00:10:28,430
¿Alguien sabe la diferencia entre
simplemente usando las sentencias if todos

182
00:10:28,430 --> 00:10:32,530
el camino hacia abajo versos if, else,
si, y más combinado?

183
00:10:32,530 --> 00:10:33,013
Sí?

184
00:10:33,013 --> 00:10:34,263
>> AUDIENCIA: [inaudible].

185
00:10:34,263 --> 00:10:40,741

186
00:10:40,741 --> 00:10:42,160
>> ALTAVOZ 1: Exactamente.

187
00:10:42,160 --> 00:10:50,210
Así que si tuviera si todo el camino hasta este
manera, aunque esta condición vuelve

188
00:10:50,210 --> 00:10:52,800
verdadera, todavía seguirá
probar los dos siguientes.

189
00:10:52,800 --> 00:11:00,120
Considerando que, con una cosa-si, una cosa
declaración, si el que devuelve true,

190
00:11:00,120 --> 00:11:02,640
los otros no se ponen a prueba.

191
00:11:02,640 --> 00:11:05,955
¿Una pregunta sobre eso?

192
00:11:05,955 --> 00:11:06,890
Enfriar.

193
00:11:06,890 --> 00:11:12,240
>> Así que utiliza una persona si-de una persona
declaración si usted sabe que sólo puede

194
00:11:12,240 --> 00:11:14,470
ser uno de estos casos.

195
00:11:14,470 --> 00:11:21,550
Así que sabemos que si x es menor que 0, es
definitivamente no va a ser

196
00:11:21,550 --> 00:11:22,890
mayor que 0.

197
00:11:22,890 --> 00:11:26,940

198
00:11:26,940 --> 00:11:31,480
>> A continuación, otro bloque de construcción
que hemos aprendido son bucles.

199
00:11:31,480 --> 00:11:33,310
Tenemos tres tipos de bucles.

200
00:11:33,310 --> 00:11:35,830
Para bucles, los bucles while,
y hacer bucles while.

201
00:11:35,830 --> 00:11:38,730
Y, en general, cuando te sientas a
escribir algo, usted tiene que decidir

202
00:11:38,730 --> 00:11:40,060
cuál de los tres que desea utilizar.

203
00:11:40,060 --> 00:11:41,900
Así que ¿cómo decidir cuál de ellas?

204
00:11:41,900 --> 00:11:44,920

205
00:11:44,920 --> 00:11:48,790
>> Generalmente usamos un bucle for si sabemos
cuántas veces queremos repetir

206
00:11:48,790 --> 00:11:53,650
a través de algo o cuántas veces
queremos realizar una tarea.

207
00:11:53,650 --> 00:11:58,830
Utilizamos bucles while si necesitamos alguna
condición de ser fieles a seguir corriendo.

208
00:11:58,830 --> 00:12:03,730
Y utilizamos hacemos bien es muy similar a la
tiempo, pero queremos que nuestro código se ejecute en

209
00:12:03,730 --> 00:12:04,880
menos una vez.

210
00:12:04,880 --> 00:12:09,410
>> Así que hacer, mientras que, lo que está en el hacer la voluntad
siempre correr al menos una vez.

211
00:12:09,410 --> 00:12:13,120
Considerando que, con el tiempo, se
pueden no funcionar en absoluto si la

212
00:12:13,120 --> 00:12:15,490
condición no se cumple.

213
00:12:15,490 --> 00:12:16,740
Cualquier pregunta con eso?

214
00:12:16,740 --> 00:12:20,480

215
00:12:20,480 --> 00:12:22,860
>> Así la estructura de un bucle for.

216
00:12:22,860 --> 00:12:23,620
Todo lo que ustedes han visto esto.

217
00:12:23,620 --> 00:12:25,320
Usted inicialice.

218
00:12:25,320 --> 00:12:26,600
Usted tiene algún tipo de condición.

219
00:12:26,600 --> 00:12:32,340
Así, por ejemplo, podríamos inicializar
como para i es igual a 0.

220
00:12:32,340 --> 00:12:34,040
i es menor que 10.

221
00:12:34,040 --> 00:12:35,442
Y i ++.

222
00:12:35,442 --> 00:12:39,010
Muy sencillo que hemos hecho.

223
00:12:39,010 --> 00:12:42,210
>> Para un bucle while, de manera similar, usted tiene
tener algún tipo de inicialización,

224
00:12:42,210 --> 00:12:44,980
algún tipo de condición, y
algún tipo de actualización.

225
00:12:44,980 --> 00:12:51,990
Así que podemos implementar nuestro bucle for también
como un bucle durante el uso de este.

226
00:12:51,990 --> 00:12:56,000
Y de manera similar con un do while,
podríamos tener un poco de inicialización,

227
00:12:56,000 --> 00:12:58,640
ejecutar algo, actualizarlo, y
a continuación, compruebe el estado.

228
00:12:58,640 --> 00:13:03,500

229
00:13:03,500 --> 00:13:05,140
>> Así que ahora las funciones.

230
00:13:05,140 --> 00:13:06,460
Pusimos todo juntos.

231
00:13:06,460 --> 00:13:10,140
Podríamos querer escribir algo
tipo de función.

232
00:13:10,140 --> 00:13:12,790
Función común que te pueden
han visto ya es principal.

233
00:13:12,790 --> 00:13:13,770
Principal es una función.

234
00:13:13,770 --> 00:13:16,160
Tiene un tipo de retorno, int.

235
00:13:16,160 --> 00:13:18,470
Tiene un nombre de función, principal.

236
00:13:18,470 --> 00:13:20,810
Y tiene argumentos, argc y argv.

237
00:13:20,810 --> 00:13:24,040
Así principal es sólo una función.

238
00:13:24,040 --> 00:13:27,230
>> Otras funciones que pueda haber utilizado,
printf printf-- es un function--

239
00:13:27,230 --> 00:13:29,330
GetInt, toupper.

240
00:13:29,330 --> 00:13:32,010
Pero estos resultan haber sido
implementado para nosotros por

241
00:13:32,010 --> 00:13:33,270
algún tipo de biblioteca.

242
00:13:33,270 --> 00:13:37,400
Si ustedes recuerden incluyendo
esta biblioteca CS50.h o la

243
00:13:37,400 --> 00:13:38,510
E / S estándar biblioteca.

244
00:13:38,510 --> 00:13:39,200
Sí, la pregunta?

245
00:13:39,200 --> 00:13:41,610
>> AUDIENCIA: ¿Es justo principal inherente a c?

246
00:13:41,610 --> 00:13:44,740
Lo hace sólo un poco de [inaudible]?

247
00:13:44,740 --> 00:13:47,370
>> ALTAVOZ 1: La pregunta es
si principal es inherente a c.

248
00:13:47,370 --> 00:13:51,460
Y sí, todas las funciones
tener una función principal.

249
00:13:51,460 --> 00:13:55,290
Es una especie de necesario para el ordenador
a saber por dónde empezar

250
00:13:55,290 --> 00:13:55,993
ejecutar el código.

251
00:13:55,993 --> 00:13:58,108
>> AUDIENCIA: ¿Así que no lo haría [inaudible]?

252
00:13:58,108 --> 00:13:59,480
>> ALTAVOZ 1: No.

253
00:13:59,480 --> 00:14:00,760
Alguna otra pregunta?

254
00:14:00,760 --> 00:14:03,430

255
00:14:03,430 --> 00:14:04,770
Enfriar.

256
00:14:04,770 --> 00:14:08,050
Así como usted puede utilizar una función
que está escrito para usted, también puede

257
00:14:08,050 --> 00:14:10,380
escribir su propia función.

258
00:14:10,380 --> 00:14:17,050
Esta es una función que alguien podría
han escrito para calcular el volumen

259
00:14:17,050 --> 00:14:18,395
de un q, por ejemplo.

260
00:14:18,395 --> 00:14:21,300

261
00:14:21,300 --> 00:14:29,500
Hay un tipo de retorno aquí, en este caso
int, nuestro nombre y nuestra función q

262
00:14:29,500 --> 00:14:31,360
lista de parámetros.

263
00:14:31,360 --> 00:14:34,550
>> Y tenga en cuenta que usted tiene que escribir los datos
tipo del parámetro que desea

264
00:14:34,550 --> 00:14:38,660
utilizar o bien la función no
saber qué tipo de

265
00:14:38,660 --> 00:14:41,650
parámetro debo aceptará.

266
00:14:41,650 --> 00:14:48,110
Así que, en este caso, queremos
un entero como nuestra entrada.

267
00:14:48,110 --> 00:14:50,390
¿Entonces por qué podríamos querer utilizar funciones?

268
00:14:50,390 --> 00:14:52,800
>> En primer lugar, ideal para la organización.

269
00:14:52,800 --> 00:14:56,350
Ayudan a romper el código en
más organizada trozos y hacer

270
00:14:56,350 --> 00:14:57,960
más fácil de leer.

271
00:14:57,960 --> 00:14:59,760
Simplificación.

272
00:14:59,760 --> 00:15:01,740
Esto es bueno para el diseño.

273
00:15:01,740 --> 00:15:04,570
Cuando usted está leyendo un fragmento de código
y la función principal es realmente,

274
00:15:04,570 --> 00:15:07,750
muy largo, podría ser más difícil de
razón acerca de lo que está pasando.

275
00:15:07,750 --> 00:15:11,710
Así que si lo desglosamos en funciones,
puede ser que sea más fácil de leer.

276
00:15:11,710 --> 00:15:12,750
Y reutilizar-capacidad.

277
00:15:12,750 --> 00:15:16,940
Si usted tiene un trozo de código que está siendo
llamada o ejecutar varias veces,

278
00:15:16,940 --> 00:15:20,690
en lugar de volver a escribir el código 10 veces
en su función principal, que te pueden

279
00:15:20,690 --> 00:15:21,440
quieren volver a utilizarlo.

280
00:15:21,440 --> 00:15:25,740
Y entonces cada vez que necesita usar ese
pieza de código, llame a la función.

281
00:15:25,740 --> 00:15:30,550

282
00:15:30,550 --> 00:15:35,380
>> Así que ahora si recordamos de nuevo a cero,
también hablamos de algunos conceptos,

283
00:15:35,380 --> 00:15:37,680
uno de los cuales está roscado.

284
00:15:37,680 --> 00:15:41,120
Tema es el concepto de múltiples
secuencias de código

285
00:15:41,120 --> 00:15:43,040
ejecutar al mismo tiempo.

286
00:15:43,040 --> 00:15:47,490
Así que piensen en el primer día en que David tenía
ustedes Cuente el número de

287
00:15:47,490 --> 00:15:48,440
personas en la habitación.

288
00:15:48,440 --> 00:15:50,550
>> En esencia, lo que se va
sobre todo es de ustedes eran

289
00:15:50,550 --> 00:15:52,370
correr hilos separados.

290
00:15:52,370 --> 00:15:55,540
Y esos hilos se unen
para obtener algún tipo de respuesta.

291
00:15:55,540 --> 00:15:58,890
Del mismo modo, en Scratch, cuando se tiene
múltiples sprites, que te pueden

292
00:15:58,890 --> 00:16:01,070
tener un gato y un perro.

293
00:16:01,070 --> 00:16:08,770
Y estarían simultáneamente
la gestión de sus propios guiones.

294
00:16:08,770 --> 00:16:10,020
Ese es un ejemplo de roscado.

295
00:16:10,020 --> 00:16:12,860

296
00:16:12,860 --> 00:16:18,000
>> Y el otro concepto que fue
introducido en cero era eventos.

297
00:16:18,000 --> 00:16:22,550
Y cuando los eventos son múltiples partes
su código se comunican entre sí.

298
00:16:22,550 --> 00:16:26,840
En Scratch, esto fue cuando usó el
control de difusión y el Cuando

299
00:16:26,840 --> 00:16:29,500
Recibe bloques.

300
00:16:29,500 --> 00:16:35,170
>> Y también, en problemas 4, vimos
un poco de los acontecimientos también.

301
00:16:35,170 --> 00:16:38,250
Ustedes podrían haber utilizado
la biblioteca GEvent.

302
00:16:38,250 --> 00:16:42,450
Y había una función waitForClick
en el que estabas esperando

303
00:16:42,450 --> 00:16:44,300
para que el usuario haga clic.

304
00:16:44,300 --> 00:16:47,870
Y el clic, en este caso, sería
el evento y esperar a que Click es su

305
00:16:47,870 --> 00:16:49,120
controlador de eventos.

306
00:16:49,120 --> 00:16:53,690

307
00:16:53,690 --> 00:16:58,630
>> Y también, a través de la publicación de sus conjuntos de procesadores
y trabajando en sus conjuntos de procesadores, que

308
00:16:58,630 --> 00:17:01,920
podría haber entrado en contacto con
algunos de estos comandos.

309
00:17:01,920 --> 00:17:05,579
Esto es lo que ha escrito en su
ventana de terminal o lo que sea ventana

310
00:17:05,579 --> 00:17:12,119
que aparece en su edición en g,
esencialmente, navegar por su ordenador.

311
00:17:12,119 --> 00:17:19,440
>> Así, por ejemplo, las listas de la LS
contenido de un directorio.

312
00:17:19,440 --> 00:17:22,510
Haz directorio crea una nueva carpeta.

313
00:17:22,510 --> 00:17:24,819
CD, cambio de directorio.

314
00:17:24,819 --> 00:17:28,400
RM, eliminar, elimina un archivo
o algún directorio.

315
00:17:28,400 --> 00:17:31,050
Y a continuación, eliminar el directorio
Elimina un directorio.

316
00:17:31,050 --> 00:17:32,300
>> AUDIENCIA: [inaudible]?

317
00:17:32,300 --> 00:17:36,978

318
00:17:36,978 --> 00:17:38,370
>> ALTAVOZ 1: Sí, claro.

319
00:17:38,370 --> 00:17:42,530

320
00:17:42,530 --> 00:17:46,040
Lo sentimos, la pregunta era si
sugeriría poner este

321
00:17:46,040 --> 00:17:48,840
en la hoja de trucos.

322
00:17:48,840 --> 00:17:49,440
Podría ayudar.

323
00:17:49,440 --> 00:17:51,490
Si tiene espacio, puede ponérselo.

324
00:17:51,490 --> 00:17:56,170
También está a sólo generalmente lo suficientemente bueno
de recordar, porque cuando lo utiliza

325
00:17:56,170 --> 00:17:59,060
es posible que desee simplemente
tiene memorizado.

326
00:17:59,060 --> 00:18:02,750
Eso va a hacer su vida mucho más fácil.

327
00:18:02,750 --> 00:18:04,000
¿He respondido a su pregunta?

328
00:18:04,000 --> 00:18:10,528

329
00:18:10,528 --> 00:18:14,290
>> Así que ahora, hablamos un poco
brevemente acerca de las bibliotecas.

330
00:18:14,290 --> 00:18:18,570
Pero los dos principales que hemos estado
utilizando hasta ahora en el curso son

331
00:18:18,570 --> 00:18:20,860
E / S estándar y CS50.

332
00:18:20,860 --> 00:18:25,410
¿Qué tipo de cosas se incluyen
en la librería estándar de E / S?

333
00:18:25,410 --> 00:18:28,410
>> Sí, hasta ahora hemos usado printf.

334
00:18:28,410 --> 00:18:31,150
En CS50, hemos utilizado getInt
y GetString.

335
00:18:31,150 --> 00:18:37,200
Y la cadena de tipo de datos también pasa
para ser declarado en esta biblioteca CS50.

336
00:18:37,200 --> 00:18:40,250
Hablaremos un poco más en profundidad sobre
cómo las bibliotecas funcionan y cómo

337
00:18:40,250 --> 00:18:41,870
interactuar con el resto de su código.

338
00:18:41,870 --> 00:18:46,220
Pero esos son los dos principales que
haber estado en contacto con lo que va de

339
00:18:46,220 --> 00:18:48,430
el curso.

340
00:18:48,430 --> 00:18:50,050
>> Tipos.

341
00:18:50,050 --> 00:18:58,120
Estos son buenos para recordar lo mucho
cada tipo está representado por o cómo

342
00:18:58,120 --> 00:19:02,840
muchos bytes cada uno de tipo requires--

343
00:19:02,840 --> 00:19:04,990
int, 4 bytes; char, 1 byte.

344
00:19:04,990 --> 00:19:06,550
Float es de 4 bytes.

345
00:19:06,550 --> 00:19:07,782
¿Qué es un doble?

346
00:19:07,782 --> 00:19:09,032
>> AUDIENCIA: [inaudible].

347
00:19:09,032 --> 00:19:11,398

348
00:19:11,398 --> 00:19:16,240
>> ALTAVOZ 1: Sí, por lo que un flotador
pero doblar el tamaño.

349
00:19:16,240 --> 00:19:17,150
¿Qué hay de un tiempo?

350
00:19:17,150 --> 00:19:18,400
>> AUDIENCIA: [inaudible].

351
00:19:18,400 --> 00:19:21,614

352
00:19:21,614 --> 00:19:24,680
>> ALTAVOZ 1: OK.

353
00:19:24,680 --> 00:19:25,410
¿Qué es un tiempo?

354
00:19:25,410 --> 00:19:26,660
>> AUDIENCIA: [inaudible].

355
00:19:26,660 --> 00:19:29,400

356
00:19:29,400 --> 00:19:31,450
>> ALTAVOZ 1: Sí, el doble de un int.

357
00:19:31,450 --> 00:19:34,240

358
00:19:34,240 --> 00:19:34,705
Sí.

359
00:19:34,705 --> 00:19:36,100
>> AUDIENCIA: [inaudible].

360
00:19:36,100 --> 00:19:38,030
>> ALTAVOZ 1: Long [inaudible].

361
00:19:38,030 --> 00:19:41,860
Y luego de un largo tiempo es el doble.

362
00:19:41,860 --> 00:19:42,814
>> AUDIENCIA: No, no.

363
00:19:42,814 --> 00:19:47,107
Una larga es sólo un int.

364
00:19:47,107 --> 00:19:50,910
Depende de la arquitectura
antes de la [inaudible]

365
00:19:50,910 --> 00:19:52,922
int y tienen el mismo tamaño.

366
00:19:52,922 --> 00:19:54,172
[Inaudible].

367
00:19:54,172 --> 00:19:58,841

368
00:19:58,841 --> 00:20:00,920
>> ALTAVOZ 1: Así que una larga y
un int son los mismos.

369
00:20:00,920 --> 00:20:02,943
Y luego de un largo tiempo
es el doble de la int.

370
00:20:02,943 --> 00:20:03,910
Enfriar.

371
00:20:03,910 --> 00:20:05,550
Y entonces, ¿cuál es el último tipo?

372
00:20:05,550 --> 00:20:06,510
>> AUDIENCIA: Puntero.

373
00:20:06,510 --> 00:20:10,350
>> ALTAVOZ 1: Sí, así que aprendió
un poco acerca de los punteros.

374
00:20:10,350 --> 00:20:14,015
Y sin importar lo que un puntero es
señalando a-- que podría ser una estrella de carbón

375
00:20:14,015 --> 00:20:15,880
o un int star--

376
00:20:15,880 --> 00:20:20,530
siempre 4 bytes para un puntero.

377
00:20:20,530 --> 00:20:21,633
Preguntas acerca de eso?

378
00:20:21,633 --> 00:20:22,116
Sí?

379
00:20:22,116 --> 00:20:24,531
>> AUDIENCIA: [inaudible]?

380
00:20:24,531 --> 00:20:29,530
>> ALTAVOZ 1: Así que un largo y un int son
lo mismo en este aparato CS50.

381
00:20:29,530 --> 00:20:32,302
>> AUDIENCIA: El aparato está completamente
intercambiables.

382
00:20:32,302 --> 00:20:33,510
>> ALTAVOZ 1: Si.

383
00:20:33,510 --> 00:20:36,610
Así que un largo, largo es el doble de un int.

384
00:20:36,610 --> 00:20:39,250
>> AUDIENCIA: Este es el de 32 bits?

385
00:20:39,250 --> 00:20:40,620
>> ALTAVOZ 1: 32 bits, sí.

386
00:20:40,620 --> 00:20:43,572
>> AUDIENCIA: Así que [inaudible]?

387
00:20:43,572 --> 00:20:46,790
>> ALTAVOZ 1: Sí, si no lo hace
decir de forma explícita, que

388
00:20:46,790 --> 00:20:47,870
debe asumir un poco 32.

389
00:20:47,870 --> 00:20:50,040
>> AUDIENCIA: Sería decir algo
como asumir una

390
00:20:50,040 --> 00:20:51,498
arquitectura como el aparato.

391
00:20:51,498 --> 00:20:58,800

392
00:20:58,800 --> 00:21:01,710
Para 64 bits, lo único que
cambio son largos y punteros.

393
00:21:01,710 --> 00:21:05,614
Ambos [inaudible].

394
00:21:05,614 --> 00:21:06,590
>> ALTAVOZ 1: Sí?

395
00:21:06,590 --> 00:21:07,566
>> AUDIENCIA: Pregunta.

396
00:21:07,566 --> 00:21:10,982
Así que en una de las pruebas de práctica,
se pregunta sobre un int sin signo.

397
00:21:10,982 --> 00:21:15,374
Entonces, ¿cómo habría que determinarse
de un int [inaudible]?

398
00:21:15,374 --> 00:21:18,140
>> ALTAVOZ 1: Un signo
en es también 4 bytes.

399
00:21:18,140 --> 00:21:21,172
Pero lo que es diferente acerca de una firma
int y un int sin firmar?

400
00:21:21,172 --> 00:21:22,422
>> AUDIENCIA: [inaudible].

401
00:21:22,422 --> 00:21:24,868

402
00:21:24,868 --> 00:21:25,630
>> ALTAVOZ 1: Así es.

403
00:21:25,630 --> 00:21:27,570
Uno puede representar valores negativos.

404
00:21:27,570 --> 00:21:28,580
Pero ¿cómo se hace eso?

405
00:21:28,580 --> 00:21:30,536
>> AUDIENCIA: [inaudible].

406
00:21:30,536 --> 00:21:36,370
>> ALTAVOZ 1: Sí, se ahorra 1
bit para representar el signo.

407
00:21:36,370 --> 00:21:40,910

408
00:21:40,910 --> 00:21:45,040
La firma tiene un bit que
representa el signo.

409
00:21:45,040 --> 00:21:48,886
Y sin signo sólo es de todos los positivos.

410
00:21:48,886 --> 00:21:50,365
>> AUDIENCIA: OK.

411
00:21:50,365 --> 00:21:54,230
Así que usted dice que es un doble
dos veces el tamaño de un flotador?

412
00:21:54,230 --> 00:21:58,202
>> ALTAVOZ 1: Haga doble es dos veces
el tamaño de un flotador, sí.

413
00:21:58,202 --> 00:22:01,639
>> AUDIENCIA: ¿Cómo funciona un puntero
para un largo tiempo [inaudible]?

414
00:22:01,639 --> 00:22:06,058

415
00:22:06,058 --> 00:22:10,870
>> ALTAVOZ 1: Entonces la pregunta es ¿cómo
el puntero a una larga long--

416
00:22:10,870 --> 00:22:13,800
cómo es que sólo cuatro bytes cuando
un largo, largo de sus 8 bytes.

417
00:22:13,800 --> 00:22:17,310
Así que recuerda lo que es un puntero,
esencialmente, en el valor muy base.

418
00:22:17,310 --> 00:22:19,046
>> AUDIENCIA: [inaudible].

419
00:22:19,046 --> 00:22:22,670
>> ALTAVOZ 1: Sí, así que un puntero
es sólo una posición de memoria.

420
00:22:22,670 --> 00:22:28,040
Así que no importa la cantidad de espacio
ese puntero está apuntando.

421
00:22:28,040 --> 00:22:32,060
Sólo necesita 4 bytes para realizar un seguimiento
de esa ubicación de memoria.

422
00:22:32,060 --> 00:22:34,760

423
00:22:34,760 --> 00:22:36,010
Alguna otra pregunta?

424
00:22:36,010 --> 00:22:39,800

425
00:22:39,800 --> 00:22:41,050
Enfriar.

426
00:22:41,050 --> 00:22:42,920

427
00:22:42,920 --> 00:22:47,460
>> Así que la última cosa que tengo
es la salida estándar.

428
00:22:47,460 --> 00:22:51,020
Usted debe utilizar con frecuencia
lo suficiente para que usted pueda recordar.

429
00:22:51,020 --> 00:22:54,800
Pero esto es cuando usamos
printf, por ejemplo.

430
00:22:54,800 --> 00:22:59,260
Y tenemos estos marcadores de posición que
fueron llamados códigos de formato.

431
00:22:59,260 --> 00:23:03,910
>> Así ciento c char, ciento i para int,
y también podemos utilizar el porcentaje d.

432
00:23:03,910 --> 00:23:05,130
Es la misma cosa.

433
00:23:05,130 --> 00:23:08,200
Pero, en general, en que CS50
tratar de utilizar el porcentaje de i.

434
00:23:08,200 --> 00:23:09,860
F Porcentaje de flotador.

435
00:23:09,860 --> 00:23:15,620
Ld Porcentaje de largo de largo y
ciento s para cadena.

436
00:23:15,620 --> 00:23:18,550
>> Del mismo modo, hemos estado utilizando algunos
de estas secuencias de escape.

437
00:23:18,550 --> 00:23:22,431
Por ejemplo, la barra invertida n para la nueva línea.

438
00:23:22,431 --> 00:23:26,910
Esto es sólo para cuando estás de formatear
su código para la impresión f.

439
00:23:26,910 --> 00:23:27,260
Sí?

440
00:23:27,260 --> 00:23:28,906
>> AUDIENCIA: ¿Cuál es el porcentaje de d?

441
00:23:28,906 --> 00:23:31,850
>> ALTAVOZ 1: Así que la pregunta
es lo que es ciento por d?

442
00:23:31,850 --> 00:23:33,270
Porcentaje d es para enteros.

443
00:23:33,270 --> 00:23:37,392
Porcentaje dy ciento i son los mismos.

444
00:23:37,392 --> 00:23:41,130
>> AUDIENCIA: ¿Cuál es la diferencia entre
barra invertida n y barra invertida r?

445
00:23:41,130 --> 00:23:45,300
>> ALTAVOZ 1: Entonces la pregunta es ¿cuál es el
diferencia entre N y reacción

446
00:23:45,300 --> 00:23:48,615
r contragolpe?

447
00:23:48,615 --> 00:23:50,906
Creo barra invertida r es--

448
00:23:50,906 --> 00:23:54,340
>> AUDIENCIA: Así barra invertida r sólo implica
regresa al principio de la línea

449
00:23:54,340 --> 00:23:56,670
sin tener que ir a una nueva línea.

450
00:23:56,670 --> 00:24:01,000
Así que si imprime una barra invertida r y
volver al principio de la línea

451
00:24:01,000 --> 00:24:04,005
a continuación, se imprime más cosas, se sobrescribe
el material que ya está en

452
00:24:04,005 --> 00:24:04,390
[Inaudible].

453
00:24:04,390 --> 00:24:06,725
Considerando que, en realidad n va a una nueva
línea y va a [inaudible].

454
00:24:06,725 --> 00:24:10,525

455
00:24:10,525 --> 00:24:13,915
>> ALTAVOZ 1: Bueno, alguna otra pregunta?

456
00:24:13,915 --> 00:24:15,430
Bien.

457
00:24:15,430 --> 00:24:18,617
Voy a darlo fuera de
Dan quien continuará.

458
00:24:18,617 --> 00:24:25,078
>> [Aplausos]

459
00:24:25,078 --> 00:25:08,814

460
00:25:08,814 --> 00:25:09,720
>> DAN: Muy bien.

461
00:25:09,720 --> 00:25:18,590
Así que voy a estar hablando de otra amplia
gama de ideas de la clase que sean

462
00:25:18,590 --> 00:25:23,220
representante de aproximadamente dos semanas y
el comienzo de la semana tres partiendo

463
00:25:23,220 --> 00:25:28,690
con la fundición, que es sólo una forma de
el tratamiento de un valor de un cierto tipo como

464
00:25:28,690 --> 00:25:30,830
un valor de un tipo diferente.

465
00:25:30,830 --> 00:25:34,110
Así que podemos hacer esto con caracteres a
ints, flotadores para ints, y

466
00:25:34,110 --> 00:25:35,360
longs largas duplicar.

467
00:25:35,360 --> 00:25:38,170

468
00:25:38,170 --> 00:25:44,500
>> Todas estas cosas pueden ser utilizados como formas
de tratar algún valor numérico

469
00:25:44,500 --> 00:25:48,370
Char menos como algún otro
valor numérico.

470
00:25:48,370 --> 00:25:54,480
Así que hay algunos problemas con esto, de
Por supuesto, que viene cuando lanzas

471
00:25:54,480 --> 00:25:57,860
cosas como float a ints.

472
00:25:57,860 --> 00:26:00,500
Así que esto es un poco raro.

473
00:26:00,500 --> 00:26:03,170
Tenemos un flotador que es de 1.31.

474
00:26:03,170 --> 00:26:05,220
Nos multiplicamos por 10.000.

475
00:26:05,220 --> 00:26:08,380
Y entonces lo imprimimos como un int.

476
00:26:08,380 --> 00:26:09,630
¿Qué significa este resultado?

477
00:26:09,630 --> 00:26:11,600

478
00:26:11,600 --> 00:26:14,020
10.000 veces 1.31.

479
00:26:14,020 --> 00:26:18,761
Así que 13.000, es que la conjetura?

480
00:26:18,761 --> 00:26:20,685
>> AUDIENCIA: Creo que es de 10.000.

481
00:26:20,685 --> 00:26:24,234
>> DAN: Así que estoy multiplicarlo por 10.000
antes de que me lanzarlo.

482
00:26:24,234 --> 00:26:25,202
>> AUDIENCIA: Oh.

483
00:26:25,202 --> 00:26:27,622
¿No habría un 9
y algunos números de 0?

484
00:26:27,622 --> 00:26:29,270
>> DAN: Usted podría tener algunos dígitos extraños.

485
00:26:29,270 --> 00:26:32,410

486
00:26:32,410 --> 00:26:37,670
Así bien, es 1,3 veces 10.000.

487
00:26:37,670 --> 00:26:40,040
Así que eso es 13.000.

488
00:26:40,040 --> 00:26:41,313
Y esto weird-- adicional

489
00:26:41,313 --> 00:26:42,160
>> AUDIENCIA: 13100.

490
00:26:42,160 --> 00:26:42,650
>> DAN: 13100.

491
00:26:42,650 --> 00:26:44,910
Gracias, Rob.

492
00:26:44,910 --> 00:26:46,610
Y esto weirdness-- adicional

493
00:26:46,610 --> 00:26:48,060
este 9,9--

494
00:26:48,060 --> 00:26:53,860
es simplemente porque este casting
acabó redondeando donde

495
00:26:53,860 --> 00:26:55,394
que no debería tener.

496
00:26:55,394 --> 00:26:55,871
Sí.

497
00:26:55,871 --> 00:26:58,256
>> AUDIENCIA: El casting sucede
después de todo lo demás?

498
00:26:58,256 --> 00:27:03,865
>> DAN: Así que ya tengo esto en impresión,
hace esta multiplicación antes de que se

499
00:27:03,865 --> 00:27:05,230
hace este casting.

500
00:27:05,230 --> 00:27:06,140
>> AUDIENCIA: [inaudible].

501
00:27:06,140 --> 00:27:11,350
>> DAN: Creo que proyectaría primero,
sí, lo que sería de 10.000.

502
00:27:11,350 --> 00:27:12,610
Algo más?

503
00:27:12,610 --> 00:27:13,330
Enfriar.

504
00:27:13,330 --> 00:27:16,344
Así que esto es 13.099.

505
00:27:16,344 --> 00:27:17,840
¿Por qué sucede esto?

506
00:27:17,840 --> 00:27:18,900
La imprecisión.

507
00:27:18,900 --> 00:27:21,020
>> Los flotadores no son perfectos.

508
00:27:21,020 --> 00:27:27,550
Sólo pueden representar los números a un
cierto número de cifras significativas.

509
00:27:27,550 --> 00:27:35,120
Así que si imprimimos 8 sig higos en
este flotador, obtenemos una especie de

510
00:27:35,120 --> 00:27:36,800
número feo aspecto.

511
00:27:36,800 --> 00:27:45,580
Y eso es porque 1.31 no puede con precisión
ser representado por simples

512
00:27:45,580 --> 00:27:49,000
potencias de dos en la máquina.

513
00:27:49,000 --> 00:27:53,530
Por lo que termina teniendo el más cercano
Supongo, que termina

514
00:27:53,530 --> 00:27:55,710
ser un poco bajo.

515
00:27:55,710 --> 00:27:57,730
Tiene sentido?

516
00:27:57,730 --> 00:27:59,110
Okay.

517
00:27:59,110 --> 00:28:05,840
>> Ahora, con conmutación son una forma diferente de
haciendo sentencias condicionales donde todos los

518
00:28:05,840 --> 00:28:09,900
que nos importa es una sola variable.

519
00:28:09,900 --> 00:28:16,570
Así que en este ejemplo en particular, estamos
obtener un número entero de usuario.

520
00:28:16,570 --> 00:28:21,070
Y entonces estamos viendo
lo que es entero.

521
00:28:21,070 --> 00:28:23,500
Presumiblemente, es el número
entre uno y cuatro.

522
00:28:23,500 --> 00:28:24,800
Eso es lo que estamos pidiendo.

523
00:28:24,800 --> 00:28:28,450
>> Así lo hace un interruptor de
el nombre de la variable.

524
00:28:28,450 --> 00:28:34,290
Luego de configurar los casos de posible
valora que podría ser.

525
00:28:34,290 --> 00:28:37,730
Así caso de que uno, dicen que es bajo.

526
00:28:37,730 --> 00:28:41,080
Y luego se rompe para salir
de la condición del interruptor de modo

527
00:28:41,080 --> 00:28:43,270
no seguir adelante.

528
00:28:43,270 --> 00:28:44,830
>> En la siguiente caso--

529
00:28:44,830 --> 00:28:46,940
así que caso dos y caso tres--

530
00:28:46,940 --> 00:28:51,920
si es el caso de dos que sólo desciende a
la primera línea de código que ve como con

531
00:28:51,920 --> 00:28:55,400
caso, tres, hasta que ve un descanso.

532
00:28:55,400 --> 00:29:00,430
Así que la razón se obtiene caso de que uno de
sólo impresión bajo es porque

533
00:29:00,430 --> 00:29:01,890
tener este descanso aquí.

534
00:29:01,890 --> 00:29:05,360
Si yo, por ejemplo, ignorado este break--
si me lancé este breakaway--

535
00:29:05,360 --> 00:29:09,740
sería imprimir bajo, y entonces sería
imprimir medio, y luego se rompería.

536
00:29:09,740 --> 00:29:12,200
>> Así descansos son una parte importante
de cambiar las condiciones y

537
00:29:12,200 --> 00:29:14,340
deberían estar allí.

538
00:29:14,340 --> 00:29:20,070
Los casos que no figuran explícitamente
son manejadas por el defecto

539
00:29:20,070 --> 00:29:26,645
caso en el interruptor y sea echado.

540
00:29:26,645 --> 00:29:31,363
>> AUDIENCIA: So 1, 2, 3,
y 4 sería n?

541
00:29:31,363 --> 00:29:33,310
>> DAN: Valores que n puede ser.

542
00:29:33,310 --> 00:29:34,654
Sí.

543
00:29:34,654 --> 00:29:35,146
¿Sí?

544
00:29:35,146 --> 00:29:37,606
>> AUDIENCIA: Así que cuando usted tiene
que [inaudible]?

545
00:29:37,606 --> 00:29:44,002

546
00:29:44,002 --> 00:29:46,830
>> DAN: Usted imprimiría baja, y luego
sería imprimir media y

547
00:29:46,830 --> 00:29:47,400
a continuación, se rompería.

548
00:29:47,400 --> 00:29:50,244
>> AUDIENCIA: ¿Por qué sería imprimir
medio si [inaudible]?

549
00:29:50,244 --> 00:29:54,036

550
00:29:54,036 --> 00:30:00,550
>> DAN: Así que todo bajo un caso
antes de un descanso cae bajo.

551
00:30:00,550 --> 00:30:09,390
Así caso una copia de impresión es el caso por debajo de
uno como es este siguiente impresión.

552
00:30:09,390 --> 00:30:09,890
¿Sí?

553
00:30:09,890 --> 00:30:11,140
>> AUDIENCIA: [inaudible]?

554
00:30:11,140 --> 00:30:15,890

555
00:30:15,890 --> 00:30:22,170
>> DAN: Así que este número es sólo un particular,
valor que esta variable

556
00:30:22,170 --> 00:30:23,420
puede tomar, ¿no?

557
00:30:23,420 --> 00:30:26,740

558
00:30:26,740 --> 00:30:28,490
¿Tiene eso sentido?

559
00:30:28,490 --> 00:30:28,990
Sí.

560
00:30:28,990 --> 00:30:31,490
>> AUDIENCIA: [inaudible]?

561
00:30:31,490 --> 00:30:34,130
>> DAN: Sí, el caso de dos imprimiría
medio y luego romper.

562
00:30:34,130 --> 00:30:35,380
>> AUDIENCIA: [inaudible]?

563
00:30:35,380 --> 00:30:37,954

564
00:30:37,954 --> 00:30:40,050
>> DAN: Creo que cualquier?

565
00:30:40,050 --> 00:30:43,855
¿Qué otros tipos de datos
se puede cambiar de nuevo?

566
00:30:43,855 --> 00:30:46,320
>> AUDIENCIA: Usted puede cambiar
sobre cualquier tipo de datos.

567
00:30:46,320 --> 00:30:50,905
Pero sólo significa algo más caracteres
y ints y cosas por el estilo, ya que

568
00:30:50,905 --> 00:30:55,600
si usted está cambiando más de un puntero
que en realidad no tiene sentido,

569
00:30:55,600 --> 00:30:59,555
conmutación de cargas, si es que vamos a
usted hace eso, porque de punto flotante

570
00:30:59,555 --> 00:31:02,840
en la precisión, no lo harías realmente
quiero hacer eso de todos modos.

571
00:31:02,840 --> 00:31:07,320
Así que más o menos, a sólo enteros y
caracteres y cosas por el estilo.

572
00:31:07,320 --> 00:31:12,360
>> DAN: Sí, es cuando tienes explícita
valores que usted sabe, creo, puede ser

573
00:31:12,360 --> 00:31:14,250
que un cambio es realmente útil.

574
00:31:14,250 --> 00:31:17,094

575
00:31:17,094 --> 00:31:18,990
Bueno?

576
00:31:18,990 --> 00:31:21,370
Okay.

577
00:31:21,370 --> 00:31:26,180
>> Alcance es el rango que un declarado
la variable se extiende.

578
00:31:26,180 --> 00:31:32,190
Así que en este pequeño trozo de código que tengo,
que estaría lleno de errores.

579
00:31:32,190 --> 00:31:41,450
Y la razón es que declaré esto int
i dentro del alcance de este bucle.

580
00:31:41,450 --> 00:31:46,390
Y entonces yo estoy tratando de hacer referencia a ese
i fuera de ese ámbito de bucle.

581
00:31:46,390 --> 00:31:50,330
>> Así que, básicamente, se puede pensar en el alcance
como todo lo que se declara

582
00:31:50,330 --> 00:31:59,750
con el interior de un conjunto de llaves sólo
existe dentro de esas llaves.

583
00:31:59,750 --> 00:32:04,990
Y si se trata de usar esa variable
fuera de esas llaves, podrás

584
00:32:04,990 --> 00:32:08,356
obtendrá un error del compilador.

585
00:32:08,356 --> 00:32:08,812
¿Sí?

586
00:32:08,812 --> 00:32:09,724
>> AUDIENCIA: Así que éste no funciona?

587
00:32:09,724 --> 00:32:11,790
>> DAN: Esto no funciona, sí.

588
00:32:11,790 --> 00:32:17,190

589
00:32:17,190 --> 00:32:18,660
Cuerdas.

590
00:32:18,660 --> 00:32:19,780
String a char *.

591
00:32:19,780 --> 00:32:22,250
Son exactamente lo mismo.

592
00:32:22,250 --> 00:32:25,540
Ellos son sólo punteros a caracteres.

593
00:32:25,540 --> 00:32:33,000
Y cualquier cadena que tiene deben terminar
con barra invertida cero, que es justo

594
00:32:33,000 --> 00:32:34,410
una convención c.

595
00:32:34,410 --> 00:32:36,680
>> Se llama el terminador NULL.

596
00:32:36,680 --> 00:32:39,050
Y NULL--

597
00:32:39,050 --> 00:32:41,670
N mayúscula, capital de U, el capital
L, de capital L--

598
00:32:41,670 --> 00:32:44,290
no es el mismo que el
Terminador NULL.

599
00:32:44,290 --> 00:32:46,640
Esto es un puntero.

600
00:32:46,640 --> 00:32:48,280
Este es un personaje.

601
00:32:48,280 --> 00:32:49,530
Son muy distintos.

602
00:32:49,530 --> 00:32:50,200
Recuérdalo.

603
00:32:50,200 --> 00:32:52,320
Será en el cuestionario, probablemente.

604
00:32:52,320 --> 00:32:54,040
No he visto la prueba.

605
00:32:54,040 --> 00:32:57,880

606
00:32:57,880 --> 00:32:58,840
¿Sí?

607
00:32:58,840 --> 00:33:01,232
>> AUDIENCIA: Así NULL es, por ejemplo, el puntero?

608
00:33:01,232 --> 00:33:01,995
>> DAN: Si.

609
00:33:01,995 --> 00:33:05,170
>> AUDIENCIA: ¿Qué hace [inaudible]?

610
00:33:05,170 --> 00:33:10,050
>> DAN: Si, dicen, malloc se llama cuando usted
no tienen suficiente memoria para obtener

611
00:33:10,050 --> 00:33:14,400
sea ​​cual sea el tamaño que usted está pidiendo,
malloc devolverá NULL.

612
00:33:14,400 --> 00:33:19,550
Es, básicamente, cada vez que una función es
supone que devolver un puntero,

613
00:33:19,550 --> 00:33:22,600
que comprobar contra NULL porque
NULL es un bueno-- bastante

614
00:33:22,600 --> 00:33:25,260
es, más o menos, el valor de la basura.

615
00:33:25,260 --> 00:33:27,050
Es un cero en la medida de como punteros van.

616
00:33:27,050 --> 00:33:29,630

617
00:33:29,630 --> 00:33:32,250
>> Cada vez que se llama a una función,
que devuelve un puntero.

618
00:33:32,250 --> 00:33:35,960
Usted va a querer comprobar que
Seguro que ese puntero no es NULL

619
00:33:35,960 --> 00:33:37,760
porque NULL es muy común.

620
00:33:37,760 --> 00:33:40,160
Es una especie de un retorno de la basura.

621
00:33:40,160 --> 00:33:44,902
Así que si algo no iba bien,
simplemente devolver NULL en su lugar.

622
00:33:44,902 --> 00:33:45,898
>> AUDIENCIA: [inaudible]?

623
00:33:45,898 --> 00:33:48,922
>> DAN: Sí, y eso es esto.

624
00:33:48,922 --> 00:33:51,750
>> AUDIENCIA: [inaudible]?

625
00:33:51,750 --> 00:33:52,800
>> DAN: Spell como este.

626
00:33:52,800 --> 00:33:54,150
Es el terminador NULL.

627
00:33:54,150 --> 00:33:56,560
Es minúsculas N-U-L-L si
está deletreando ella.

628
00:33:56,560 --> 00:33:59,860
>> AUDIENCIA: Y me fui
espalda y probado.

629
00:33:59,860 --> 00:34:03,010
Y si tratas de poner un punto flotante
valor en un interruptor, que va a gritar a usted

630
00:34:03,010 --> 00:34:05,916
decir, declaración requiere la expresión
de tipo entero.

631
00:34:05,916 --> 00:34:07,166
>> DAN: Hay que ir.

632
00:34:07,166 --> 00:34:09,639

633
00:34:09,639 --> 00:34:12,246
Pero sí, lo era la pregunta?

634
00:34:12,246 --> 00:34:13,496
>> AUDIENCIA: [inaudible]?

635
00:34:13,496 --> 00:34:16,150

636
00:34:16,150 --> 00:34:23,679
>> DAN: Así de capital N, U mayúscula, el capital
L, L mayúscula es una cosa real c.

637
00:34:23,679 --> 00:34:29,719
Es el puntero NULL y voluntad
sólo ser tratados como tales.

638
00:34:29,719 --> 00:34:33,530
Usted nunca va a tratar de explicar el
Carácter nulo y ver cualquier

639
00:34:33,530 --> 00:34:35,630
otra manera que esto.

640
00:34:35,630 --> 00:34:36,610
¿Sí?

641
00:34:36,610 --> 00:34:42,490
>> AUDIENCIA: Así que volviendo a char máximo o
algo en las notas, ¿verdad

642
00:34:42,490 --> 00:34:43,960
encarnar la misma función
como [inaudible]?

643
00:34:43,960 --> 00:34:50,655

644
00:34:50,655 --> 00:34:54,949
>> AUDIENCIA: Así que te refieres
regresar max caracteres de getchar, o

645
00:34:54,949 --> 00:34:55,444
sea ​​lo que sea?

646
00:34:55,444 --> 00:34:55,940
>> AUDIENCIA: Si.

647
00:34:55,940 --> 00:34:58,620
>> AUDIENCIA: Sí, por lo general
plazo para todas esas cosas

648
00:34:58,620 --> 00:34:59,920
son valores centinela.

649
00:34:59,920 --> 00:35:03,640
Así como volver int max de getInt
y trucha máximo de getchar, es

650
00:35:03,640 --> 00:35:06,010
supone que es igual, de acuerdo, si
estas cosas están volviendo a nosotros,

651
00:35:06,010 --> 00:35:07,210
algo salió mal.

652
00:35:07,210 --> 00:35:09,950
>> Para los perros, sólo sucede que tiene
este valor centinela que todo el mundo

653
00:35:09,950 --> 00:35:10,750
conviene en.

654
00:35:10,750 --> 00:35:13,210
Y esto es lo que regrese
cuando las cosas van mal.

655
00:35:13,210 --> 00:35:15,910
Así max char es lo que estamos utilizando
para representar algo

656
00:35:15,910 --> 00:35:18,100
como NULL o getchar.

657
00:35:18,100 --> 00:35:23,420
>> AUDIENCIA: Así que si usted está probando getchar,
podría usted acaba de poner NULL?

658
00:35:23,420 --> 00:35:23,910
¿Sería eso una diferencia?

659
00:35:23,910 --> 00:35:25,400
>> DAN: No podías comprobar NULL.

660
00:35:25,400 --> 00:35:30,130
Habría que revisar caracteres máximo debido a que el
valor de retorno de la función es

661
00:35:30,130 --> 00:35:35,416
un carácter no un puntero.

662
00:35:35,416 --> 00:35:35,888
¿Sí?

663
00:35:35,888 --> 00:35:38,248
>> AUDIENCIA: Esta pregunta
para la longitud de la cadena.

664
00:35:38,248 --> 00:35:40,136
¿Eso incluye el carácter NULL?

665
00:35:40,136 --> 00:35:41,000
>> DAN: No.

666
00:35:41,000 --> 00:35:45,930
Y eso es en realidad la forma de longitud de serie
sabe que parar porque se pasa por

667
00:35:45,930 --> 00:35:49,070
la matriz de caracteres hasta
se ve un carácter NULL.

668
00:35:49,070 --> 00:35:51,030
Y entonces es como, todo
bien, he terminado.

669
00:35:51,030 --> 00:35:52,130
>> AUDIENCIA: [inaudible] de cinco?

670
00:35:52,130 --> 00:35:53,990
>> DAN: Hola sería cinco.

671
00:35:53,990 --> 00:35:55,240
Sip.

672
00:35:55,240 --> 00:35:59,580

673
00:35:59,580 --> 00:36:02,880
Así arrays son continuas
bloques de memoria.

674
00:36:02,880 --> 00:36:08,480
Ellos tienen acceso inmediato al decir que el
nombre de la matriz y, a continuación, en rizado

675
00:36:08,480 --> 00:36:16,720
apoyos, cualquiera que sea el índice que desea ir
a, que están indexados a partir de cero a

676
00:36:16,720 --> 00:36:20,100
la longitud de la matriz menos 1.

677
00:36:20,100 --> 00:36:23,070
>> Y están declarados por el tipo de la
Lo que usted está almacenando en el

678
00:36:23,070 --> 00:36:29,750
matriz, el nombre de la matriz, y luego
cualquiera que sea el tamaño es de esa matriz.

679
00:36:29,750 --> 00:36:36,660
Así que esta es una matriz de caracteres de longitud
seis que tiene esos valores.

680
00:36:36,660 --> 00:36:42,050

681
00:36:42,050 --> 00:36:42,700
¿Sí?

682
00:36:42,700 --> 00:36:43,950
>> AUDIENCIA: [inaudible]?

683
00:36:43,950 --> 00:36:47,980

684
00:36:47,980 --> 00:36:48,460
>> DAN: Si.

685
00:36:48,460 --> 00:36:51,340
>> AUDIENCIA: [inaudible]?

686
00:36:51,340 --> 00:36:56,700
>> DAN: Si usted tiene lo que está pasando
en la matriz ya hecha.

687
00:36:56,700 --> 00:37:02,260
Así que se podría especificar esta vez como,
por ejemplo, char, cualquiera que sea el nombre de su

688
00:37:02,260 --> 00:37:12,200
matriz es, corchetes vacíos es igual rizado
prepararse H E coma coma coma L L comas

689
00:37:12,200 --> 00:37:16,290
O coma carácter NULL
y llave de cierre.

690
00:37:16,290 --> 00:37:18,180
Eso también funciona como una declaración.

691
00:37:18,180 --> 00:37:20,886
>> AUDIENCIA: [inaudible]?

692
00:37:20,886 --> 00:37:23,110
>> DAN: Entonces es necesario tener
el tamaño ya hizo.

693
00:37:23,110 --> 00:37:23,896
>> AUDIENCIA: [inaudible]?

694
00:37:23,896 --> 00:37:25,146
>> DAN: Si.

695
00:37:25,146 --> 00:37:30,114

696
00:37:30,114 --> 00:37:32,420
Muy bien.

697
00:37:32,420 --> 00:37:36,430
Argumentos de la línea de comandos son una forma de
obtener la entrada del usuario como

698
00:37:36,430 --> 00:37:39,380
argumentos a principal.

699
00:37:39,380 --> 00:37:40,600
Principal tiene dos argumentos.

700
00:37:40,600 --> 00:37:47,680
El número de argumentos que se está
pasado a lo largo de la línea de comandos y un

701
00:37:47,680 --> 00:37:55,340
vector cadena o una matriz de cadenas
de todos los argumentos.

702
00:37:55,340 --> 00:38:07,840
>> Así que si, por ejemplo, llamé a una función como
un punto a 1 plaza, 2 plaza, tres,

703
00:38:07,840 --> 00:38:10,110
argc sería 4.

704
00:38:10,110 --> 00:38:17,370
Y el argv 0 sería un punto fuera.

705
00:38:17,370 --> 00:38:19,130
Argv1 sería 1.

706
00:38:19,130 --> 00:38:23,030
argv2 sería 2. argv3 serían
3, en ese caso particular.

707
00:38:23,030 --> 00:38:23,310
¿Sí?

708
00:38:23,310 --> 00:38:25,400
>> AUDIENCIA: [inaudible]?

709
00:38:25,400 --> 00:38:34,010
>> DAN: El último elemento de la matriz
porque la matriz es la longitud argc más

710
00:38:34,010 --> 00:38:41,050
uno de argb, el último elemento
es el puntero NULL.

711
00:38:41,050 --> 00:38:42,580
Es más argc 1.

712
00:38:42,580 --> 00:38:46,210

713
00:38:46,210 --> 00:38:52,150
Así que en el caso que acabo de decir, que
se argv 0 es un punto fuera.

714
00:38:52,150 --> 00:38:56,330
argv 1 es 1. argv2 es 2. argv 3 es 3.

715
00:38:56,330 --> 00:39:03,490
argv 4, que es uno más grande
que argc sería NULL.

716
00:39:03,490 --> 00:39:04,870
>> Y eso es el puntero NULL.

717
00:39:04,870 --> 00:39:06,590
Sí.

718
00:39:06,590 --> 00:39:11,250
Y eso es porque la cadena es
una estrella char es un puntero.

719
00:39:11,250 --> 00:39:14,102
Así que tiene que ser del mismo tipo.

720
00:39:14,102 --> 00:39:14,595
¿Sí?

721
00:39:14,595 --> 00:39:16,074
>> AUDIENCIA: Dos preguntas.

722
00:39:16,074 --> 00:39:21,004
Así que uno, ¿cuál es la diferencia entre
esto y GetString otra de un tipo

723
00:39:21,004 --> 00:39:22,483
en el motor de usuario?

724
00:39:22,483 --> 00:39:25,934
Y dos, que se almacena en
su historia reciente?

725
00:39:25,934 --> 00:39:28,399
Así como, GetString haría
ser [inaudible]?

726
00:39:28,399 --> 00:39:31,357

727
00:39:31,357 --> 00:39:33,650
>> DAN: ¿Dónde se almacena?

728
00:39:33,650 --> 00:39:34,905
No sé donde se almacena.

729
00:39:34,905 --> 00:39:40,000
>> AUDIENCIA: Así que, en realidad, ya sabes cómo cualquier
función que llama a sus argumentos

730
00:39:40,000 --> 00:39:42,170
se almacenan en la pila?

731
00:39:42,170 --> 00:39:46,610
Así argc y argv son argumentos a principal
y están en la pila, o realmente

732
00:39:46,610 --> 00:39:49,131
justo por encima de lo que usted piensa como
el comienzo de la pila.

733
00:39:49,131 --> 00:39:53,490
¿Cuál era la otra parte
de la pregunta?

734
00:39:53,490 --> 00:39:56,821
>> AUDIENCIA: ¿Cuál es la [inaudible]?

735
00:39:56,821 --> 00:40:00,990
>> DAN: Sí, es sólo una manera diferente
de conseguir la entrada del usuario.

736
00:40:00,990 --> 00:40:06,030
Ligeramente más eficiente y de este uno
es más práctico para los scripts porque

737
00:40:06,030 --> 00:40:10,070
sólo puede pasar argumentos a su principal
función en lugar de tener que esperar

738
00:40:10,070 --> 00:40:13,400
para los usuarios si usted no tiene ningún usuario.

739
00:40:13,400 --> 00:40:16,280
>> AUDIENCIA: Y sí, conseguir cadenas
sería [inaudible].

740
00:40:16,280 --> 00:40:17,922
Sería almacenar las cosas que necesita.

741
00:40:17,922 --> 00:40:18,834
>> DAN: ¿Sí?

742
00:40:18,834 --> 00:40:21,114
>> AUDIENCIA: [inaudible]?

743
00:40:21,114 --> 00:40:27,545
>> DAN: Sí, argv 0 siempre incluye la
punto slash de la llamada a la función.

744
00:40:27,545 --> 00:40:28,042
¿Sí?

745
00:40:28,042 --> 00:40:29,292
>> AUDIENCIA: [inaudible]?

746
00:40:29,292 --> 00:40:33,509

747
00:40:33,509 --> 00:40:37,310
>> DAN: Sí, cada uno de los argumentos son
terminó en carácter NULL porque

748
00:40:37,310 --> 00:40:38,310
son cadenas.

749
00:40:38,310 --> 00:40:40,892
>> AUDIENCIA: [inaudible]?

750
00:40:40,892 --> 00:40:44,116
>> DAN: Sí, argc argv es un puntero NULL.

751
00:40:44,116 --> 00:40:45,112
>> AUDIENCIA: [inaudible]?

752
00:40:45,112 --> 00:40:47,104
>> DAN: Ah, sí.

753
00:40:47,104 --> 00:40:48,100
Sí, lo siento.

754
00:40:48,100 --> 00:40:49,594
>> AUDIENCIA: Así que [inaudible]?

755
00:40:49,594 --> 00:41:08,518

756
00:41:08,518 --> 00:41:16,340
>> DAN: Así que la pregunta es si usted tuviera la
punto de línea de comandos slash un punto a cabo 1, 2,

757
00:41:16,340 --> 00:41:20,410
haría el número de línea de comandos
argumentos sean dos o tendrían que ser tres?

758
00:41:20,410 --> 00:41:24,420

759
00:41:24,420 --> 00:41:28,240
>> AUDIENCIA: Creo que no hace
realmente importa.

760
00:41:28,240 --> 00:41:31,370
Tiendo a decir, oh, que no pasó
cualquier argumento de línea de comandos cuando,

761
00:41:31,370 --> 00:41:32,730
obviamente, que llamó a la función.

762
00:41:32,730 --> 00:41:37,950
Así que tiendo a excluir vocalmente la
función desde la línea de comandos

763
00:41:37,950 --> 00:41:40,350
argumentos, aunque es
incluido en argv.

764
00:41:40,350 --> 00:41:42,600
>> DAN: Pero si estaba en el test--

765
00:41:42,600 --> 00:41:46,550
Sí-- y también si usted dice algo
como argc es igual a 3,

766
00:41:46,550 --> 00:41:48,512
usted está en la caja fuerte de pie.

767
00:41:48,512 --> 00:41:49,416
¿Sí?

768
00:41:49,416 --> 00:41:50,666
>> AUDIENCIA: [inaudible]?

769
00:41:50,666 --> 00:42:00,990

770
00:42:00,990 --> 00:42:09,510
>> DAN: Creo que si en lugar de llamar a este
en argc y argv cadena entre paréntesis

771
00:42:09,510 --> 00:42:14,350
pero mantuvo los mismos tipos y acaba de llamar
ellos algo diferente como un

772
00:42:14,350 --> 00:42:16,640
y b, ¿seguiría trabajando?

773
00:42:16,640 --> 00:42:18,790
Y no por ello deja trabajar,
usted solo--

774
00:42:18,790 --> 00:42:21,520
en lugar de utilizar argc--
tendrá que utilizar a y b.

775
00:42:21,520 --> 00:42:24,436

776
00:42:24,436 --> 00:42:25,408
¿Sí?

777
00:42:25,408 --> 00:42:26,658
>> AUDIENCIA: [inaudible]?

778
00:42:26,658 --> 00:42:34,642

779
00:42:34,642 --> 00:42:38,850
>> DAN: Así que la pregunta es GetString es
va a almacenar la memoria en el montón

780
00:42:38,850 --> 00:42:42,280
porque GetString es char *.

781
00:42:42,280 --> 00:42:47,530
Almacena la memoria en el montón, ya que
pide ahora malloc en el real

782
00:42:47,530 --> 00:42:49,258
aplicación de GetString.

783
00:42:49,258 --> 00:42:53,210

784
00:42:53,210 --> 00:42:55,090
Aceptar, seguir adelante.

785
00:42:55,090 --> 00:42:55,950
>> Seguridad.

786
00:42:55,950 --> 00:43:01,090
Así que para que sea realmente seguro, usted confía en no
uno y permites que nadie el acceso a cualquier

787
00:43:01,090 --> 00:43:04,540
de su información, que es la razón por
cada uno construye sus propias máquinas,

788
00:43:04,540 --> 00:43:09,580
sus propios sistemas operativos, toda su
programas a partir de cero, y, obviamente,

789
00:43:09,580 --> 00:43:13,410
no conecte a cualquier otra máquina
a través de Internet.

790
00:43:13,410 --> 00:43:17,350
Así que las computadoras son inseguras.

791
00:43:17,350 --> 00:43:19,200
Ellos realmente son.

792
00:43:19,200 --> 00:43:20,940
Tenemos que confiar en otras personas.

793
00:43:20,940 --> 00:43:26,500
>> Y la idea de la seguridad es que eres
tratando de limitar la cantidad de

794
00:43:26,500 --> 00:43:27,540
la confianza que usted necesita.

795
00:43:27,540 --> 00:43:32,080
Y uno de los medios que hace que
es a través de la criptografía.

796
00:43:32,080 --> 00:43:34,950
La criptografía es, en esencia,
tenemos secretos.

797
00:43:34,950 --> 00:43:38,880
>> A veces tenemos que pasar nuestros secretos
a lo largo a través, por ejemplo, el Internet o

798
00:43:38,880 --> 00:43:39,980
otras cosas.

799
00:43:39,980 --> 00:43:43,180
Y no queremos que la gente
conocer estos secretos.

800
00:43:43,180 --> 00:43:50,100
Así que ciframos nuestros secretos en un camino
que esperamos que nadie puede imaginar.

801
00:43:50,100 --> 00:43:51,600
>> Así que used--

802
00:43:51,600 --> 00:43:54,340
a través del curso de este class--

803
00:43:54,340 --> 00:44:00,750
cosas como cifrado César y
[Inaudible], que son a la vez muy, muy

804
00:44:00,750 --> 00:44:03,200
formas inseguras de la encriptación de las cosas.

805
00:44:03,200 --> 00:44:07,930
Son fáciles de averiguar lo que
son y cuáles son sus secretos son.

806
00:44:07,930 --> 00:44:12,130
El mundo real utiliza mucho más
esquemas de cifrado complicados.

807
00:44:12,130 --> 00:44:13,880
Y no vamos a entrar en
mucho más que eso.

808
00:44:13,880 --> 00:44:18,280

809
00:44:18,280 --> 00:44:19,430
>> Depuración.

810
00:44:19,430 --> 00:44:20,785
GDB es el mejor.

811
00:44:20,785 --> 00:44:24,014

812
00:44:24,014 --> 00:44:25,810
Voy a insistir en esto otra vez.

813
00:44:25,810 --> 00:44:30,920
Utilice GDB todo el tiempo cada
vez que tenga un problema.

814
00:44:30,920 --> 00:44:36,030
Los comandos que son útiles en el BGF son
rompes, lo que pasa, ya sea una línea

815
00:44:36,030 --> 00:44:41,330
número, un nombre de función, esencialmente
donde en el código que desee detener,

816
00:44:41,330 --> 00:44:45,600
y ser capaz de tomar el control.

817
00:44:45,600 --> 00:44:54,140
>> Imprimir toma una variable e imprime
cualquiera que sea esa variable es en ese

818
00:44:54,140 --> 00:44:55,990
momento de su ejecución.

819
00:44:55,990 --> 00:45:00,130
Siguiente mueve su ejecución
a lo largo de un solo paso.

820
00:45:00,130 --> 00:45:05,050
Y paso pasos dentro de una función
en su ejecución.

821
00:45:05,050 --> 00:45:10,480
>> Otras cosas se ejecutan, que es como
en realidad se ejecuta el código.

822
00:45:10,480 --> 00:45:16,630
Continuar toma todas las medidas necesarias
para llegar al siguiente punto de ruptura.

823
00:45:16,630 --> 00:45:18,300
Y hay muchos, muchos otros.

824
00:45:18,300 --> 00:45:19,040
Búscalos.

825
00:45:19,040 --> 00:45:19,901
Son excelentes.

826
00:45:19,901 --> 00:45:20,863
¿Sí?

827
00:45:20,863 --> 00:45:22,113
>> AUDIENCIA: [inaudible]?

828
00:45:22,113 --> 00:45:26,635

829
00:45:26,635 --> 00:45:28,200
>> DAN: Sí, que es un depurador.

830
00:45:28,200 --> 00:45:34,230
Así que un depurador es un programa que
le permite comprobar el programa.

831
00:45:34,230 --> 00:45:39,931
No es un programa que encuentra errores para
que, sin embargo, que sería grande.

832
00:45:39,931 --> 00:45:43,020

833
00:45:43,020 --> 00:45:46,040
>> Y por último, para mí es la búsqueda.

834
00:45:46,040 --> 00:45:51,470
Así que los tipos de búsqueda que hablamos
acerca de esta clase son búsqueda lineal,

835
00:45:51,470 --> 00:45:55,960
que es justo que se mira a través de cada
elemento del espacio de búsqueda, uno

836
00:45:55,960 --> 00:46:00,410
elemento a la vez, hasta encontrar lo que
usted está buscando o hasta que llegue

837
00:46:00,410 --> 00:46:03,350
Al final de su espacio de búsqueda en el que
señala que dices que no se podía encontrar

838
00:46:03,350 --> 00:46:06,360
el elemento que estabas buscando.

839
00:46:06,360 --> 00:46:13,450
Y esto lleva tiempo, en el mejor constante,
que es 0 de 1 y en el peor lineal

840
00:46:13,450 --> 00:46:16,070
tiempo, que es 0 de n.

841
00:46:16,070 --> 00:46:19,250
>> La búsqueda binaria, que necesita
elementos sórdidos.

842
00:46:19,250 --> 00:46:24,230
Usted va a la mitad de sus elementos,
ver si el elemento que está buscando

843
00:46:24,230 --> 00:46:30,120
es mayor o menor que el elemento
que estás en el medio.

844
00:46:30,120 --> 00:46:36,510
Es que es más grande, se dice que el fondo
de su búsqueda de espacio es su

845
00:46:36,510 --> 00:46:41,550
ubicación actual, el medio,
y reiniciar el proceso.

846
00:46:41,550 --> 00:46:46,150
Si es menor, se mira dicen
que el-- sí, ¿qué pasa?

847
00:46:46,150 --> 00:46:47,400
>> AUDIENCIA: [inaudible]?

848
00:46:47,400 --> 00:46:51,000

849
00:46:51,000 --> 00:46:54,260
>> DAN: Si.

850
00:46:54,260 --> 00:46:58,360
Cualquier tipo de especie que se ha enseñado en
la clase es un juego justo para la prueba.

851
00:46:58,360 --> 00:47:01,504

852
00:47:01,504 --> 00:47:04,920
>> [Risas]

853
00:47:04,920 --> 00:47:10,260
>> DAN: Y el hecho de que usted no ha tenido
que lo haga por una serie de problemas, que es justo

854
00:47:10,260 --> 00:47:12,420
juego para la prueba.

855
00:47:12,420 --> 00:47:15,186
>> AUDIENCIA: ¿Podemos ir sobre ella cómo a--

856
00:47:15,186 --> 00:47:17,052
>> DAN: Se ha ido otra vez.

857
00:47:17,052 --> 00:47:20,496
>> ALTAVOZ 2: El código real para
[Inaudible] es en study.cs50.net.

858
00:47:20,496 --> 00:47:25,910

859
00:47:25,910 --> 00:47:32,680
Así que si nos fijamos en el problema la práctica
en la página de combinación de tipo de

860
00:47:32,680 --> 00:47:35,880
study.cs50.net, no es el código
para la implementación de fusionar especie.

861
00:47:35,880 --> 00:47:38,550
Así que usted no tiene que poner en práctica
usted mismo esta noche.

862
00:47:38,550 --> 00:47:42,090
Pero asegúrese de que entiende que en lugar
que simplemente memorizarla.

863
00:47:42,090 --> 00:47:45,035
>> AUDIENCIA: [inaudible]?

864
00:47:45,035 --> 00:47:49,720
>> ALTAVOZ 2: La página de combinación de tipo de
study.cs50.net, existe una práctica

865
00:47:49,720 --> 00:47:53,570
problema que, si hace clic a través de la
problema, al final hay una

866
00:47:53,570 --> 00:47:56,280
solución, que es la combinación
aplicación especie.

867
00:47:56,280 --> 00:47:58,510
Pero asegúrese de que entiende que
y no sólo memorizarla

868
00:47:58,510 --> 00:47:59,760
o copiar hacia abajo.

869
00:47:59,760 --> 00:48:02,870

870
00:48:02,870 --> 00:48:06,340
>> AUDIENCIA: Y un perfectamente válido
problema para el examen sería

871
00:48:06,340 --> 00:48:07,990
algo así aquí está una lista.

872
00:48:07,990 --> 00:48:12,100
¿Qué hace esta lista parece después
un paso de selecciones tipo u

873
00:48:12,100 --> 00:48:13,330
ordenación por inserción o lo que sea.

874
00:48:13,330 --> 00:48:14,940
Una iteración completa de la lista.

875
00:48:14,940 --> 00:48:18,530
Así que incluso si usted no termina encima de necesitar
código para ello, es necesario comprender que

876
00:48:18,530 --> 00:48:20,440
suficiente para saber cómo va
que la modificación de esta matriz.

877
00:48:20,440 --> 00:48:24,144

878
00:48:24,144 --> 00:48:25,394
>> DAN: Eso es todo para mí.

879
00:48:25,394 --> 00:48:30,604

880
00:48:30,604 --> 00:48:32,588
>> [Aplausos]

881
00:48:32,588 --> 00:49:06,316

882
00:49:06,316 --> 00:49:07,410
>> LUCAS: Hola a todos.

883
00:49:07,410 --> 00:49:08,390
Mi nombre es Lucas.

884
00:49:08,390 --> 00:49:16,840
Voy a hablar de la recursividad, todo
las clases que hemos aprendido, y un

885
00:49:16,840 --> 00:49:18,050
poco de todos los punteros.

886
00:49:18,050 --> 00:49:18,740
¿De acuerdo?

887
00:49:18,740 --> 00:49:20,340
Así que primero de todo, la recursión.

888
00:49:20,340 --> 00:49:22,951
¿Qué significa decir que
es una función recursiva?

889
00:49:22,951 --> 00:49:24,675
>> AUDIENCIA: Llamadas en sí.

890
00:49:24,675 --> 00:49:26,500
>> LUCAS: OK, llama a sí mismo, sí.

891
00:49:26,500 --> 00:49:27,700
Así que te gusta esta foto, por ejemplo.

892
00:49:27,700 --> 00:49:30,280
Es como la imagen en el interior
de una imagen y así sucesivamente.

893
00:49:30,280 --> 00:49:35,740
Así, por ejemplo, puede tener-- como Dan
que hablaba de búsqueda binaria.

894
00:49:35,740 --> 00:49:41,840
Una forma en que la búsqueda binaria es
recursivo es el hecho de que eres

895
00:49:41,840 --> 00:49:43,130
tratando de encontrar un número.

896
00:49:43,130 --> 00:49:44,250
Así que ir al centro.

897
00:49:44,250 --> 00:49:47,130
Y a continuación, comprobar si los números allí
en la izquierda y en la derecha.

898
00:49:47,130 --> 00:49:49,650
>> Y entonces si usted descubre que el número es
va a ser de la izquierda, que es la misma

899
00:49:49,650 --> 00:49:53,340
cosa como hacer la búsqueda de nuevo, pero
sólo en la izquierda de la lista.

900
00:49:53,340 --> 00:49:57,350
Así que así es como suena
como que es recursivo.

901
00:49:57,350 --> 00:50:01,870
Así que es por eso que ustedes tienen recursiva
solución para merge sort.

902
00:50:01,870 --> 00:50:04,270
>> OK, así que aquí está un ejemplo.

903
00:50:04,270 --> 00:50:07,280
Así que digamos que yo quiero elegir
todos los números de 1 a n.

904
00:50:07,280 --> 00:50:13,790
Puedo darme cuenta de que la suma de los n
número es n más n menos 1 hasta 1.

905
00:50:13,790 --> 00:50:17,810
Pero entonces, si miro n menos 1 más
n menos 2 más 1, que es el mismo

906
00:50:17,810 --> 00:50:20,680
cosa como números cuya suma
hasta n menos 1.

907
00:50:20,680 --> 00:50:25,890
Así que puedo decir que la suma de una cantidad igual
es igual a n más la suma de n menos 1.

908
00:50:25,890 --> 00:50:28,010
¿Tiene eso sentido?

909
00:50:28,010 --> 00:50:32,630
>> Y yo también tendría algo más
llamado el caso base, que es que

910
00:50:32,630 --> 00:50:37,440
la suma de los números hasta
a cero sería cero.

911
00:50:37,440 --> 00:50:42,770
Así que tan pronto como llegue al número
cero, que detener el conteo.

912
00:50:42,770 --> 00:50:45,330
¿Tiene eso sentido?

913
00:50:45,330 --> 00:50:48,120
>> Así que aquí está un ejemplo de cómo
Puedo aplicar eso.

914
00:50:48,120 --> 00:50:49,860
Así que tengo esta función en algunos.

915
00:50:49,860 --> 00:50:51,700
Para eso se necesita un entero n.

916
00:50:51,700 --> 00:50:56,300
Así que aquí primero compruebo si n es
menos o igual a cero.

917
00:50:56,300 --> 00:51:00,310
Así que si es menor o igual a cero, I
devolver cero, que es nuestro caso base.

918
00:51:00,310 --> 00:51:05,690
De lo contrario, sólo puede volver n más
la suma de los números de

919
00:51:05,690 --> 00:51:07,190
uno a n menos uno.

920
00:51:07,190 --> 00:51:09,360
Tiene sentido?

921
00:51:09,360 --> 00:51:10,100
Okay.

922
00:51:10,100 --> 00:51:11,610
>> Así que aquí está lo que parece.

923
00:51:11,610 --> 00:51:15,260
Tiene suma de 2 pares
2 más la suma de 1.

924
00:51:15,260 --> 00:51:18,930
Y algunos de 1 es 1 más el
suma de 0, que es 0.

925
00:51:18,930 --> 00:51:20,216
Tiene sentido?

926
00:51:20,216 --> 00:51:25,342
Así que si nos fijamos en la pila de su
programa, esto es lo que parece.

927
00:51:25,342 --> 00:51:26,820
>> En primer lugar, tenemos la función principal.

928
00:51:26,820 --> 00:51:30,320
Y a continuación, la función principal
llamada suma 2.

929
00:51:30,320 --> 00:51:36,690
Y a continuación, suma 2 que va a decir, oh, suma
2 es igual a 2, más la suma de uno.

930
00:51:36,690 --> 00:51:39,460
Así que añado suma de 1 a la pila.

931
00:51:39,460 --> 00:51:43,860
Y la suma de 1 va a llamar suma de
0, que también va a ser añadido

932
00:51:43,860 --> 00:51:44,630
a la pila.

933
00:51:44,630 --> 00:51:49,240
Y entonces cada uno de estos los que están
en la parte superior de otro tener que volver

934
00:51:49,240 --> 00:51:52,020
antes de que los demás pueden seguir adelante.

935
00:51:52,020 --> 00:51:56,240
>> Así, por ejemplo, aquí, suma de 0,
en primer lugar, se va a devolver 0.

936
00:51:56,240 --> 00:51:58,320
Y a continuación, elija suma de 1.

937
00:51:58,320 --> 00:52:00,850
Luego suma de 1 va a
devuelve 1 a la suma de 2.

938
00:52:00,850 --> 00:52:03,900
Y finalmente, suma de 2 va
para volver a la principal 3.

939
00:52:03,900 --> 00:52:05,320
¿Tiene eso sentido?

940
00:52:05,320 --> 00:52:09,496
>> Es muy importante entender cómo
la pila está trabajando y tratar de

941
00:52:09,496 --> 00:52:11,980
ver si tiene sentido.

942
00:52:11,980 --> 00:52:13,260
Aceptar, por lo que la clasificación.

943
00:52:13,260 --> 00:52:16,170
Así que ¿por qué es importante la clasificación,
ante todo?

944
00:52:16,170 --> 00:52:18,260
¿Por qué debería importarnos?

945
00:52:18,260 --> 00:52:20,310
¿Alguien?

946
00:52:20,310 --> 00:52:20,695
Dame un ejemplo?

947
00:52:20,695 --> 00:52:21,040
¿Sí?

948
00:52:21,040 --> 00:52:22,968
>> AUDIENCIA: [inaudible].

949
00:52:22,968 --> 00:52:24,700
>> LUCAS: Sí, está bien.

950
00:52:24,700 --> 00:52:26,090
Así que usted puede buscar de manera más eficiente.

951
00:52:26,090 --> 00:52:28,580
Eso es una buena manera.

952
00:52:28,580 --> 00:52:32,462
Así, por ejemplo, tenemos una gran cantidad de
cosas, en realidad, en nuestras vidas que

953
00:52:32,462 --> 00:52:32,920
se ordenan.

954
00:52:32,920 --> 00:52:34,830
Por ejemplo, los diccionarios.

955
00:52:34,830 --> 00:52:39,210
>> Es muy importante tener toda la
palabras en algún tipo de orden que

956
00:52:39,210 --> 00:52:41,970
puede acceder fácilmente.

957
00:52:41,970 --> 00:52:43,280
Así que eso es lo que estaba diciendo.

958
00:52:43,280 --> 00:52:45,530
Usted puede buscar de manera más eficiente.

959
00:52:45,530 --> 00:52:48,740
Piense en lo difícil que sería tener un
diccionario en el que las palabras están en

960
00:52:48,740 --> 00:52:49,500
orden aleatorio.

961
00:52:49,500 --> 00:52:53,120
Vas a tener que ver, más o menos,
cada palabra hasta que encuentre el

962
00:52:53,120 --> 00:52:54,720
palabra que usted está buscando.

963
00:52:54,720 --> 00:52:58,710
>> Si estás usando Facebook También, cuando
lo que buscas en tus amigos, eres

964
00:52:58,710 --> 00:53:03,540
vamos a ver que Facebook pone a su
amigo más cercano está en la cima de los

965
00:53:03,540 --> 00:53:05,470
que no habla con tanto.

966
00:53:05,470 --> 00:53:08,080
Si usted va todo el camino hasta la parte inferior de
tu lista de amigos, vas a ver

967
00:53:08,080 --> 00:53:11,250
personas que probablemente ni siquiera
recuerde que usted es amigo de.

968
00:53:11,250 --> 00:53:14,590
Y eso es porque las clases de Facebook
sus amigos en función de cómo

969
00:53:14,590 --> 00:53:16,472
cerca está de ellos.

970
00:53:16,472 --> 00:53:17,930
>> Así que la organización de los datos.

971
00:53:17,930 --> 00:53:18,450
También Pokemon.

972
00:53:18,450 --> 00:53:21,400
Así que ya ves que todos los Pokémons
tener números.

973
00:53:21,400 --> 00:53:27,210
Y eso es como un fácil
forma de acceder a los datos.

974
00:53:27,210 --> 00:53:29,050
>> AUDIENCIA: Acceso a Pokemon.

975
00:53:29,050 --> 00:53:29,890
>> LUCAS: Si.

976
00:53:29,890 --> 00:53:32,395
>> AUDIENCIA: [inaudible].

977
00:53:32,395 --> 00:53:33,460
>> LUCAS: Yep.

978
00:53:33,460 --> 00:53:35,140
Aceptar, por lo que la selección de clasificación.

979
00:53:35,140 --> 00:53:41,610
Selección tipo va a seleccionar el
menor valor sin ordenar de una lista cada

980
00:53:41,610 --> 00:53:43,300
tiempo en cada iteración.

981
00:53:43,300 --> 00:53:46,800
Es un poco como el tipo que lo hace
en su cabeza cuando usted está tratando de

982
00:53:46,800 --> 00:53:48,430
ordenar una lista en la mano.

983
00:53:48,430 --> 00:53:51,990
>> Básicamente, todo lo que hacemos es mirar
para el número más pequeño.

984
00:53:51,990 --> 00:53:54,280
Te lo pones en la lista ordenada.

985
00:53:54,280 --> 00:53:56,230
Y luego busca la
siguiente número más pequeño.

986
00:53:56,230 --> 00:54:00,080
Y luego sigues haciendo
que y así sucesivamente.

987
00:54:00,080 --> 00:54:04,600
>> Así que la selección especie es, básicamente, que
seleccionar cada vez que el más pequeño

988
00:54:04,600 --> 00:54:05,750
valor sin clasificar.

989
00:54:05,750 --> 00:54:10,840
Ponga al final de la ordenada
parte de la lista.

990
00:54:10,840 --> 00:54:12,370
Y seguir haciendo eso.

991
00:54:12,370 --> 00:54:15,890
Así que vamos a ver rápidamente lo que
esto se parece.

992
00:54:15,890 --> 00:54:19,340
Así que aquí está la ordenada
y la lista sin ordenar.

993
00:54:19,340 --> 00:54:23,350
>> Así que para la ordenada de la lista,
es inicialmente vacía.

994
00:54:23,350 --> 00:54:26,760
Y luego voy a seleccionar el
menor número aquí, que es 2.

995
00:54:26,760 --> 00:54:30,650
Así que tengo el número 2 y pongo
en la parte delantera de la lista.

996
00:54:30,650 --> 00:54:34,910
Y entonces miro a la inmediata inferior
elemento, que es 3.

997
00:54:34,910 --> 00:54:37,050
Así que lo puse al final
de la lista ordenada.

998
00:54:37,050 --> 00:54:38,140
Y luego sigo haciendo eso.

999
00:54:38,140 --> 00:54:40,040
Encuentro 4 y lo puse al final.

1000
00:54:40,040 --> 00:54:41,360
Encontrar 5 y lo puso al final.

1001
00:54:41,360 --> 00:54:44,830
>> Y mira cómo todos esos momentos que
Estoy diciendo lo puso al final es,

1002
00:54:44,830 --> 00:54:46,850
básicamente, el canje de dos valores.

1003
00:54:46,850 --> 00:54:48,100
¿De acuerdo?

1004
00:54:48,100 --> 00:54:50,140

1005
00:54:50,140 --> 00:54:52,825
Y luego la última, que acaba de
tener un elemento más.

1006
00:54:52,825 --> 00:54:55,870
Así que ya está solucionado.

1007
00:54:55,870 --> 00:54:57,800
>> Aceptar, por lo que la ordenación por inserción.

1008
00:54:57,800 --> 00:55:03,180
La ordenación por inserción que vamos a tener también
esa cosa de tener un ordenado y

1009
00:55:03,180 --> 00:55:04,690
una lista sin ordenar.

1010
00:55:04,690 --> 00:55:14,540
Lo único es que cada vez que
va a añadir un elemento a la ordenada

1011
00:55:14,540 --> 00:55:18,170
lista, que acaba de recoger el elemento que
está en frente de la lista sin ordenar.

1012
00:55:18,170 --> 00:55:20,880
Y luego vas a encontrar lo
posición en la que debe estar en la ordenada

1013
00:55:20,880 --> 00:55:22,300
parte de la lista.

1014
00:55:22,300 --> 00:55:25,840
>> Vamos a ver qué esto es así
esto tiene más sentido.

1015
00:55:25,840 --> 00:55:29,360
Así que al principio, por ejemplo, estoy tratando de
para insertar el número tres de la

1016
00:55:29,360 --> 00:55:30,680
parte ordenada de la lista.

1017
00:55:30,680 --> 00:55:31,800
Así que la lista no tiene nada.

1018
00:55:31,800 --> 00:55:34,160
Así que sólo puedo poner el número 3.

1019
00:55:34,160 --> 00:55:37,480
>> Ahora, quiero añadir el número 5 a
la parte ordenada de la lista.

1020
00:55:37,480 --> 00:55:38,900
Así que miro el número 5.

1021
00:55:38,900 --> 00:55:40,450
Me doy cuenta de que es mayor que 3.

1022
00:55:40,450 --> 00:55:41,980
Así que sé que tiene que ser después de las 3.

1023
00:55:41,980 --> 00:55:44,100
Así que puse 3 y 5.

1024
00:55:44,100 --> 00:55:45,940
>> Entonces quiero insertar el número 2.

1025
00:55:45,940 --> 00:55:51,630
Me doy cuenta de que el número 2 es en realidad
durar entonces ambos 3 y 5.

1026
00:55:51,630 --> 00:55:54,580
Así que en realidad tengo que poner todo el
camino en el principio de la lista.

1027
00:55:54,580 --> 00:55:59,030
Así que tengo que hacerlo, clase de, trasladar toda la
elementos en la lista ordenada de modo que pueda

1028
00:55:59,030 --> 00:56:01,970
hacer espacio para el número 2.

1029
00:56:01,970 --> 00:56:03,160
>> Entonces veo el número 6.

1030
00:56:03,160 --> 00:56:05,450
Veo que debería ser después de las 5.

1031
00:56:05,450 --> 00:56:06,240
Así que lo puse ahí.

1032
00:56:06,240 --> 00:56:07,965
Y, por último, me veo en el número 4.

1033
00:56:07,965 --> 00:56:11,030
Y me doy cuenta de que debería
estar entre 3 y 5.

1034
00:56:11,030 --> 00:56:14,870
Y entonces me puse ahí y cambio
todos los demás elementos.

1035
00:56:14,870 --> 00:56:16,120
Tiene sentido?

1036
00:56:16,120 --> 00:56:17,880

1037
00:56:17,880 --> 00:56:19,150
>> La clase de burbuja.

1038
00:56:19,150 --> 00:56:25,730
Así ordenamiento de burbuja es básicamente lo que está
va a hacer-- lo llamamos burbuja

1039
00:56:25,730 --> 00:56:30,113
especie, porque usted va a través de la lista--
en realidad es mejor que me muestro

1040
00:56:30,113 --> 00:56:32,300
te gusta esto--

1041
00:56:32,300 --> 00:56:35,030
y vas a comparar
números adyacentes.

1042
00:56:35,030 --> 00:56:38,410
Y usted va a cambiar su
posiciones si no están

1043
00:56:38,410 --> 00:56:39,190
en el orden correcto.

1044
00:56:39,190 --> 00:56:42,570
>> Así que, básicamente, lo que va a
pasar es que aquí, por ejemplo,

1045
00:56:42,570 --> 00:56:44,160
Tiene 8 y 6.

1046
00:56:44,160 --> 00:56:47,270
Usted sabe que el orden de clasificación será
en realidad ser de 6 y 5, ¿verdad?

1047
00:56:47,270 --> 00:56:49,540
Así que vas a cambiar las órdenes.

1048
00:56:49,540 --> 00:56:51,370
Entonces veo 8 y 4 aquí.

1049
00:56:51,370 --> 00:56:52,250
Y yo hago lo mismo.

1050
00:56:52,250 --> 00:56:53,400
Me cambiaré de nuevo.

1051
00:56:53,400 --> 00:56:55,070
Y, finalmente, 2 y 8.

1052
00:56:55,070 --> 00:56:56,670
También les swap.

1053
00:56:56,670 --> 00:57:01,690
>> Se llama la clase de burbuja porque después
cada una de estas iteraciones, en realidad,

1054
00:57:01,690 --> 00:57:05,910
el mayor número en la lista recibe toda
el camino hasta el final de la lista.

1055
00:57:05,910 --> 00:57:06,940
¿Tiene eso sentido?

1056
00:57:06,940 --> 00:57:11,880
Porque mantiene intercambiarlo
y moviéndolo hacia la derecha.

1057
00:57:11,880 --> 00:57:14,440
>> OK, así que esta es la segunda iteración.

1058
00:57:14,440 --> 00:57:17,200
Sería lo mismo.

1059
00:57:17,200 --> 00:57:20,190
Voy a hacer un intercambio y
a continuación, el último.

1060
00:57:20,190 --> 00:57:23,290
I que no hay swaps
y la lista está ordenada.

1061
00:57:23,290 --> 00:57:27,460
Así que en la clase de burbuja, que básicamente mantenemos
ir a través de la lista y el intercambio

1062
00:57:27,460 --> 00:57:32,310
cosas hasta que me doy cuenta de que yo no hice
cualquier swaps haciendo esa iteración, que

1063
00:57:32,310 --> 00:57:34,270
significa que la lista ya está ordenado.

1064
00:57:34,270 --> 00:57:35,520
Tiene sentido?

1065
00:57:35,520 --> 00:57:38,400

1066
00:57:38,400 --> 00:57:40,870
>> Vamos a hablar un poco
sobre el tiempo de funcionamiento.

1067
00:57:40,870 --> 00:57:45,165
Así que es lo que ustedes recuerden Grande
O, Omega, y Theta?

1068
00:57:45,165 --> 00:57:49,290

1069
00:57:49,290 --> 00:57:50,990
¿Sí?

1070
00:57:50,990 --> 00:57:53,070
Bien, ¿qué es Big O, en primer lugar?

1071
00:57:53,070 --> 00:57:54,315
>> AUDIENCIA: [inaudible].

1072
00:57:54,315 --> 00:57:59,070
>> LUCAS: Sí, se llama el peor caso
tiempo de ejecución, lo que sólo significa que es

1073
00:57:59,070 --> 00:58:03,470
cuánto espera el programa
tomar para funcionar.

1074
00:58:03,470 --> 00:58:04,910
Al igual que, en términos de--

1075
00:58:04,910 --> 00:58:06,660
en este caso-- n.

1076
00:58:06,660 --> 00:58:09,150
El número de elementos en la
lista en el peor de los casos.

1077
00:58:09,150 --> 00:58:12,520
Al igual que, en el peor de los casos posibles.

1078
00:58:12,520 --> 00:58:17,100
>> Así que para la clase de burbuja, por ejemplo,
tenemos Big O de n cuadrado.

1079
00:58:17,100 --> 00:58:20,580
¿Por qué tenemos que?

1080
00:58:20,580 --> 00:58:24,716
¿Por qué es la clase de burbuja Big O n cuadrada?

1081
00:58:24,716 --> 00:58:27,614
>> AUDIENCIA: [inaudible].

1082
00:58:27,614 --> 00:58:35,670
>> LUCAS: Sí, por lo que el peor de los casos será
que voy a tener que hacer n iteraciones.

1083
00:58:35,670 --> 00:58:39,260
Así que cada una de las iteraciones se va a
llevar el elemento más grande hasta el final

1084
00:58:39,260 --> 00:58:40,290
de la lista.

1085
00:58:40,290 --> 00:58:44,230
Así que el peor de los casos es que tengo
para hacer esa cosa n veces.

1086
00:58:44,230 --> 00:58:48,550
Y para cada uno de esos momentos, tengo que
hacer n swaps porque tengo que comparar

1087
00:58:48,550 --> 00:58:49,870
cada uno dos elementos.

1088
00:58:49,870 --> 00:58:53,730
Así que por eso está n al cuadrado
porque es n veces n.

1089
00:58:53,730 --> 00:59:00,120
>> Entonces, la selección de género es también n cuadrada
porque, para cada iteración, tengo que

1090
00:59:00,120 --> 00:59:02,650
mirar cada elemento individual
en la lista.

1091
00:59:02,650 --> 00:59:04,980
Y luego encontrar el más pequeño,
lo que significa que tengo que

1092
00:59:04,980 --> 00:59:06,130
mirar a través de n elementos.

1093
00:59:06,130 --> 00:59:11,750
Y tengo que hacer que n veces porque
Tengo que seleccionar todos los elementos n.

1094
00:59:11,750 --> 00:59:18,273
>> Una ordenación por inserción es también n cuadrada
debido a que el peor de los casos lo hará

1095
00:59:18,273 --> 00:59:20,950
ser, uno, tengo que insertar
n números, ¿verdad?

1096
00:59:20,950 --> 00:59:22,765
Así que ya sé que voy
tener n iteraciones.

1097
00:59:22,765 --> 00:59:25,466

1098
00:59:25,466 --> 00:59:29,840
Pero para cada uno de esos números, si tuviera
para mirar a todos los números en

1099
00:59:29,840 --> 00:59:34,380
la lista ordenada y lo puso todo el camino
en la parte delantera, que será n cuadrada

1100
00:59:34,380 --> 00:59:36,230
porque será n veces n de nuevo.

1101
00:59:36,230 --> 00:59:38,280
Tiene sentido?

1102
00:59:38,280 --> 00:59:41,512
¿Qué pasa con omega?

1103
00:59:41,512 --> 00:59:42,886
>> AUDIENCIA: [inaudible].

1104
00:59:42,886 --> 00:59:44,620
>> LUCAS: Es el mejor de los casos.

1105
00:59:44,620 --> 00:59:48,810
Así es como, en un montón de veces para
clasificación, el mejor de los casos es

1106
00:59:48,810 --> 00:59:50,660
cuando la lista ya está ordenado.

1107
00:59:50,660 --> 00:59:52,670
Así que usted realmente no tiene
que hacer nada.

1108
00:59:52,670 --> 00:59:56,290
La clase de burbuja tiene la mejor
de los casos de n.

1109
00:59:56,290 --> 00:59:58,820
¿Conoce chicos por qué?

1110
00:59:58,820 --> 01:00:00,620
>> AUDIENCIA: [inaudible].

1111
01:00:00,620 --> 01:00:05,640
>> LUCAS: Sí, si usted no pierde de
si la ración de datos tenía ningún swaps o

1112
01:00:05,640 --> 01:00:10,533
No, si usted tiene algo así como se establece en
verdadero si había una iteración, si el

1113
01:00:10,533 --> 01:00:15,140
lista ya está ordenado, básicamente,
lo que va a pasar es que voy a

1114
01:00:15,140 --> 01:00:17,890
intentar cambiar cada dos
elementos adyacentes.

1115
01:00:17,890 --> 01:00:19,920
Voy a ver que
no hay swaps.

1116
01:00:19,920 --> 01:00:21,230
Y yo acabo de volver de inmediato.

1117
01:00:21,230 --> 01:00:24,240
>> Así que eso significa que yo sólo tenía que
ir a través de la lista una vez.

1118
01:00:24,240 --> 01:00:28,990
Así que es n porque me veo
en n elementos.

1119
01:00:28,990 --> 01:00:30,930
¿Por qué la selección tipo n cuadrar?

1120
01:00:30,930 --> 01:00:35,150

1121
01:00:35,150 --> 01:00:45,520
>> Sí, incluso si la lista está ordenada, para
cada iteración del ordenamiento por selección, me

1122
01:00:45,520 --> 01:00:47,590
que seleccionar el elemento mínimo.

1123
01:00:47,590 --> 01:00:49,980
Así que eso significa que tengo que salir a buscar
en todos los elementos en el sin clasificar

1124
01:00:49,980 --> 01:00:53,350
listar y encontrar el mínimo
para cada iteración.

1125
01:00:53,350 --> 01:00:54,600
¿Tiene eso sentido?

1126
01:00:54,600 --> 01:00:56,880

1127
01:00:56,880 --> 01:01:04,690
>> Y la espada de inserción está n porque en el
caso que estoy tratando de insertar el

1128
01:01:04,690 --> 01:01:09,320
números y todos los números, cuando me
tratar de insertarlos, veo que

1129
01:01:09,320 --> 01:01:10,510
están en la posición correcta.

1130
01:01:10,510 --> 01:01:15,120
Yo no tengo que ir a ver todos los demás
números de la lista sin ordenar.

1131
01:01:15,120 --> 01:01:17,170
Así que por eso será n.

1132
01:01:17,170 --> 01:01:19,480
Tiene sentido?

1133
01:01:19,480 --> 01:01:21,035
Y lo que es theta?

1134
01:01:21,035 --> 01:01:23,410
>> AUDIENCIA: [inaudible].

1135
01:01:23,410 --> 01:01:24,380
>> LUCAS: ¿Qué, lo siento?

1136
01:01:24,380 --> 01:01:24,960
Dilo de nuevo.

1137
01:01:24,960 --> 01:01:25,666
>> AUDIENCIA: [inaudible].

1138
01:01:25,666 --> 01:01:26,490
>> LUCAS: Exactamente.

1139
01:01:26,490 --> 01:01:31,280
Así se puede ver que sólo la selección
almacenada en Merge sort tener theta.

1140
01:01:31,280 --> 01:01:39,920
Y eso es porque sólo tienes theta
si ambos Big O y Omega son la misma.

1141
01:01:39,920 --> 01:01:41,520
Okay.

1142
01:01:41,520 --> 01:01:44,210
Y, por último, fusionar es un género en el registro n.

1143
01:01:44,210 --> 01:01:48,910
>> Y entonces, como Dan estaba diciendo, Merge sort
es una especie de la misma manera que

1144
01:01:48,910 --> 01:01:50,320
usted hace una búsqueda binaria.

1145
01:01:50,320 --> 01:01:53,530
Así se obtiene la lista.

1146
01:01:53,530 --> 01:01:55,170
Y usted va a cortar por la mitad.

1147
01:01:55,170 --> 01:02:00,580
Y después de haberlos cortado
en mitades más pequeñas.

1148
01:02:00,580 --> 01:02:01,730
Y luego combinarlos.

1149
01:02:01,730 --> 01:02:02,960
Ustedes recuerdas, ¿verdad?

1150
01:02:02,960 --> 01:02:04,960
Aceptar, como él decía.

1151
01:02:04,960 --> 01:02:08,330
>> Aceptar, punteros.

1152
01:02:08,330 --> 01:02:11,078
Entonces, ¿qué es un puntero?

1153
01:02:11,078 --> 01:02:12,050
>> AUDIENCIA: [inaudible].

1154
01:02:12,050 --> 01:02:12,820
>> LUCAS: Una dirección.

1155
01:02:12,820 --> 01:02:13,720
Okay.

1156
01:02:13,720 --> 01:02:18,530
Sé que David muestra un montón de
videos de Binky y cosas que apuntan

1157
01:02:18,530 --> 01:02:19,080
El uno al otro.

1158
01:02:19,080 --> 01:02:22,960
Pero me gusta pensar de punteros
simplemente como una dirección.

1159
01:02:22,960 --> 01:02:26,110
Así que es una variable que se va
para almacenar una dirección.

1160
01:02:26,110 --> 01:02:31,940
>> Así que es sólo esta variable especial
es decir, cuatro bytes de longitud.

1161
01:02:31,940 --> 01:02:36,550
Recuerde, que para nada es puntero
siempre de cuatro bytes de longitud para nuestro 32-bit

1162
01:02:36,550 --> 01:02:39,370
máquina para que el caso con
el aparato.

1163
01:02:39,370 --> 01:02:41,920

1164
01:02:41,920 --> 01:02:47,050
Y que sólo tiene la ubicación
de una variable dentro de la misma.

1165
01:02:47,050 --> 01:02:50,240
>> OK, así que hay esta memoria, básicamente.

1166
01:02:50,240 --> 01:02:57,420
Así que cada bloque de memoria tiene en realidad un
etiqueta, que es la dirección de la

1167
01:02:57,420 --> 01:02:58,890
memoria Slotty.

1168
01:02:58,890 --> 01:03:02,370
Así que eso significa que puedo tener
un puntero que apunta a

1169
01:03:02,370 --> 01:03:03,380
cualquiera de estas direcciones.

1170
01:03:03,380 --> 01:03:09,930
Así que la razón por la que vamos a utilizar punteros es
si tengo que recordar la ubicación

1171
01:03:09,930 --> 01:03:12,300
que una variable específica es un recuerdo.

1172
01:03:12,300 --> 01:03:16,560
>> Y ustedes recuerda que uno de los
casos era si tengo una función

1173
01:03:16,560 --> 01:03:20,820
que si tengo realmente quiere
intercambio de reales, en realidad

1174
01:03:20,820 --> 01:03:22,110
que enviar un puntero.

1175
01:03:22,110 --> 01:03:23,460
No es la variable.

1176
01:03:23,460 --> 01:03:25,200
¿Ustedes se acuerdan?

1177
01:03:25,200 --> 01:03:26,450
El between-- diferencia

1178
01:03:26,450 --> 01:03:33,350

1179
01:03:33,350 --> 01:03:34,120
¿cómo se llama?

1180
01:03:34,120 --> 01:03:36,010
Llamando por valor y llamar
por referencia, ¿no?

1181
01:03:36,010 --> 01:03:36,840
>> Bueno, sí.

1182
01:03:36,840 --> 01:03:38,330
Así que llame por valor.

1183
01:03:38,330 --> 01:03:43,570
Cuando usted acaba de enviar una variable a
función que está mandando un valor.

1184
01:03:43,570 --> 01:03:45,610
Así que en realidad estás enviando
una copia de la variable.

1185
01:03:45,610 --> 01:03:49,720
Y su programa no podría importarle menos
acerca de si la misma variable en realidad

1186
01:03:49,720 --> 01:03:51,650
hace una copia.

1187
01:03:51,650 --> 01:03:56,330
>> Y llamando por referencia significa que
En realidad estoy enviando una copia de la

1188
01:03:56,330 --> 01:03:57,550
puntero a esa variable.

1189
01:03:57,550 --> 01:04:00,970
Así que eso significa que estoy enviando la
ubicación de esa variable.

1190
01:04:00,970 --> 01:04:04,440
Así que sentir que tengo la ubicación de la
variables, cuando llamo a la función

1191
01:04:04,440 --> 01:04:09,700
con punteros, soy capaz de realidad
cambiar los datos que estaban en la principal.

1192
01:04:09,700 --> 01:04:12,050
Tiene sentido?

1193
01:04:12,050 --> 01:04:17,560
>> Aunque, el puntero es una copia, el
puntero todavía tiene la dirección real de

1194
01:04:17,560 --> 01:04:20,090
la variable que quiero cambiar.

1195
01:04:20,090 --> 01:04:21,920
Tiene sentido?

1196
01:04:21,920 --> 01:04:24,290
>> Así que la creación de punteros.

1197
01:04:24,290 --> 01:04:28,410
Recuerde, el puntero siempre tienen
el tipo que se está apuntando

1198
01:04:28,410 --> 01:04:29,890
y luego a una estrella.

1199
01:04:29,890 --> 01:04:31,030
Y a continuación, poner el nombre.

1200
01:04:31,030 --> 01:04:35,765
Así que recuerde que cada vez que tenga
cualquiera que sea la estrella, que es un puntero a

1201
01:04:35,765 --> 01:04:38,990
que cualquiera que sea la variable
escriba que usted tenía.

1202
01:04:38,990 --> 01:04:42,850
>> Así que aquí en estrella, por ejemplo, es
un puntero y un entero.

1203
01:04:42,850 --> 01:04:47,680
Y entonces estrella char es un puntero
Char estrella y así sucesivamente.

1204
01:04:47,680 --> 01:04:47,960
¿Sí?

1205
01:04:47,960 --> 01:04:52,710
>> AUDIENCIA: ¿Qué pasa si tenemos un
puntero a n x a la estrella.

1206
01:04:52,710 --> 01:04:55,255
Sé que crea un puntero a x.

1207
01:04:55,255 --> 01:04:59,432
¿También declaramos x un número entero?

1208
01:04:59,432 --> 01:05:05,170
>> LUCAS: OK, así que cuando usted dice n estrella x,
usted no va a crear un puntero a una

1209
01:05:05,170 --> 01:05:06,000
x variable.

1210
01:05:06,000 --> 01:05:08,170
Estás creando un puntero llamado x.

1211
01:05:08,170 --> 01:05:09,396
>> AUDIENCIA: [inaudible].

1212
01:05:09,396 --> 01:05:14,250
>> LUCAS: Así que cuando digo n estrella x, estoy
diciendo, hey, en la memoria, voy a

1213
01:05:14,250 --> 01:05:16,390
conseguir una de estas tres cajas.

1214
01:05:16,390 --> 01:05:20,750
Y yo voy a decir que eso
va a ser x, que es

1215
01:05:20,750 --> 01:05:22,000
va a ser un puntero.

1216
01:05:22,000 --> 01:05:26,860

1217
01:05:26,860 --> 01:05:30,640
Y algo interesante de punteros
es que nos dicen que tienen

1218
01:05:30,640 --> 01:05:32,620
4 bytes para una máquina de 32 bits.

1219
01:05:32,620 --> 01:05:36,320
Y la razón de esto es porque
4 bytes son 32 bits.

1220
01:05:36,320 --> 01:05:40,490
>> Y máquinas que son 64 bits en realidad
tener direcciones punteros

1221
01:05:40,490 --> 01:05:43,480
que son 64 bits de longitud.

1222
01:05:43,480 --> 01:05:49,820
Por lo que sólo significa que el tamaño de la
direcciones de la máquina es diferente.

1223
01:05:49,820 --> 01:05:52,270
>> Así que hacer referencia y Desreferenciar.

1224
01:05:52,270 --> 01:05:54,310
Hay dos operadores que
ustedes deben recordar.

1225
01:05:54,310 --> 01:05:55,450
La primera es ampersand.

1226
01:05:55,450 --> 01:05:56,810
La segunda es la estrella.

1227
01:05:56,810 --> 01:06:05,060
No se confunda por esa estrella y esto
estrella, porque recordar que, en

1228
01:06:05,060 --> 01:06:06,950
este caso, usted tiene n la estrella.

1229
01:06:06,950 --> 01:06:08,700
>> Es como una cosa entera juntos.

1230
01:06:08,700 --> 01:06:10,720
No hay espacio estrella n.

1231
01:06:10,720 --> 01:06:12,070
Así que esto significa que es el tipo.

1232
01:06:12,070 --> 01:06:14,870
Recuerde que cuando usted tiene
la estrella variable, eres

1233
01:06:14,870 --> 01:06:16,230
hablando sobre el tipo.

1234
01:06:16,230 --> 01:06:20,540
>> Cuando usted acaba de estrellas y luego el
nombre de la variable, significa que

1235
01:06:20,540 --> 01:06:24,100
estás eliminación de referencias al puntero, que
significa que usted está buscando en el

1236
01:06:24,100 --> 01:06:28,290
puntero, la búsqueda de la dirección es
señalando, ir a esa dirección,

1237
01:06:28,290 --> 01:06:30,850
y mirando siempre
que tienes ahí.

1238
01:06:30,850 --> 01:06:34,310
Así que les digo a mis estudiantes que cuando se tiene
estrella, usted debe pensar que es

1239
01:06:34,310 --> 01:06:36,850
la abreviatura de los contenidos de.

1240
01:06:36,850 --> 01:06:39,770
>> Así que si usted tiene un puntero y
hacer indicador de la estrella, que es la

1241
01:06:39,770 --> 01:06:41,720
contenido del puntero.

1242
01:06:41,720 --> 01:06:44,580
Así que ir a lo que está señalando
y mirar el contenido constante.

1243
01:06:44,580 --> 01:06:47,730
Y el signo es el mismo
Lo que la dirección de.

1244
01:06:47,730 --> 01:06:52,560
>> Así que si tengo una variable un-- como, vamos a
decir que me hice un int es igual 3--

1245
01:06:52,560 --> 01:06:56,900
si quiero encontrar la dirección de ese
una memoria de variables, sólo puedo hacer

1246
01:06:56,900 --> 01:06:58,240
ampersand a.

1247
01:06:58,240 --> 01:07:00,280
Así que es la dirección de un.

1248
01:07:00,280 --> 01:07:01,530
Tiene sentido?

1249
01:07:01,530 --> 01:07:03,790

1250
01:07:03,790 --> 01:07:05,040
>> Así que aquí está un ejemplo.

1251
01:07:05,040 --> 01:07:08,370

1252
01:07:08,370 --> 01:07:11,530
Esta falta int b y c int.

1253
01:07:11,530 --> 01:07:16,520
Así int a es igual a 3 significa que
Voy a ir a la memoria.

1254
01:07:16,520 --> 01:07:19,870
Y voy a encontrar una ranura
y poner el número 3 aquí.

1255
01:07:19,870 --> 01:07:22,200
>> Y entonces int b es igual a 4.

1256
01:07:22,200 --> 01:07:23,100
Voy a hacer lo mismo.

1257
01:07:23,100 --> 01:07:25,840
Ir a la memoria y poner un número
4 en una de las cajas.

1258
01:07:25,840 --> 01:07:27,100
Y int igual a 5.

1259
01:07:27,100 --> 01:07:29,740
Encuentra otra caja y poner un número 5.

1260
01:07:29,740 --> 01:07:36,160
>> Entonces, ¿qué es esta línea haciendo afuera?
pa n estrella es igual a un signo.

1261
01:07:36,160 --> 01:07:37,800
Así que primero de todo, n pa estrella.

1262
01:07:37,800 --> 01:07:39,050
¿Qué está haciendo?

1263
01:07:39,050 --> 01:07:40,930

1264
01:07:40,930 --> 01:07:42,298
>> AUDIENCIA: [inaudible].

1265
01:07:42,298 --> 01:07:47,890
>> LUCAS: Sí, así que n pa estrella, primero,
declara un puntero llamado pa.

1266
01:07:47,890 --> 01:07:53,720
Y luego está la asignación del valor de
que sea puntero a la dirección de una.

1267
01:07:53,720 --> 01:07:55,790
Así ampersand a.

1268
01:07:55,790 --> 01:07:58,510
Entonces, si lo hago pb estrella,
lo que es un pb estrella?

1269
01:07:58,510 --> 01:08:02,418

1270
01:08:02,418 --> 01:08:03,150
>> Oh, lo siento.

1271
01:08:03,150 --> 01:08:06,330
Esto también ha desaparecido. pb estrella n.

1272
01:08:06,330 --> 01:08:07,905
Quiero decir pc estrellas.

1273
01:08:07,905 --> 01:08:11,200
Lo siento mucho.

1274
01:08:11,200 --> 01:08:11,940
Es la misma cosa.

1275
01:08:11,940 --> 01:08:16,408
Pero ahora estoy bien ar la creación de un puntero
ab y luego un puntero a c.

1276
01:08:16,408 --> 01:08:16,886
¿Sí?

1277
01:08:16,886 --> 01:08:18,136
>> AUDIENCIA: [inaudible]?

1278
01:08:18,136 --> 01:08:25,490

1279
01:08:25,490 --> 01:08:26,670
>> LUCAS: Sí.

1280
01:08:26,670 --> 01:08:32,630
Así que si vas a la memoria y que vaya a
la caja que es el designador de pa,

1281
01:08:32,630 --> 01:08:37,149
realmente vas a
ver la dirección de un.

1282
01:08:37,149 --> 01:08:38,399
¿De acuerdo?

1283
01:08:38,399 --> 01:08:42,970

1284
01:08:42,970 --> 01:08:43,300
¿Sí?

1285
01:08:43,300 --> 01:08:45,605
>> AUDIENCIA: [inaudible]?

1286
01:08:45,605 --> 01:08:49,260
>> LUCAS: Sí, el puntero es una dirección.

1287
01:08:49,260 --> 01:08:50,120
Nunca lo olvides.

1288
01:08:50,120 --> 01:08:52,800
Es como el más importante
parte de los punteros.

1289
01:08:52,800 --> 01:08:56,180
Hay almacenar y dirección
a alguna variable.

1290
01:08:56,180 --> 01:08:56,890
Algo más?

1291
01:08:56,890 --> 01:08:58,370
Alguna otra pregunta?

1292
01:08:58,370 --> 01:08:59,189
Okay.

1293
01:08:59,189 --> 01:09:00,399
>> Así Punteros y matrices.

1294
01:09:00,399 --> 01:09:08,189
Recuerde que cuando hago int matriz de 3,
Básicamente, lo que estoy haciendo es que soy, bueno

1295
01:09:08,189 --> 01:09:12,779
de, declarando en un puntero.

1296
01:09:12,779 --> 01:09:18,960
Así matriz es algo así como un puntero a una
lugar específico en la memoria en la que

1297
01:09:18,960 --> 01:09:21,999
asignado tres ranuras para enteros.

1298
01:09:21,999 --> 01:09:23,430
¿Tiene eso sentido?

1299
01:09:23,430 --> 01:09:30,250
>> Así que cuando lo hago int matriz de 3, lo que estoy
haciendo, básicamente, es la creación de tres

1300
01:09:30,250 --> 01:09:31,479
ranuras en la memoria.

1301
01:09:31,479 --> 01:09:33,899
Así que me encuentro tres ranuras de memoria.

1302
01:09:33,899 --> 01:09:38,810
Así que si lo hago, entonces, una matriz de estrellas,
básicamente significa que el contenido de la matriz,

1303
01:09:38,810 --> 01:09:46,180
lo que significa que borro el puntero, voy
a ese lugar que está señalando,

1304
01:09:46,180 --> 01:09:47,939
y puse el número uno.

1305
01:09:47,939 --> 01:09:53,729
>> Y luego, si lo hago array estrella más 1,
eso es lo mismo que hacer array

1306
01:09:53,729 --> 01:09:59,690
soportes de uno, que sólo significa que me voy a
el lugar que está apuntando a.

1307
01:09:59,690 --> 01:10:03,000
Y entonces el plus 1 marcas
me muevo una posición.

1308
01:10:03,000 --> 01:10:06,510
Así que voy a esta posición, en realidad,
y poner el número dos.

1309
01:10:06,510 --> 01:10:10,900
>> Y entonces, por fin, cuando lo hago
gama más 2, voy a donde

1310
01:10:10,900 --> 01:10:11,825
señalador de matriz en.

1311
01:10:11,825 --> 01:10:14,690
Y entonces me mudo a bloques de memoria.

1312
01:10:14,690 --> 01:10:16,240
Y entonces me puse el número tres aquí.

1313
01:10:16,240 --> 01:10:16,600
¿Sí?

1314
01:10:16,600 --> 01:10:21,400
>> AUDIENCIA: array Así estrella es simplemente
diciendo que el primer punto.

1315
01:10:21,400 --> 01:10:25,090
Y usted puede agregar 1, sólo porque
sólo estamos realmente

1316
01:10:25,090 --> 01:10:27,295
referencia a esa primera dirección.

1317
01:10:27,295 --> 01:10:28,545
>> LUCAS: Si.

1318
01:10:28,545 --> 01:10:32,720

1319
01:10:32,720 --> 01:10:36,020
¿Por qué, por ejemplo, decimos array
0, 1 campo, y la matriz 2?

1320
01:10:36,020 --> 01:10:38,970

1321
01:10:38,970 --> 01:10:42,790
Que digo, ¿por qué haces 0,
1, 2, 3 en lugar de 1, 2, 3?

1322
01:10:42,790 --> 01:10:46,550
Una de las razones es, uno, equipo
programadores prefieren empezar

1323
01:10:46,550 --> 01:10:47,750
contando desde 0.

1324
01:10:47,750 --> 01:10:52,370
Dos es porque cuando haces matriz 0,
es lo mismo que hacer array

1325
01:10:52,370 --> 01:10:56,330
además de 0, lo que significa que voy a
esa posición, y no lo hago

1326
01:10:56,330 --> 01:10:59,320
omitir cualquier bloque de memoria.

1327
01:10:59,320 --> 01:11:01,750
Así que no me muevo de cualquier bloque de memoria.

1328
01:11:01,750 --> 01:11:02,015
¿Sí?

1329
01:11:02,015 --> 01:11:03,265
>> AUDIENCIA: [inaudible]?

1330
01:11:03,265 --> 01:11:05,928

1331
01:11:05,928 --> 01:11:12,670
>> LUCAS: Así que ella está pidiendo lo que es
la diferencia entre hacer

1332
01:11:12,670 --> 01:11:14,000
esto o hacer malloc.

1333
01:11:14,000 --> 01:11:17,550
Una de las diferencias es que
int serie 3 es la creación de un

1334
01:11:17,550 --> 01:11:19,260
matriz en la pila.

1335
01:11:19,260 --> 01:11:23,080
Y cuando lo haga malloc, que
crea en el montón.

1336
01:11:23,080 --> 01:11:25,250
¿Tiene eso sentido?

1337
01:11:25,250 --> 01:11:28,870
>> Entonces, ¿cómo funciona malloc realidad?

1338
01:11:28,870 --> 01:11:32,245
Entonces, ¿por qué necesitamos usar malloc?

1339
01:11:32,245 --> 01:11:35,730

1340
01:11:35,730 --> 01:11:39,700
Su compilador tipo de figuras todo
las variables que se declaran.

1341
01:11:39,700 --> 01:11:44,040
Y se crea un espacio para todos
de ellos en la pila.

1342
01:11:44,040 --> 01:11:47,180
Así que todas las variables se van
estar en algún lugar en la pila.

1343
01:11:47,180 --> 01:11:49,460
Así que aquí está las variables de entorno.

1344
01:11:49,460 --> 01:11:53,850
>> Así que, básicamente, el espacio para las variables
en la memoria se asigna a

1345
01:11:53,850 --> 01:11:55,080
tiempo de compilación.

1346
01:11:55,080 --> 01:11:58,790
Así que esto significa que el equipo tiene
conocer todas aquellas variables

1347
01:11:58,790 --> 01:11:59,790
de antemano.

1348
01:11:59,790 --> 01:12:02,500
No necesita saber qué valor
usted va a poner en ellos.

1349
01:12:02,500 --> 01:12:05,490
Pero es necesario saber cómo
cantidad de memoria que necesita.

1350
01:12:05,490 --> 01:12:09,380
>> Pero ahora vamos a decir que, por ejemplo,
está creando una matriz o tomar una

1351
01:12:09,380 --> 01:12:13,430
cadena que usted está tomando
del usuario.

1352
01:12:13,430 --> 01:12:17,300
Usted no sabe cuánto tiempo la cadena
va a ser, por ejemplo.

1353
01:12:17,300 --> 01:12:20,600
Así que usted no sabe exactamente cuántos
bloques de memoria se asignan, ¿verdad?

1354
01:12:20,600 --> 01:12:24,120
>> Así que no tiene mucho sentido para
que digas puso 100 caracteres.

1355
01:12:24,120 --> 01:12:26,420
Y entonces ¿qué pasa si el usuario escribe 150?

1356
01:12:26,420 --> 01:12:27,670
Usted va a ser jodido.

1357
01:12:27,670 --> 01:12:30,160

1358
01:12:30,160 --> 01:12:34,620
>> Así que, básicamente, no se puede estar seguro de cómo
cantidad de memoria que necesita asignar

1359
01:12:34,620 --> 01:12:35,960
al compilar el programa.

1360
01:12:35,960 --> 01:12:38,240
Usted acaba de saber que el tiempo de ejecución.

1361
01:12:38,240 --> 01:12:39,950
Así que es por eso que usted tiene el montón.

1362
01:12:39,950 --> 01:12:47,610
Así que el montón se va a tener memoria
que usted está asignando durante el

1363
01:12:47,610 --> 01:12:50,810
duración del programa en ejecución.

1364
01:12:50,810 --> 01:12:55,780
>> Así que, básicamente, cuando lo hace malloc, lo
que estás haciendo es la asignación de memoria en

1365
01:12:55,780 --> 01:13:00,160
tiempo de ejecución, lo que significa que usted es
decidir justo en ese momento que

1366
01:13:00,160 --> 01:13:02,670
deberían tener ese recuerdo.

1367
01:13:02,670 --> 01:13:04,210
Así que eso es cuando estás asignación.

1368
01:13:04,210 --> 01:13:06,430
¿Tiene eso sentido?

1369
01:13:06,430 --> 01:13:11,690
>> Así que recuerda, la pila tiene variables
que se crean en tiempo de compilación.

1370
01:13:11,690 --> 01:13:14,560
Y entonces el montón tiene variables
que se crean sobre la marcha

1371
01:13:14,560 --> 01:13:15,600
con malloc, por ejemplo.

1372
01:13:15,600 --> 01:13:16,850
>> AUDIENCIA: [inaudible]?

1373
01:13:16,850 --> 01:13:19,179

1374
01:13:19,179 --> 01:13:24,340
>> LUCAS: Así es GetString
Llamaré a malloc.

1375
01:13:24,340 --> 01:13:26,710
Permítanme hablar de malloc, y
Voy a explicar GetString.

1376
01:13:26,710 --> 01:13:32,000
Así malloc es la misma cosa
como la asignación de memoria.

1377
01:13:32,000 --> 01:13:34,600
Así que va a asignar
memoria en el montón.

1378
01:13:34,600 --> 01:13:40,010
Y se va a devolver un puntero a
donde la memoria se asignó al.

1379
01:13:40,010 --> 01:13:43,090
>> Así que cuando usted hacer--

1380
01:13:43,090 --> 01:13:44,910
aquí por ejemplo-

1381
01:13:44,910 --> 01:13:45,830
indicador de la estrella n.

1382
01:13:45,830 --> 01:13:50,520
Y entonces el puntero es igual a malloc
tamaño de 10 pulgadas veces.

1383
01:13:50,520 --> 01:13:52,110
Estoy creando un puntero.

1384
01:13:52,110 --> 01:13:59,020
Y entonces estoy asignando ese puntero a
el valor del puntero que malloc

1385
01:13:59,020 --> 01:13:59,680
me está dando.

1386
01:13:59,680 --> 01:14:04,150
>> Malloc Así que estoy pidiendo que usted puede asignar
espacio para 10 números enteros.

1387
01:14:04,150 --> 01:14:05,390
Eso es lo que está diciendo.

1388
01:14:05,390 --> 01:14:09,020
Y malloc me devuelve una
puntero a ese lugar.

1389
01:14:09,020 --> 01:14:11,460
Tiene sentido?

1390
01:14:11,460 --> 01:14:12,270
Okay.

1391
01:14:12,270 --> 01:14:17,940
Y yo GetString está, básicamente, haciendo un
llamar a malloc para que pueda asignar

1392
01:14:17,940 --> 01:14:21,680
memoria en tiempo de ejecución.

1393
01:14:21,680 --> 01:14:26,460
>> Recuerde siempre comprobar nula
porque malloc va a devolver null

1394
01:14:26,460 --> 01:14:28,200
si no se puede asignar memoria.

1395
01:14:28,200 --> 01:14:31,660
Digamos que usted pide un ridículo
cantidad de memoria.

1396
01:14:31,660 --> 01:14:33,950
Su equipo no va a ser
capaz de asignar tanto.

1397
01:14:33,950 --> 01:14:36,410
>> Así malloc es sólo va
a devolver null.

1398
01:14:36,410 --> 01:14:42,210
Así que siempre recuerde verificar si el
puntero que usted recibió de malloc es

1399
01:14:42,210 --> 01:14:45,640
nula o no, porque, si lo es, que te pueden
dereferencing ser un puntero y

1400
01:14:45,640 --> 01:14:48,340
causando fallos secundarios.

1401
01:14:48,340 --> 01:14:50,930
Y, por último, no se olvide
su memoria libre.

1402
01:14:50,930 --> 01:14:57,800

1403
01:14:57,800 --> 01:15:00,560
>> Malloc está creando la memoria en el montón.

1404
01:15:00,560 --> 01:15:03,436
Y usted tiene que liberar la memoria
antes de que el programa termina.

1405
01:15:03,436 --> 01:15:05,370
OK, eso es todo para mí.

1406
01:15:05,370 --> 01:15:07,900
Lo sentimos, Rob.

1407
01:15:07,900 --> 01:15:07,950
Gracias.

1408
01:15:07,950 --> 01:15:09,878
>> [Aplausos]

1409
01:15:09,878 --> 01:15:12,679
>> LUCAS: ¿Unas últimas preguntas
antes de que Rob viene?

1410
01:15:12,679 --> 01:15:13,138
No?

1411
01:15:13,138 --> 01:15:13,597
¿Sí?

1412
01:15:13,597 --> 01:15:15,892
>> AUDIENCIA: no vi
ésta línea.

1413
01:15:15,892 --> 01:15:17,269
¿Ha subido todavía?

1414
01:15:17,269 --> 01:15:19,106
>> LUCAS: Creo que Dave es
subir pronto.

1415
01:15:19,106 --> 01:15:19,880
>> DAVE: Va a ser publicado.

1416
01:15:19,880 --> 01:15:20,310
>> LUCAS: Va a ser en línea.

1417
01:15:20,310 --> 01:15:21,175
>> AUDIENCIA: Depende.

1418
01:15:21,175 --> 01:15:22,090
>> LUCAS: Depende?

1419
01:15:22,090 --> 01:15:23,157
Okay.

1420
01:15:23,157 --> 01:15:23,644
¿Sí?

1421
01:15:23,644 --> 01:15:27,053
>> AUDIENCIA: [inaudible]?

1422
01:15:27,053 --> 01:15:30,285
>> LUCAS: Sí, debe liberar todo el
memoria que se puso en el montón.

1423
01:15:30,285 --> 01:15:31,535
>> AUDIENCIA: [inaudible]?

1424
01:15:31,535 --> 01:15:34,518

1425
01:15:34,518 --> 01:15:36,160
>> LUCAS: Sí.

1426
01:15:36,160 --> 01:15:39,980
Cada vez que usted tiene un malloc cultura,
usted debe tener una cultura libre

1427
01:15:39,980 --> 01:15:42,640
después de dejar de usar esa variable.

1428
01:15:42,640 --> 01:15:44,800
Así malloc y libre son
siempre juntos.

1429
01:15:44,800 --> 01:15:45,410
Sus mejores amigos.

1430
01:15:45,410 --> 01:15:46,720
Sí.

1431
01:15:46,720 --> 01:15:47,970
Rob?

1432
01:15:47,970 --> 01:15:55,595

1433
01:15:55,595 --> 01:15:56,850
>> ROB: Voy a ir rápidamente.

1434
01:15:56,850 --> 01:16:00,466
Y también el video será puesto.

1435
01:16:00,466 --> 01:16:01,716
Tengo el micrófono en.

1436
01:16:01,716 --> 01:16:24,060

1437
01:16:24,060 --> 01:16:26,230
>> OK, así que la semana cinco cosas.

1438
01:16:26,230 --> 01:16:27,970
Lo primero que tenemos es la pila.

1439
01:16:27,970 --> 01:16:33,390
Así que recuerda que sólo hay una pila
cuadro por llamada a la función activa.

1440
01:16:33,390 --> 01:16:34,710
Veremos eso en un segundo.

1441
01:16:34,710 --> 01:16:37,850
Y también recordar lo que en realidad va
en cada marco de pila van a ser

1442
01:16:37,850 --> 01:16:41,880
las variables locales de nuestras funciones,
los argumentos que se pasan a nuestro

1443
01:16:41,880 --> 01:16:43,880
funciones, junto con un par
otras cosas que realmente no

1444
01:16:43,880 --> 01:16:45,260
tenga que preocuparse.

1445
01:16:45,260 --> 01:16:50,950
>> Así que aquí está un ejemplo de programa que,
aviso, principal se printfing el retorno

1446
01:16:50,950 --> 01:16:52,830
valor de foo 4.

1447
01:16:52,830 --> 01:16:57,930
foo es sólo va a devolver el
valor de la barra de 4 coma 6.

1448
01:16:57,930 --> 01:17:02,380
Y la barra se va a establecer algunos locales
n variable igual a 4 veces 6.

1449
01:17:02,380 --> 01:17:03,920
Y luego volver n.

1450
01:17:03,920 --> 01:17:09,130
>> Así que echemos un vistazo a la pila a lo largo
la iteración actual de este programa.

1451
01:17:09,130 --> 01:17:10,500
Así que la parte inferior de nuestra pila.

1452
01:17:10,500 --> 01:17:12,620
Recuerde que la pila crezca.

1453
01:17:12,620 --> 01:17:15,370
Así que en la parte inferior de nuestra pila, que
tener un marco de pila para las principales.

1454
01:17:15,370 --> 01:17:17,000
Al iniciar el programa, el principal
siempre va a estar en el

1455
01:17:17,000 --> 01:17:18,560
parte inferior de nuestra pila.

1456
01:17:18,560 --> 01:17:20,880
>> Y lo que está dentro de nuestra
apilar marco para main?

1457
01:17:20,880 --> 01:17:23,810
Así que, aunque no existen locales
variables al principal, como he dicho antes,

1458
01:17:23,810 --> 01:17:29,670
hemos argc y RGV ocupar espacio
interior del bastidor principal pila.

1459
01:17:29,670 --> 01:17:33,260
Así principal ahora se va a
llame a la función foo.

1460
01:17:33,260 --> 01:17:35,125
Y eso significa que foo va a
obtener su propio marco de pila.

1461
01:17:35,125 --> 01:17:36,970
>> Así que ahora estamos en el interior de
la función foo.

1462
01:17:36,970 --> 01:17:38,610
¿Y qué tiene que ir en
marco de pila de foo?

1463
01:17:38,610 --> 01:17:41,100
Bueno, foo tiene un argumento n.

1464
01:17:41,100 --> 01:17:45,440
Y n es igual a 4, ya que eso es lo que
principal pasa como argumento de foo.

1465
01:17:45,440 --> 01:17:48,490
>> Así que ahora foo va a llamar bar.

1466
01:17:48,490 --> 01:17:52,070
¿Qué es la barra va a tener en el interior
de su "marco de pila?

1467
01:17:52,070 --> 01:17:55,610
Tiene x igual a 4 y igual a seis.

1468
01:17:55,610 --> 01:17:58,540
Eso no es todo lo que vamos a tener
en el marco de pila porque la barra

1469
01:17:58,540 --> 01:18:00,580
también tiene una variable local n.

1470
01:18:00,580 --> 01:18:03,370
Y n que vamos a establecer igual a 24.

1471
01:18:03,370 --> 01:18:05,750
>> Así que ahora la barra va a regresar n.

1472
01:18:05,750 --> 01:18:09,300
Así barra 24 está volviendo a
el foo marco de pila.

1473
01:18:09,300 --> 01:18:12,560
Y debido bar regresa ahora, que
significa que estamos haciendo estallar el marco de pila

1474
01:18:12,560 --> 01:18:14,250
para la barra fuera de la pila.

1475
01:18:14,250 --> 01:18:18,430
Así que toda la memoria que había sido bar
usando ahora es de la pila.

1476
01:18:18,430 --> 01:18:21,550
>> Ahora, foo también va
para volver a 24 principal.

1477
01:18:21,550 --> 01:18:25,470
Así que ahora que foo está regresando, la memoria
foo que estaba usando en su '

1478
01:18:25,470 --> 01:18:27,550
marco de pila también se ha ido.

1479
01:18:27,550 --> 01:18:29,660
Y ahora, la principal va a llamar a printf.

1480
01:18:29,660 --> 01:18:31,660
Así printf es sólo otra función.

1481
01:18:31,660 --> 01:18:35,320
Cuando llamamos a printf, que va a ser
otro marco de pila para el printf

1482
01:18:35,320 --> 01:18:36,470
llamada a la función.

1483
01:18:36,470 --> 01:18:37,990
>> ¿Qué estamos pasando printf?

1484
01:18:37,990 --> 01:18:40,090
Eso es lo que va a ir
en su marco de pila.

1485
01:18:40,090 --> 01:18:44,970
Por lo menos, estamos pasando
que ciento i barra invertida n y

1486
01:18:44,970 --> 01:18:47,180
el argumento 24.

1487
01:18:47,180 --> 01:18:50,370
Podría tener más en es marco de pila
si printf pasa a ser el uso de algunos

1488
01:18:50,370 --> 01:18:51,200
variables locales.

1489
01:18:51,200 --> 01:18:51,920
No sabemos.

1490
01:18:51,920 --> 01:18:53,810
>> Pero todo lo que pasa en la printf
apilar marco.

1491
01:18:53,810 --> 01:18:55,740
Se va a ejecutar el printf.

1492
01:18:55,740 --> 01:18:56,830
Entonces printf que está hecho.

1493
01:18:56,830 --> 01:18:57,820
Volverá.

1494
01:18:57,820 --> 01:18:58,960
Por último, la principal está hecho.

1495
01:18:58,960 --> 01:18:59,860
Principal volverá.

1496
01:18:59,860 --> 01:19:02,020
Y entonces nuestro programa está hecho.

1497
01:19:02,020 --> 01:19:02,480
¿Sí?

1498
01:19:02,480 --> 01:19:04,505
>> AUDIENCIA: ¿Estás saliendo con [inaudible]

1499
01:19:04,505 --> 01:19:05,900
argumentos [inaudible]

1500
01:19:05,900 --> 01:19:06,830
parámetros?

1501
01:19:06,830 --> 01:19:09,970
>> ROB: Así que hay una sutil diferencia
entre los argumentos y parámetros.

1502
01:19:09,970 --> 01:19:14,400
Y realmente, en jerga común, la gente tiende
a sólo mezclarlos todo el tiempo.

1503
01:19:14,400 --> 01:19:17,550
Pero parámetros son los formales
nombre de las cosas.

1504
01:19:17,550 --> 01:19:20,180
>> Así argc y argv son el
parámetros a principal.

1505
01:19:20,180 --> 01:19:23,440
Los argumentos son lo que realmente
Aconteció en que esos parámetros.

1506
01:19:23,440 --> 01:19:28,340
Así que cuando me llame foo de 4, 4
es el argumento que estoy pasando.

1507
01:19:28,340 --> 01:19:31,460
Y el parámetro n, en el interior de
foo, toma el valor 4

1508
01:19:31,460 --> 01:19:32,880
desde 4 fue el argumento.

1509
01:19:32,880 --> 01:19:35,826
>> AUDIENCIA: [inaudible]?

1510
01:19:35,826 --> 01:19:37,880
>> ROB: n es una variable local a la barra.

1511
01:19:37,880 --> 01:19:41,420

1512
01:19:41,420 --> 01:19:44,960
n sigue siendo local para foo, pero
es un parámetro a foo.

1513
01:19:44,960 --> 01:19:48,190
No es una variable local.

1514
01:19:48,190 --> 01:19:48,546
¿Sí?

1515
01:19:48,546 --> 01:19:51,180
>> AUDIENCIA: [inaudible]?

1516
01:19:51,180 --> 01:19:55,400
>> ROB: bar foo es simplemente llamar y
devolver cualquier retornos de barras.

1517
01:19:55,400 --> 01:19:56,786
>> AUDIENCIA: [inaudible]?

1518
01:19:56,786 --> 01:19:59,591
>> ROB: Sí, sólo para ver múltiples
marcos de pila.

1519
01:19:59,591 --> 01:20:00,082
¿Sí?

1520
01:20:00,082 --> 01:20:03,519
>> AUDIENCIA: ¿Por qué se llama foo
antes printf?

1521
01:20:03,519 --> 01:20:05,920
>> ROB: ¿Por qué se llama foo antes printf?

1522
01:20:05,920 --> 01:20:10,740
Así que podría tener, en cambio, hacer algo
como int x es igual a foo de 4

1523
01:20:10,740 --> 01:20:12,980
y luego impresa x.

1524
01:20:12,980 --> 01:20:17,900
Pero en cambio, he combinado la función
poner en el argumento de printf.

1525
01:20:17,900 --> 01:20:23,670
>> Pero note que no podemos realmente
ejecutar la llamada a printf hasta que

1526
01:20:23,670 --> 01:20:25,610
averiguar lo foo de 4 es.

1527
01:20:25,610 --> 01:20:27,480
Así que vamos a evaluar esto.

1528
01:20:27,480 --> 01:20:32,504
Y sólo una vez que se han hecho van
regresar y evaluar esto.

1529
01:20:32,504 --> 01:20:32,990
¿Sí?

1530
01:20:32,990 --> 01:20:37,364
>> AUDIENCIA: Dado que tanto la barra [inaudible]

1531
01:20:37,364 --> 01:20:41,738
valor, ¿por qué nosotros no tiene [inaudible]?

1532
01:20:41,738 --> 01:20:44,400
>> ROB: Ellos totalmente deben ser int.

1533
01:20:44,400 --> 01:20:46,260
Eso no fue capturado en
múltiples pasadas.

1534
01:20:46,260 --> 01:20:49,010
Así debe ser int bar y int
foo ya que ambos de los

1535
01:20:49,010 --> 01:20:50,460
están regresando enteros.

1536
01:20:50,460 --> 01:20:54,214
Vacío es sólo si no van
para devolver valores reales.

1537
01:20:54,214 --> 01:20:54,692
¿Sí?

1538
01:20:54,692 --> 01:20:58,038
>> AUDIENCIA: Si tuvieras una línea por encima
el retorno, [inaudible]?

1539
01:20:58,038 --> 01:21:01,862

1540
01:21:01,862 --> 01:21:03,730
>> ROB: Una línea por encima de la rentabilidad?

1541
01:21:03,730 --> 01:21:04,410
>> AUDIENCIA: Si.

1542
01:21:04,410 --> 01:21:10,780
Al igual que si lo hicieras printf y [inaudible],
tendría que imprimir dos veces?

1543
01:21:10,780 --> 01:21:12,992
>> ROB: Así que dentro de foo?

1544
01:21:12,992 --> 01:21:15,945
Si tuviéramos un printf aquí?

1545
01:21:15,945 --> 01:21:16,750
>> AUDIENCIA: Si.

1546
01:21:16,750 --> 01:21:19,510
>> ROB: Así que si teníamos derecho printf
aquí, sería imprimir una vez.

1547
01:21:19,510 --> 01:21:23,400
Desde que estamos llamando foo vez derecho
aquí, a continuación, vamos a golpear el printf.

1548
01:21:23,400 --> 01:21:24,620
Entonces vamos a llamar bar.

1549
01:21:24,620 --> 01:21:25,710
Y entonces foo volverán.

1550
01:21:25,710 --> 01:21:26,275
Y eso es todo.

1551
01:21:26,275 --> 01:21:30,985
Sólo alguna vez encontramos
el printf vez.

1552
01:21:30,985 --> 01:21:31,482
¿Sí?

1553
01:21:31,482 --> 01:21:32,973
>> AUDIENCIA: [inaudible]

1554
01:21:32,973 --> 01:21:37,950
printf llamar foo, porque somos los primeros
llamar a printf y luego estamos pasando

1555
01:21:37,950 --> 01:21:38,580
los argumentos.

1556
01:21:38,580 --> 01:21:40,960
>> ROB: Así que en teoría, no es
printf llamar foo?

1557
01:21:40,960 --> 01:21:42,220
Así no.

1558
01:21:42,220 --> 01:21:47,360
Sólo el fin de que c va a
ejecutar estas cosas es, antes de que podamos

1559
01:21:47,360 --> 01:21:49,800
llamar a una función, todos los argumentos
a la función que

1560
01:21:49,800 --> 01:21:51,600
ser completamente evaluados.

1561
01:21:51,600 --> 01:21:53,540
Así es esta completamente evaluada?

1562
01:21:53,540 --> 01:21:54,610
Sí, es sólo una cadena.

1563
01:21:54,610 --> 01:21:55,480
Es sólo un valor.

1564
01:21:55,480 --> 01:21:57,200
>> Entonces tenemos que completamente
evaluar esto.

1565
01:21:57,200 --> 01:21:59,720
Una vez hecho esto, ahora todos
se evalúan sus argumentos.

1566
01:21:59,720 --> 01:22:01,982
Y ahora podemos hacer que el
llamar a printf.

1567
01:22:01,982 --> 01:22:02,478
¿Sí?

1568
01:22:02,478 --> 01:22:03,966
>> AUDIENCIA: Una pregunta.

1569
01:22:03,966 --> 01:22:06,942
Si usted tiene una función void, debe
usted tiene retorno y coma?

1570
01:22:06,942 --> 01:22:09,910
>> ROB: No hacer un punto y coma retorno
si tiene una función void.

1571
01:22:09,910 --> 01:22:13,370

1572
01:22:13,370 --> 01:22:14,780
Okay.

1573
01:22:14,780 --> 01:22:15,830
Así que ahora algunas cosas montón.

1574
01:22:15,830 --> 01:22:19,640
Así montón es cómo vamos a tratar
con la gestión de memoria dinámica.

1575
01:22:19,640 --> 01:22:23,100
Y esto contrasta directamente con la
pila que llamaríamos automática

1576
01:22:23,100 --> 01:22:24,100
la gestión de memoria.

1577
01:22:24,100 --> 01:22:27,140
>> Así que en la pila, nunca se tiene
para hacer frente a cómo las variables locales

1578
01:22:27,140 --> 01:22:30,400
están siendo empujado y hecho estallar fuera de todo
estos marcos de pila y todas esas cosas.

1579
01:22:30,400 --> 01:22:31,070
Usted no tiene que preocuparse por ello.

1580
01:22:31,070 --> 01:22:32,070
Es automático.

1581
01:22:32,070 --> 01:22:36,990
Así que el montón es manual.

1582
01:22:36,990 --> 01:22:38,070
Y la [inaudible]

1583
01:22:38,070 --> 01:22:41,260
proviene de estas funciones
malloc y libre.

1584
01:22:41,260 --> 01:22:43,550
>> Así que aquí está otro programa.

1585
01:22:43,550 --> 01:22:47,145
Todo lo que estamos haciendo es mallocing
un entero.

1586
01:22:47,145 --> 01:22:49,360
Estamos almacenarlo en estrella x.

1587
01:22:49,360 --> 01:22:52,520
Por supuesto, tenemos que comprobar
a ver si x es nulo.

1588
01:22:52,520 --> 01:22:56,400
Entonces vamos a lo que acaba de establecer
x está apuntando a un 50.

1589
01:22:56,400 --> 01:23:00,350

1590
01:23:00,350 --> 01:23:03,260
Imprima lo que x está apuntando a,
print x, y luego libre de x.

1591
01:23:03,260 --> 01:23:08,920
>> Entonces, ¿cómo es esto en realidad va a ver
si nos fijamos en nuestra pila y el montón?

1592
01:23:08,920 --> 01:23:10,950
Así que vamos a empezar de nuevo.

1593
01:23:10,950 --> 01:23:12,580
La parte inferior de nuestra pila como antes.

1594
01:23:12,580 --> 01:23:15,930
Recuerda que te uséis directamente
se opone a la pila?

1595
01:23:15,930 --> 01:23:18,850
Así que vamos a tener la
la parte superior de nuestro acervo allí.

1596
01:23:18,850 --> 01:23:22,590
>> Así que la parte inferior de nuestra pila, tenemos
nuestro marco de pila para las principales.

1597
01:23:22,590 --> 01:23:28,000
Tiene el espacio para argc, argv, y nos
ahora tenemos una variable local x, que

1598
01:23:28,000 --> 01:23:30,030
es un int estrellas.

1599
01:23:30,030 --> 01:23:32,240
Así que vamos a recorrer
a través de este programa.

1600
01:23:32,240 --> 01:23:34,420
Lo primero que tenemos es
una llamada a malloc.

1601
01:23:34,420 --> 01:23:36,250
>> Así que estamos haciendo una llamada a malloc.

1602
01:23:36,250 --> 01:23:37,100
Malloc es una función.

1603
01:23:37,100 --> 01:23:38,770
Se va a conseguir un marco de pila.

1604
01:23:38,770 --> 01:23:40,180
¿Qué estamos pasando a malloc?

1605
01:23:40,180 --> 01:23:41,610
Eso va a ir dentro de
del marco de pila.

1606
01:23:41,610 --> 01:23:45,130
Estamos pasando de tamaño n, que es 4.

1607
01:23:45,130 --> 01:23:49,700
Así que se pasa a malloc.

1608
01:23:49,700 --> 01:23:50,910
>> ¿Qué hace malloc?

1609
01:23:50,910 --> 01:23:53,820
Nos agarra un poco de espacio en el montón.

1610
01:23:53,820 --> 01:23:55,320
Así que vamos a ir a la pila.

1611
01:23:55,320 --> 01:23:57,990
Y vamos a tomar
4 bytes de la pila.

1612
01:23:57,990 --> 01:24:01,500
Así que vamos a dar que
una dirección arbitraria.

1613
01:24:01,500 --> 01:24:06,680
0x123 Sólo fingir que es un
dirección que está en el heap.

1614
01:24:06,680 --> 01:24:12,300
>> Entonces, ¿qué es en realidad dentro de ese
región de memoria en la dirección Ox123?

1615
01:24:12,300 --> 01:24:13,080
Garbage.

1616
01:24:13,080 --> 01:24:15,270
Así que no hemos guardado nada en ella.

1617
01:24:15,270 --> 01:24:18,830
Así que por lo que sabemos,
podría ser cualquier cosa.

1618
01:24:18,830 --> 01:24:20,560
Usted no debe asumir que es cero.

1619
01:24:20,560 --> 01:24:23,870
Es más probable que no es cero.

1620
01:24:23,870 --> 01:24:26,260
>> Así que ahora regresa malloc.

1621
01:24:26,260 --> 01:24:28,020
Y ¿qué hacemos cuando se restablezca el malloc?

1622
01:24:28,020 --> 01:24:29,800
Nos propusimos lo que devuelve.

1623
01:24:29,800 --> 01:24:32,290
Fijamos x igual a lo que
que está regresando.

1624
01:24:32,290 --> 01:24:33,690
Así que ¿qué es lo regresaba?

1625
01:24:33,690 --> 01:24:38,150
Está regresando 0x123 ya que es el
dirección del bloque de memoria que se

1626
01:24:38,150 --> 01:24:40,850
acaba de ser asignado en el montón.

1627
01:24:40,850 --> 01:24:47,160
>> Así que volver 0x123 x ahora va a ser establecido
igual a 0x123 que, ilustrado,

1628
01:24:47,160 --> 01:24:52,940
que con frecuencia dibujamos como X que tenga un real
flecha apuntando a ese bloque.

1629
01:24:52,940 --> 01:24:55,820
Pero x es simplemente almacenando esa dirección.

1630
01:24:55,820 --> 01:24:58,670
Así que ahora tenemos que comprobar si x es nulo.

1631
01:24:58,670 --> 01:24:59,120
No es nulo.

1632
01:24:59,120 --> 01:25:02,170
Pretendemos que esa malloc sucedió.

1633
01:25:02,170 --> 01:25:04,950
>> Así que ahora estrella de x es igual a 50.

1634
01:25:04,950 --> 01:25:08,450
Así estrella recuerda que significa
ir a esa dirección.

1635
01:25:08,450 --> 01:25:12,700
Así 0x123 Vamos a
ir a esa dirección.

1636
01:25:12,700 --> 01:25:14,660
Así que eso nos lleva hasta allí.

1637
01:25:14,660 --> 01:25:16,310
¿Qué estamos haciendo en esa dirección?

1638
01:25:16,310 --> 01:25:19,020
Estamos almacenando 50.

1639
01:25:19,020 --> 01:25:22,500
>> Así que después de esta línea, que es lo que
las cosas van a ser similar.

1640
01:25:22,500 --> 01:25:24,640
Así que ahora que ya no es
basura allí.

1641
01:25:24,640 --> 01:25:28,910
Ahora sabemos que el 50 es en ese
en particular porque la dirección

1642
01:25:28,910 --> 01:25:32,410
nos pusimos a ello.

1643
01:25:32,410 --> 01:25:32,790
¿De acuerdo?

1644
01:25:32,790 --> 01:25:34,370
Así que ahora vamos a imprimir f.

1645
01:25:34,370 --> 01:25:38,490
>> Así que primero vamos a imprimir estrella x.

1646
01:25:38,490 --> 01:25:39,640
Entonces, ¿qué es la estrella x?

1647
01:25:39,640 --> 01:25:44,300
Una vez más, la estrella x significa ir a la
cosa que x está apuntando.

1648
01:25:44,300 --> 01:25:47,140
Así que x es el almacenamiento de 0x123 Ir a eso.

1649
01:25:47,140 --> 01:25:48,490
Recibimos 50.

1650
01:25:48,490 --> 01:25:50,540
Así que imprimir f.

1651
01:25:50,540 --> 01:25:54,900
Y eso significa que va a imprimir 50.

1652
01:25:54,900 --> 01:25:56,850
Y luego que devuelve.

1653
01:25:56,850 --> 01:25:58,340
>> Y luego tenemos el segundo printf.

1654
01:25:58,340 --> 01:25:59,370
Ahora estamos por ciento p.

1655
01:25:59,370 --> 01:26:01,680
Si no lo has visto, eso es
cómo se imprime un puntero.

1656
01:26:01,680 --> 01:26:04,960
Así que tenemos por ciento i, ciento
f, y todos los que ya.

1657
01:26:04,960 --> 01:26:07,160
Así ciento p, imprimir un puntero.

1658
01:26:07,160 --> 01:26:08,920
>> Así que x es un puntero.

1659
01:26:08,920 --> 01:26:13,440
Así que si vamos a imprimir x sí mismo,
estamos imprimiendo lo que es en realidad dentro

1660
01:26:13,440 --> 01:26:19,220
x, que es 0x123 Así que la primera
print f va a imprimir 50.

1661
01:26:19,220 --> 01:26:23,620
La segunda impresión f va
imprimir 0x123 Sí?

1662
01:26:23,620 --> 01:26:27,460
>> AUDIENCIA: ¿Utiliza ciento
x para imprimir un puntero?

1663
01:26:27,460 --> 01:26:31,200
>> ROB: Así que usas ciento
x para imprimir un puntero?

1664
01:26:31,200 --> 01:26:38,350
Así que se puede, pero por ciento x es justo,
en general, para como si tiene alguna

1665
01:26:38,350 --> 01:26:40,325
entero y que desea imprimir
como un hexadecimal.

1666
01:26:40,325 --> 01:26:43,250

1667
01:26:43,250 --> 01:26:44,880
Así es como se hace eso.

1668
01:26:44,880 --> 01:26:47,160
>> Considerando que, por ciento d haría
imprimir como decimal.

1669
01:26:47,160 --> 01:26:50,310
Ahí es donde obtenemos ciento
d. i es simplemente entero.

1670
01:26:50,310 --> 01:26:52,690
ciento p es específicamente
para los punteros.

1671
01:26:52,690 --> 01:26:54,060
>> Así que x es un puntero.

1672
01:26:54,060 --> 01:26:56,360
Queremos utilizar el porcentaje p.

1673
01:26:56,360 --> 01:26:57,937
Pero por ciento x podría funcionar.

1674
01:26:57,937 --> 01:26:58,414
¿Sí?

1675
01:26:58,414 --> 01:26:59,664
>> AUDIENCIA: [inaudible]?

1676
01:26:59,664 --> 01:27:04,138

1677
01:27:04,138 --> 01:27:05,388
>> ROB: Si.

1678
01:27:05,388 --> 01:27:07,870

1679
01:27:07,870 --> 01:27:13,440
Al menos para este call-- así que
no incluirlo aquí.

1680
01:27:13,440 --> 01:27:19,850
Pero estos dos argumentos son necesariamente
dentro de este marco de pila

1681
01:27:19,850 --> 01:27:23,040
junto con las variables locales
printf pasa a estar usando.

1682
01:27:23,040 --> 01:27:27,020
Y a continuación, la siguiente llamada a printf ahora
dentro del marco de pila es printf

1683
01:27:27,020 --> 01:27:33,960
ciento p barra invertida n y cualquiera que sea el
valor de x es, que es 0x123.

1684
01:27:33,960 --> 01:27:34,425
¿Sí?

1685
01:27:34,425 --> 01:27:35,675
>> AUDIENCIA: [inaudible]?

1686
01:27:35,675 --> 01:27:38,145

1687
01:27:38,145 --> 01:27:40,880
>> ROB: Se va a imprimir algo
que se parece a esto.

1688
01:27:40,880 --> 01:27:41,846
>> AUDIENCIA: [inaudible].

1689
01:27:41,846 --> 01:27:44,510
>> ROB: ¿Así que la imprime en formato electrónico.

1690
01:27:44,510 --> 01:27:47,003
Se parece a una dirección.

1691
01:27:47,003 --> 01:27:47,494
¿Sí?

1692
01:27:47,494 --> 01:27:49,458
>> AUDIENCIA: [inaudible]?

1693
01:27:49,458 --> 01:27:51,075
>> ROB: ¿Por qué es qué?

1694
01:27:51,075 --> 01:27:52,920
>> AUDIENCIA: [inaudible]?

1695
01:27:52,920 --> 01:27:55,240
>> ROB: ¿Por qué es este puntero de 4 bytes?

1696
01:27:55,240 --> 01:27:58,500
Así que hay un montón
de 0 de delante de esta.

1697
01:27:58,500 --> 01:28:03,740
Así que es realmente 0x0000000123.

1698
01:28:03,740 --> 01:28:06,510
En un sistema de 64 bits, no habría
un montón de más ceros.

1699
01:28:06,510 --> 01:28:11,410

1700
01:28:11,410 --> 01:28:11,900
¿Sí?

1701
01:28:11,900 --> 01:28:13,150
>> AUDIENCIA: [inaudible].

1702
01:28:13,150 --> 01:28:17,290

1703
01:28:17,290 --> 01:28:21,130
>> ROB: Así que el primer printf
va a print--

1704
01:28:21,130 --> 01:28:21,980
>> AUDIENCIA: [inaudible].

1705
01:28:21,980 --> 01:28:24,420
>> ROB: Sí, se va a imprimir
lo que x está señalando.

1706
01:28:24,420 --> 01:28:27,030

1707
01:28:27,030 --> 01:28:29,070
Star dice lo que es este
lo que apunta a.

1708
01:28:29,070 --> 01:28:30,300
N..

1709
01:28:30,300 --> 01:28:31,455
Así que ¿qué es lo que apunta?

1710
01:28:31,455 --> 01:28:31,850
50.

1711
01:28:31,850 --> 01:28:32,410
N..

1712
01:28:32,410 --> 01:28:33,390
Eso es lo que vamos a imprimir.

1713
01:28:33,390 --> 01:28:37,020
Considerando que, en el siguiente, estamos
simplemente imprimir x sí mismo.

1714
01:28:37,020 --> 01:28:38,850
¿Qué hay dentro de la f?

1715
01:28:38,850 --> 01:28:43,710
0x123.

1716
01:28:43,710 --> 01:28:44,500
Okay.

1717
01:28:44,500 --> 01:28:46,620
>> Y entonces, por fin, tenemos el libre.

1718
01:28:46,620 --> 01:28:48,040
¿Qué estamos pasando a liberar?

1719
01:28:48,040 --> 01:28:49,470
Estamos pasando x.

1720
01:28:49,470 --> 01:28:52,380
Ese tiempo realmente exhibí
en el marco de pila.

1721
01:28:52,380 --> 01:28:56,370
>> Así que estamos pasando el valor
0x123 para liberar.

1722
01:28:56,370 --> 01:28:59,070
Así que ahora gratis sabe, está bien,
Tengo que ir hasta el montón

1723
01:28:59,070 --> 01:29:00,050
y libre que la memoria.

1724
01:29:00,050 --> 01:29:03,920
Ya no está usando lo que
es en la dirección 0x123.

1725
01:29:03,920 --> 01:29:07,010
>> Tan libre va a liberar
que del montón.

1726
01:29:07,010 --> 01:29:09,490
Ahora nuestra pila está vacía otra vez.

1727
01:29:09,490 --> 01:29:11,120
No tenemos pérdidas de memoria.

1728
01:29:11,120 --> 01:29:12,940
Ahora libre volverá.

1729
01:29:12,940 --> 01:29:16,130
Observe que x es aún 0x123.

1730
01:29:16,130 --> 01:29:18,240
Pero eso no es ahora de memoria válida.

1731
01:29:18,240 --> 01:29:21,220

1732
01:29:21,220 --> 01:29:23,986
Ya no debemos eliminar la referencia de x.

1733
01:29:23,986 --> 01:29:24,440
¿Sí?

1734
01:29:24,440 --> 01:29:27,240
>> AUDIENCIA: Es volver 0 redundante?

1735
01:29:27,240 --> 01:29:28,290
>> ROB: ¿Es returen 0 redundante?

1736
01:29:28,290 --> 01:29:31,110
Sí.

1737
01:29:31,110 --> 01:29:33,950
Acabamos de poner que hay porque
tenemos un retorno de uno de aire.

1738
01:29:33,950 --> 01:29:36,830
Así es como, sí, vamos a
incluir el retorno 0.

1739
01:29:36,830 --> 01:29:37,310
¿Sí?

1740
01:29:37,310 --> 01:29:38,560
>> AUDIENCIA: [inaudible]?

1741
01:29:38,560 --> 01:29:42,110

1742
01:29:42,110 --> 01:29:45,580
>> ROB: Así que después de x gratis, ¿qué ocurre si
tratamos de eliminar la referencia al puntero?

1743
01:29:45,580 --> 01:29:47,240
Es posible que nada salga mal.

1744
01:29:47,240 --> 01:29:49,330
Es posible que todavía nos conseguimos 50.

1745
01:29:49,330 --> 01:29:53,590
>> Es posible, también, que esa memoria es
que ahora se utiliza para otra cosa.

1746
01:29:53,590 --> 01:29:57,140
Así que es un comportamiento indefinido.

1747
01:29:57,140 --> 01:30:00,772
Y indefinido significa nada
puede suceder.

1748
01:30:00,772 --> 01:30:01,250
¿Sí?

1749
01:30:01,250 --> 01:30:02,500
>> AUDIENCIA: [inaudible]?

1750
01:30:02,500 --> 01:30:07,942

1751
01:30:07,942 --> 01:30:10,830
>> ROB: No, por lo que si usted asigna
x a otra cosa.

1752
01:30:10,830 --> 01:30:15,870
Así que si aquí dijimos x es igual a
algo malloc else--

1753
01:30:15,870 --> 01:30:17,100
Tamaño malloc event--

1754
01:30:17,100 --> 01:30:20,180
entonces que bloque original
de la memoria no se libera.

1755
01:30:20,180 --> 01:30:21,490
Y hemos perdido oficialmente.

1756
01:30:21,490 --> 01:30:23,150
Eso es una pérdida de memoria.

1757
01:30:23,150 --> 01:30:25,090
Hemos perdido todas las referencias
a ese bloque de memoria.

1758
01:30:25,090 --> 01:30:26,827
Así que no hay manera de que jamás podamos liberarla.

1759
01:30:26,827 --> 01:30:32,074

1760
01:30:32,074 --> 01:30:36,630
OK, así que luego regrese 0 significa hecho.

1761
01:30:36,630 --> 01:30:37,900
>> Muy bien, así que el desbordamiento de pila.

1762
01:30:37,900 --> 01:30:39,320
¿Cuál es la idea aquí?

1763
01:30:39,320 --> 01:30:41,210
Así que recuerda, montón está bajando.

1764
01:30:41,210 --> 01:30:43,480
Pila está subiendo.

1765
01:30:43,480 --> 01:30:48,000
Así que este fue el ejemplo de la conferencia,
Creo que, en su principal sólo va a

1766
01:30:48,000 --> 01:30:51,380
llamar a esta función foo, que va
llamarse recursivamente una y

1767
01:30:51,380 --> 01:30:52,320
otra vez.

1768
01:30:52,320 --> 01:30:55,370
>> Así se apilan las tramas se van a
trabajar exactamente de la misma.

1769
01:30:55,370 --> 01:30:58,130
Así que vamos a empezar con la principal
como el marco de pila inferior.

1770
01:30:58,130 --> 01:31:02,000
Luego principal va a llamar a foo, que
se va a conseguir un marco de pila.

1771
01:31:02,000 --> 01:31:04,260
>> Entonces foo va a llamar foo
de nuevo, que se va a poner

1772
01:31:04,260 --> 01:31:05,500
otro marco de pila.

1773
01:31:05,500 --> 01:31:08,270
Y luego otra vez, y otra vez, y otra vez,
y otra vez hasta que, finalmente, se corre

1774
01:31:08,270 --> 01:31:09,190
en el montón.

1775
01:31:09,190 --> 01:31:11,990
Así que esta es la forma en que obtenemos
un desbordamiento de pila.

1776
01:31:11,990 --> 01:31:14,910
Y en este punto, usted SEG culpa.

1777
01:31:14,910 --> 01:31:17,335
O usted realmente seg mancha delante
este punto pero sí.

1778
01:31:17,335 --> 01:31:19,660
>> AUDIENCIA: ¿Es un volcado del núcleo del
mismo que falla seg?

1779
01:31:19,660 --> 01:31:26,140
>> ROB: Así que usted verá la segmentación
núcleo falla dejó.

1780
01:31:26,140 --> 01:31:28,760
Usted obtiene un volcado de memoria cuando
usted SEG culpa.

1781
01:31:28,760 --> 01:31:32,580
Y es como un volcado de toda la
contenido de la memoria actual, de modo

1782
01:31:32,580 --> 01:31:36,670
que se puede tratar de identificar
por qué SEG criticado.

1783
01:31:36,670 --> 01:31:37,135
¿Sí?

1784
01:31:37,135 --> 01:31:38,385
>> AUDIENCIA: [inaudible]?

1785
01:31:38,385 --> 01:31:40,855

1786
01:31:40,855 --> 01:31:45,460
>> ROB: Así que un medio de fallo de segmentación
hay un desbordamiento de pila.

1787
01:31:45,460 --> 01:31:47,060
Así que no necesariamente.

1788
01:31:47,060 --> 01:31:49,880
Un fallo de segmentación significa que eres
tocar la memoria de una manera

1789
01:31:49,880 --> 01:31:50,880
usted no debe ser.

1790
01:31:50,880 --> 01:31:54,750
Así que una manera de que eso ocurra es, cuando
usted desbordamiento de pila, empezamos tocando

1791
01:31:54,750 --> 01:31:58,736
memoria de una manera que no debemos ser.

1792
01:31:58,736 --> 01:31:59,208
¿Sí?

1793
01:31:59,208 --> 01:32:00,458
>> AUDIENCIA: [inaudible]?

1794
01:32:00,458 --> 01:32:03,456

1795
01:32:03,456 --> 01:32:05,830
>> ROB: Así que dentro de un bucle infinito.

1796
01:32:05,830 --> 01:32:08,770
Al igual, esto es como una infinita recursiva
bucle y así tenemos otra

1797
01:32:08,770 --> 01:32:09,770
pila enmarcar cada vez.

1798
01:32:09,770 --> 01:32:13,540
Pero justo en el interior de un habitual
infinito mientras uno--

1799
01:32:13,540 --> 01:32:16,390
bueno, vamos ni siquiera imprimir F--

1800
01:32:16,390 --> 01:32:17,040
hacer algo.

1801
01:32:17,040 --> 01:32:18,390
Lo que sea.

1802
01:32:18,390 --> 01:32:20,610
>> No vamos a estar recibiendo
otro marco de pila.

1803
01:32:20,610 --> 01:32:22,530
Sólo vamos a mantener looping
sobre esta única instrucción.

1804
01:32:22,530 --> 01:32:23,920
La pila no está creciendo.

1805
01:32:23,920 --> 01:32:27,290
Es el hecho de que cada recursiva
llamada nos está dando un marco de pila.

1806
01:32:27,290 --> 01:32:31,231
Es por eso que tenemos un desbordamiento de pila.

1807
01:32:31,231 --> 01:32:31,728
¿Sí?

1808
01:32:31,728 --> 01:32:38,189
>> AUDIENCIA: Así que si usted dice que obtener el
while y luego [inaudible]?

1809
01:32:38,189 --> 01:32:42,000
>> ROB: Así que si dentro del bucle while
hubo un printf, a pesar de ello

1810
01:32:42,000 --> 01:32:42,790
culpa no seg.

1811
01:32:42,790 --> 01:32:46,090
Yo simplemente no quiero confundir las cosas.

1812
01:32:46,090 --> 01:32:46,610
Sería bucle.

1813
01:32:46,610 --> 01:32:48,225
Obtendría una sola pila
enmarcar para el printf.

1814
01:32:48,225 --> 01:32:49,580
>> Entonces printf regresaría.

1815
01:32:49,580 --> 01:32:50,280
Entonces será bucle de nuevo.

1816
01:32:50,280 --> 01:32:51,460
Obtendría una sola pila
enmarcar para el printf.

1817
01:32:51,460 --> 01:32:52,850
Sería volver.

1818
01:32:52,850 --> 01:32:54,060
Marco de pila individual.

1819
01:32:54,060 --> 01:33:00,215
Así que usted no está consiguiendo este infinito
apilando marcos de pila.

1820
01:33:00,215 --> 01:33:03,185
>> AUDIENCIA: [inaudible]?

1821
01:33:03,185 --> 01:33:04,040
>> ROB: Si.

1822
01:33:04,040 --> 01:33:09,360
Así que este desbordamiento de pila ocurre
porque ninguno de ellos

1823
01:33:09,360 --> 01:33:11,600
llamadas a foo están regresando.

1824
01:33:11,600 --> 01:33:15,250
Así que si volvemos, entonces lo haríamos
empezar a perder los marcos de pila.

1825
01:33:15,250 --> 01:33:17,870
Y entonces no tendríamos desbordamiento de pila.

1826
01:33:17,870 --> 01:33:20,070
Y es por eso que usted necesita un caso base
para sus funciones personales.

1827
01:33:20,070 --> 01:33:22,992

1828
01:33:22,992 --> 01:33:23,479
¿Sí?

1829
01:33:23,479 --> 01:33:27,375
>> AUDIENCIA: ¿Es el tamaño potencial y la
apilar para el montón de la misma para

1830
01:33:27,375 --> 01:33:29,880
todos los programas?

1831
01:33:29,880 --> 01:33:31,910
>> ROB: Aproximadamente.

1832
01:33:31,910 --> 01:33:35,090
¿Es el tamaño potencial de la pila y
el montón de la misma para todos los programas?

1833
01:33:35,090 --> 01:33:37,180
Aproximadamente.

1834
01:33:37,180 --> 01:33:40,080
Hay algo de la aleatorización hasta
donde comienza la pila y

1835
01:33:40,080 --> 01:33:42,400
donde comienza el montón.

1836
01:33:42,400 --> 01:33:45,870
Si le sucede que tiene una gran cantidad de
variables y cosas globales, es posible que

1837
01:33:45,870 --> 01:33:49,520
quitar un poco de espacio
para su montón.

1838
01:33:49,520 --> 01:33:54,060
>> En un sistema de 64 bits, que prácticamente
tener memoria infinita.

1839
01:33:54,060 --> 01:33:55,820
Hay tantas cosas.

1840
01:33:55,820 --> 01:33:59,250
Entre 32 bits y 64 bits, que
es una diferencia significativa.

1841
01:33:59,250 --> 01:34:02,350
>> Usted va a conseguir mucho más
apilar y espacio de almacenamiento dinámico en una de 64 bits

1842
01:34:02,350 --> 01:34:05,810
sistema porque no sólo más
Las direcciones que se pueden utilizar.

1843
01:34:05,810 --> 01:34:09,360
Pero en un sistema individual, lo hará
ser más o menos la misma cantidad de pila

1844
01:34:09,360 --> 01:34:10,785
y espacio de almacenamiento dinámico.

1845
01:34:10,785 --> 01:34:13,635

1846
01:34:13,635 --> 01:34:15,530
Bien.

1847
01:34:15,530 --> 01:34:18,220
>> Así que lo último es la compilación.

1848
01:34:18,220 --> 01:34:19,810
Así que usted debe saber este proceso.

1849
01:34:19,810 --> 01:34:22,240
Hay cuatro grandes pasos.

1850
01:34:22,240 --> 01:34:24,400
Así que el primero debe
ser fácil de recordar.

1851
01:34:24,400 --> 01:34:25,085
Pre-procesamiento.

1852
01:34:25,085 --> 01:34:28,390
Cuenta con el prefijo pre en el mismo.

1853
01:34:28,390 --> 01:34:32,080
Así que se trata antes de todo lo demás.

1854
01:34:32,080 --> 01:34:34,000
>> La cosa a recordar es el hash.

1855
01:34:34,000 --> 01:34:37,250
Así define hachís y hachís incluye
en todos aquellos.

1856
01:34:37,250 --> 01:34:39,560
Esos son todos los pre-procesador
directivas.

1857
01:34:39,560 --> 01:34:42,030
Estas son las cosas que los
pre-procesador se encarga de.

1858
01:34:42,030 --> 01:34:43,680
>> Entonces, ¿qué hace un pre-procesador?

1859
01:34:43,680 --> 01:34:44,850
Es una cosa muy tonta.

1860
01:34:44,850 --> 01:34:49,380
Todo lo que es capaz de hacer son todos ellos
copia y de corte, y pegar operaciones.

1861
01:34:49,380 --> 01:34:51,790
>> Así de hash estándar incluye dot i0 h.

1862
01:34:51,790 --> 01:34:52,990
¿Qué es eso que hace?

1863
01:34:52,990 --> 01:34:56,610
Se quitó la norma i0 punto h
presentar y pegándolo en la parte superior

1864
01:34:56,610 --> 01:34:58,960
dondequiera que dice hachís incluye
estándar dot h i0.

1865
01:34:58,960 --> 01:35:02,480
>> Y cualquier hash de definir que hemos
ve, lo que se que hacer?

1866
01:35:02,480 --> 01:35:06,730
Su copiando el valor que el hash
definido se define como y pegar que

1867
01:35:06,730 --> 01:35:08,500
donde quiera que esté utilizando el valor.

1868
01:35:08,500 --> 01:35:13,400
Así que el preprocesador simplemente hace realmente
operaciones basadas en texto sencillo.

1869
01:35:13,400 --> 01:35:15,870
No hace nada inteligente.

1870
01:35:15,870 --> 01:35:18,920
Así que todo lo demás es
más complicado.

1871
01:35:18,920 --> 01:35:22,970
>> Así que ahora que es preprocesador
hecho, en realidad compilamos.

1872
01:35:22,970 --> 01:35:24,320
Así que, ¿qué significa la compilación?

1873
01:35:24,320 --> 01:35:27,310
Estamos pasando de código c
al código ensamblador.

1874
01:35:27,310 --> 01:35:27,570
¿Sí?

1875
01:35:27,570 --> 01:35:28,820
>> AUDIENCIA: [inaudible]?

1876
01:35:28,820 --> 01:35:32,390

1877
01:35:32,390 --> 01:35:34,220
>> ROB: Sí, cogimos eso.

1878
01:35:34,220 --> 01:35:36,880

1879
01:35:36,880 --> 01:35:38,660
Así que la compilación.

1880
01:35:38,660 --> 01:35:40,310
Vamos de c para el montaje.

1881
01:35:40,310 --> 01:35:42,470
Así que esto es un cambio de idioma actual.

1882
01:35:42,470 --> 01:35:45,240
Compilación de sí mismo significa pasar de
un lenguaje de alto nivel para

1883
01:35:45,240 --> 01:35:47,340
un lenguaje de nivel inferior.

1884
01:35:47,340 --> 01:35:50,720
>> Y C es un lenguaje de alto nivel
en comparación con el montaje.

1885
01:35:50,720 --> 01:35:52,320
¿Cuál es el montaje?

1886
01:35:52,320 --> 01:35:56,440
Sus instrucciones, que son bastante
mucho, hecha para su CPU.

1887
01:35:56,440 --> 01:35:59,130
Pero el ordenador sigue
No entender el montaje.

1888
01:35:59,130 --> 01:36:01,570
Sólo se entiende unos y ceros.

1889
01:36:01,570 --> 01:36:06,160
Así que el siguiente paso es el montaje, que
nos lleva de estas instrucciones que

1890
01:36:06,160 --> 01:36:08,760
su CPU entiende y realidad
los traduce, a

1891
01:36:08,760 --> 01:36:10,820
los unos y ceros.

1892
01:36:10,820 --> 01:36:13,570
>> Así C para montaje en binario.

1893
01:36:13,570 --> 01:36:15,870
Pero yo no tengo un ejecutable todavía.

1894
01:36:15,870 --> 01:36:19,550
Así que piensa en la biblioteca CS50.

1895
01:36:19,550 --> 01:36:23,070
Nosotros le proporcionamos un binario para
esta biblioteca CS50, que tiene GetString

1896
01:36:23,070 --> 01:36:24,400
y getInt y todo eso.

1897
01:36:24,400 --> 01:36:25,700
>> Pero el CS50 library--

1898
01:36:25,700 --> 01:36:27,650
y de itself-- no es ejecutable.

1899
01:36:27,650 --> 01:36:29,570
No tiene una función principal.

1900
01:36:29,570 --> 01:36:32,230
Es sólo un montón de binario
que se puede utilizar.

1901
01:36:32,230 --> 01:36:41,730
Así que la vinculación es cómo reunir a todos
de estos diferentes archivos binarios

1902
01:36:41,730 --> 01:36:43,110
en un archivo ejecutable real.

1903
01:36:43,110 --> 01:36:45,900
Uno que puede escribir
dot recortar un punto fuera.

1904
01:36:45,900 --> 01:36:51,660
>> Así que esto es como el archivo que
escribió, - sea cual sea su programa es--

1905
01:36:51,660 --> 01:36:53,620
Ceaser punto c.

1906
01:36:53,620 --> 01:36:55,100
Pero ahora que ha sido compilado
a binario.

1907
01:36:55,100 --> 01:36:56,480
Así que o punto Ceaser.

1908
01:36:56,480 --> 01:36:59,620
Y esta es nuestra CS50 bibliotecas binario.

1909
01:36:59,620 --> 01:37:02,284
Y están siendo combinados
en un solo ejecutable.

1910
01:37:02,284 --> 01:37:02,758
¿Sí?

1911
01:37:02,758 --> 01:37:04,008
>> AUDIENCIA: [inaudible]?

1912
01:37:04,008 --> 01:37:08,800

1913
01:37:08,800 --> 01:37:12,710
>> ROB: Así que primero incluye, recuerda,
el hash incluir es en realidad un

1914
01:37:12,710 --> 01:37:13,810
etapa de pre-procesador.

1915
01:37:13,810 --> 01:37:14,750
Pero eso es aparte.

1916
01:37:14,750 --> 01:37:20,730
Si usted no está utilizando ninguna función que
están fuera de su archivo solo entonces,

1917
01:37:20,730 --> 01:37:26,100
no, no es necesario vincular nada
ya que tienes todo.

1918
01:37:26,100 --> 01:37:30,310
>> Dicho esto, printf está siendo vinculado en.

1919
01:37:30,310 --> 01:37:32,820
Si alguna vez utiliza printf, eso es algo
que necesita ser vinculado en

1920
01:37:32,820 --> 01:37:35,740
porque usted no escribió eso.

1921
01:37:35,740 --> 01:37:39,530
Y, de hecho, printf es automáticamente
vinculada en.

1922
01:37:39,530 --> 01:37:42,760
Usted sabe cómo en la línea de comandos o cuando
usted escribiría make, verlo tiene

1923
01:37:42,760 --> 01:37:46,690
tablero l CS50, que tiene enlace
en la biblioteca CS50?

1924
01:37:46,690 --> 01:37:49,070
Printf, y cosas por el estilo, se va
estar vinculado en forma automática.

1925
01:37:49,070 --> 01:37:51,730

1926
01:37:51,730 --> 01:37:53,930
¿Alguna otra pregunta sobre algo?

1927
01:37:53,930 --> 01:37:56,280
>> AUDIENCIA: [inaudible]?

1928
01:37:56,280 --> 01:37:58,300
>> ROB: Vinculación?

1929
01:37:58,300 --> 01:38:03,450
Tenemos un montón de
diferentes archivos binarios.

1930
01:38:03,450 --> 01:38:06,410
Este es el ejemplo canónico
que utilizamos es la biblioteca CS50.

1931
01:38:06,410 --> 01:38:09,960
Hemos recopilado y que le ha asignado el
binario para esta biblioteca CS50.

1932
01:38:09,960 --> 01:38:12,410
>> Desea utilizar GetString
en su programa.

1933
01:38:12,410 --> 01:38:14,750
Así que ve y utiliza GetString.

1934
01:38:14,750 --> 01:38:19,700
Pero sin mi código binario para
GetString, al compilar el código

1935
01:38:19,700 --> 01:38:23,140
abajo, usted no pueda ejecutar su
programa porque GetString cuerdas es

1936
01:38:23,140 --> 01:38:25,080
aún no completamente definido.

1937
01:38:25,080 --> 01:38:29,220
>> Es sólo cuando se vincula en mi binario
que contiene GetString que ahora, todo

1938
01:38:29,220 --> 01:38:31,130
derecho, que pueda realmente
ejecutar GetString.

1939
01:38:31,130 --> 01:38:32,330
Mi expediente está completo.

1940
01:38:32,330 --> 01:38:34,208
Y puedo ejecutar este.

1941
01:38:34,208 --> 01:38:34,697
¿Sí?

1942
01:38:34,697 --> 01:38:37,631
>> AUDIENCIA: Lo que convertir vinculando
el binario ejecutable a?

1943
01:38:37,631 --> 01:38:42,032
Así que incluso si usted no tiene otra
bibliotecas, no seguiría siendo

1944
01:38:42,032 --> 01:38:44,477
necesario traducir
la [inaudible]?

1945
01:38:44,477 --> 01:38:48,640
>> ROB: Así que un ejecutable
todavía está en binario.

1946
01:38:48,640 --> 01:38:51,750
Es que la combinación de un conjunto
montón de binarios.

1947
01:38:51,750 --> 01:38:55,124

1948
01:38:55,124 --> 01:38:56,591
>> AUDIENCIA: Muchas gracias.

1949
01:38:56,591 --> 01:38:58,560
>> ROB: No hay problema.

1950
01:38:58,560 --> 01:38:59,540
Alguna otra pregunta?

1951
01:38:59,540 --> 01:39:02,001
De lo contrario, estamos listos.

1952
01:39:02,001 --> 01:39:02,690
Bien.

1953
01:39:02,690 --> 01:39:02,990
Gracias.

1954
01:39:02,990 --> 01:39:03,590
>> [Aplausos]

1955
01:39:03,590 --> 01:39:04,490
>> AUDIENCIA: Gracias.

1956
01:39:04,490 --> 01:39:05,740
>> ROB: Si.

1957
01:39:05,740 --> 01:39:06,582