1
00:00:00,000 --> 00:00:09,572

2
00:00:09,572 --> 00:00:12,030
ROB BOWDEN: Salut, je suis Rob Bowden,
et parlons quiz0.

3
00:00:12,030 --> 00:00:13,280

4
00:00:13,280 --> 00:00:14,545
>> Donc, première question.

5
00:00:14,545 --> 00:00:17,750
Telle est la question où
vous avez besoin pour coder le numéro

6
00:00:17,750 --> 00:00:21,270
127 dans les ampoules binaires.

7
00:00:21,270 --> 00:00:23,550
Si vous vouliez, vous pourriez
faire la conversion régulière

8
00:00:23,550 --> 00:00:25,950
de bi-- ou, de décimal à binaire.

9
00:00:25,950 --> 00:00:28,300
Mais que va probablement
de prendre beaucoup de temps.

10
00:00:28,300 --> 00:00:31,750
Je veux dire, vous pouvez comprendre que,
OK, 1 est là, 2 est là,

11
00:00:31,750 --> 00:00:33,650
4 est là, 8 est là.

12
00:00:33,650 --> 00:00:39,280
Moyen plus facile, est de 128 127 moins un.

13
00:00:39,280 --> 00:00:42,013
Cette ampoule de gauche est le 128-bit.

14
00:00:42,013 --> 00:00:43,490

15
00:00:43,490 --> 00:00:47,860
Donc 127 est vraiment juste tout
des autres ampoules,

16
00:00:47,860 --> 00:00:51,420
depuis que la gauche est
ampoule moins 1.

17
00:00:51,420 --> 00:00:52,800
Voilà pour cette question.

18
00:00:52,800 --> 00:00:54,060
>> Première question.

19
00:00:54,060 --> 00:00:56,710
Donc, avec 3 bits, vous pouvez
représenter 8 valeurs distinctes.

20
00:00:56,710 --> 00:01:01,000
Pourquoi, alors, est de 7 le plus grand non-négatif
entier décimal vous pouvez représenter?

21
00:01:01,000 --> 00:01:04,050
Eh bien, si nous ne pouvons
représenter 8 valeurs distinctes,

22
00:01:04,050 --> 00:01:07,430
alors ce que nous allons être
représente 0 à 7.

23
00:01:07,430 --> 00:01:08,745
0 prend l'une des valeurs.

24
00:01:08,745 --> 00:01:09,980

25
00:01:09,980 --> 00:01:11,190
>> Deuxième question.

26
00:01:11,190 --> 00:01:14,610
Avec n bits, combien distinct
valeurs peuvent vous représenter?

27
00:01:14,610 --> 00:01:19,080
Ainsi, avec n bits, vous avez 2
valeurs possibles pour chaque bit.

28
00:01:19,080 --> 00:01:22,300
Nous avons donc deux valeurs possibles pour
le premier bit, deux valeurs possibles

29
00:01:22,300 --> 00:01:24,450
pour le deuxième, 2
possible pour le troisième.

30
00:01:24,450 --> 00:01:28,730
Et qui est 2 fois 2 fois 2, et
en fin de compte la réponse est de 2 à n.

31
00:01:28,730 --> 00:01:30,010

32
00:01:30,010 --> 00:01:31,100
>> La troisième question.

33
00:01:31,100 --> 00:01:33,450
Quel est 0x50 en binaire?

34
00:01:33,450 --> 00:01:39,490
Alors rappelez-vous que hexadécimal a une très
conversion simple en binaire.

35
00:01:39,490 --> 00:01:43,180
Donc, ici, nous avons juste besoin de regarder
le 5 et le 0 de façon indépendante.

36
00:01:43,180 --> 00:01:45,110
Donc, ce qui est 5 en binaire?

37
00:01:45,110 --> 00:01:48,400
0101, qui est le bit 1 et le 4 bits.

38
00:01:48,400 --> 00:01:49,900
Ce qui est 0 en binaire?

39
00:01:49,900 --> 00:01:50,520
Pas difficile.

40
00:01:50,520 --> 00:01:52,180
0000.

41
00:01:52,180 --> 00:01:54,970
Il suffit donc de les mettre ensemble, et
qui est le numéro complet en binaire.

42
00:01:54,970 --> 00:01:57,640
01010000.

43
00:01:57,640 --> 00:02:00,439
Et si vous vouliez vous pourriez
décoller que de gauche à zéro.

44
00:02:00,439 --> 00:02:01,105
Il est hors de propos.

45
00:02:01,105 --> 00:02:02,920

46
00:02:02,920 --> 00:02:05,733
>> Alors encore,
ce qui est 0x50 en décimal?

47
00:02:05,733 --> 00:02:08,649
Si vous voulez, vous could-- si vous êtes
plus à l'aise avec le binaire,

48
00:02:08,649 --> 00:02:11,340
vous pourriez prendre cette réponse binaire
et convertir en décimal.

49
00:02:11,340 --> 00:02:13,870
Ou nous pourrions rappeler
que hexadécimal.

50
00:02:13,870 --> 00:02:21,140
Alors que 0 est dans le 0-ème place, et
la figure 5 est dans le 16 à la première place.

51
00:02:21,140 --> 00:02:25,990
Donc, ici, nous avons 5 fois 16 à la
première, plus 0 fois 16 à zéro,

52
00:02:25,990 --> 00:02:27,520
80 est.

53
00:02:27,520 --> 00:02:29,710
Et si vous regardiez à la
titre de la question,

54
00:02:29,710 --> 00:02:32,920
il était CS 80, qui était une sorte de
allusion à la réponse à ce problème.

55
00:02:32,920 --> 00:02:34,460

56
00:02:34,460 --> 00:02:35,420
>> Question de cinq ans.

57
00:02:35,420 --> 00:02:40,320
Nous avons ce script de zéro, ce qui est
répéter 4 fois le beurre d'arachide gelée.

58
00:02:40,320 --> 00:02:42,800
Alors, comment pouvons-nous maintenant le code que dans C?

59
00:02:42,800 --> 00:02:47,730
Eh bien, nous avons ici-- la partie en gras
est la seule partie que vous aviez à mettre en œuvre.

60
00:02:47,730 --> 00:02:51,950
Nous avons donc une boucle de 4 qui tourne en boucle 4
fois, ing printf beurre d'arachide gelée,

61
00:02:51,950 --> 00:02:53,910
avec la nouvelle ligne que le problème demande.

62
00:02:53,910 --> 00:02:55,250

63
00:02:55,250 --> 00:02:57,490
>> Question six, un autre problème de Scratch.

64
00:02:57,490 --> 00:03:00,210
Nous voyons que nous sommes dans une boucle infinie.

65
00:03:00,210 --> 00:03:05,000
Nous disons la variable i
et puis incrémenter i de 1.

66
00:03:05,000 --> 00:03:09,580
Maintenant, nous voulons le faire en C. Il ya
de multiples façons nous aurions pu faire cela.

67
00:03:09,580 --> 00:03:12,840
Ici nous est arrivé de coder la
toujours comme une boucle while (true).

68
00:03:12,840 --> 00:03:16,600
Donc, nous déclarons la variable i, juste
comme nous avons eu la variable i dans Scratch.

69
00:03:16,600 --> 00:03:21,950
Déclarez la variable i, et pour toujours
while (true), nous disons que la variable i.

70
00:03:21,950 --> 00:03:25,260
Donc printf% i-- ou vous auriez pu utiliser% d.

71
00:03:25,260 --> 00:03:27,985
Nous disons que la variable, et
puis incrémenter, i ++.

72
00:03:27,985 --> 00:03:29,560

73
00:03:29,560 --> 00:03:30,830
>> Question sept.

74
00:03:30,830 --> 00:03:35,560
Maintenant, nous voulons faire quelque chose de très similaire
Mario point c de problème en créer un.

75
00:03:35,560 --> 00:03:39,110
Nous voulons imprimer ces hashtags,
nous voulons imprimer un cinq

76
00:03:39,110 --> 00:03:40,700
par trois rectangle de ces valeurs de hachage.

77
00:03:40,700 --> 00:03:41,770

78
00:03:41,770 --> 00:03:43,162
Alors, comment allons-nous faire cela?

79
00:03:43,162 --> 00:03:45,370
Eh bien, nous vous donnons un ensemble
tas de code, et vous venez de

80
00:03:45,370 --> 00:03:47,560
avoir à remplir la fonction de la grille d'impression.

81
00:03:47,560 --> 00:03:49,540
>> Alors qu'est-ce PrintGrid ressemble?

82
00:03:49,540 --> 00:03:51,480
Eh bien, vous êtes passé le
la largeur et la hauteur.

83
00:03:51,480 --> 00:03:53,520
Nous avons donc un extérieur 4
boucle, qui tourne en boucle

84
00:03:53,520 --> 00:03:57,650
sur toutes les lignes de ce
grille que nous voulons imprimer.

85
00:03:57,650 --> 00:04:01,250
Ensuite, nous avons le 4 boucle inter-imbriquée,
qui est l'impression sur chaque colonne.

86
00:04:01,250 --> 00:04:06,210
Donc, pour chaque ligne, nous imprimons pour
chaque colonne, une seule table de hachage.

87
00:04:06,210 --> 00:04:10,045
Puis à la fin de la ligne que nous imprimons une
seule nouvelle ligne pour aller à la ligne suivante.

88
00:04:10,045 --> 00:04:11,420
Et voilà pour l'ensemble de la grille.

89
00:04:11,420 --> 00:04:12,810

90
00:04:12,810 --> 00:04:13,675
>> Question huit.

91
00:04:13,675 --> 00:04:17,170
Une fonction comme PrintGrid est dit
avoir un effet secondaire, mais pas un retour

92
00:04:17,170 --> 00:04:17,670
valeur.

93
00:04:17,670 --> 00:04:19,209
Expliquer la distinction.

94
00:04:19,209 --> 00:04:23,080
Donc, ce compte sur vous souvenir
ce un effet secondaire est.

95
00:04:23,080 --> 00:04:25,180
Eh bien, un retour value--
nous savons PrintGrid ne

96
00:04:25,180 --> 00:04:28,180
avoir une valeur de retour, depuis
ici il est dit nulle.

97
00:04:28,180 --> 00:04:31,150
Donc, tout ce qui retourne void
ne vraiment rien retourne pas.

98
00:04:31,150 --> 00:04:32,200

99
00:04:32,200 --> 00:04:33,620
Alors, quel est l'effet secondaire?

100
00:04:33,620 --> 00:04:36,620
Eh bien, un effet secondaire est
tout ce qui persiste sorte de

101
00:04:36,620 --> 00:04:39,500
après la fin de la fonction
qui était non seulement retourné,

102
00:04:39,500 --> 00:04:41,340
et il n'a pas été seulement des entrées.

103
00:04:41,340 --> 00:04:44,970
>> Ainsi, par exemple, nous pourrions
changer une variable globale.

104
00:04:44,970 --> 00:04:46,590
Ce serait un effet secondaire.

105
00:04:46,590 --> 00:04:49,000
Dans ce cas particulier, un
effet très important de côté

106
00:04:49,000 --> 00:04:51,070
est l'impression à l'écran.

107
00:04:51,070 --> 00:04:53,110
Ce qui est un effet secondaire
qui a PrintGrid.

108
00:04:53,110 --> 00:04:54,980
Nous imprimons ces choses à l'écran.

109
00:04:54,980 --> 00:04:56,370
Et vous pouvez penser
que comme un effet secondaire,

110
00:04:56,370 --> 00:04:58,690
depuis que ya quelque chose qui
persiste après la fin de cette fonction.

111
00:04:58,690 --> 00:05:01,481
Voilà quelque chose en dehors du champ d'application
de cette fonction qui en fin de compte

112
00:05:01,481 --> 00:05:03,380
est modifiée, la
contenu de l'écran.

113
00:05:03,380 --> 00:05:05,200

114
00:05:05,200 --> 00:05:05,839
>> Question neuf.

115
00:05:05,839 --> 00:05:07,880
Considérons le programme ci-dessous,
dans laquelle les numéros de ligne

116
00:05:07,880 --> 00:05:09,740
ont été ajoutées pour
l'intérêt de la discussion.

117
00:05:09,740 --> 00:05:13,480
Donc, dans ce programme, nous sommes juste
appelant GetString, stocker

118
00:05:13,480 --> 00:05:16,220
Dans cette variable s, puis
imprimer cette variable s.

119
00:05:16,220 --> 00:05:16,720
D'accord.

120
00:05:16,720 --> 00:05:19,090
Donc expliquer pourquoi une ligne est présent.

121
00:05:19,090 --> 00:05:20,920
#include CS50 point h.

122
00:05:20,920 --> 00:05:23,820
Pourquoi devons-nous #include CS50 point h?

123
00:05:23,820 --> 00:05:26,180
Bien que nous appelons la
Fonction GetString,

124
00:05:26,180 --> 00:05:28,840
et GetString est définie
dans la bibliothèque de CS50.

125
00:05:28,840 --> 00:05:31,600
Donc, si nous ne disposions pas
#include CS50 point h,

126
00:05:31,600 --> 00:05:35,760
nous obtiendrions cette déclaration implicite
de l'erreur de la fonction de GetString

127
00:05:35,760 --> 00:05:36,840
du compilateur.

128
00:05:36,840 --> 00:05:40,110
Donc, nous devons inclure le library--
nous devons inclure le fichier d'en-tête,

129
00:05:40,110 --> 00:05:42,870
ou bien le compilateur ne sera pas
reconnaître que GetString existe.

130
00:05:42,870 --> 00:05:44,380

131
00:05:44,380 --> 00:05:46,140
>> Expliquez pourquoi la deuxième ligne est présent.

132
00:05:46,140 --> 00:05:47,890
Alors norme io point h.

133
00:05:47,890 --> 00:05:50,430
Il est exactement le même
que le problème précédent,

134
00:05:50,430 --> 00:05:53,310
sauf qu'au lieu de traiter avec
GetString, nous parlons printf.

135
00:05:53,310 --> 00:05:56,654
Donc, si nous ne disions pas que nous devons
d'inclure norme io point h,

136
00:05:56,654 --> 00:05:58,820
alors nous ne serions pas en mesure
d'utiliser la fonction printf,

137
00:05:58,820 --> 00:06:00,653
parce que le compilateur
serait pas au courant.

138
00:06:00,653 --> 00:06:01,750

139
00:06:01,750 --> 00:06:05,260
>> Pourquoi-- quelle est la signification
de plein droit dans la ligne quatre?

140
00:06:05,260 --> 00:06:08,010
Nous avons donc ici int main (void).

141
00:06:08,010 --> 00:06:10,600
Cela juste dire que nous
ne reçoivent pas une ligne de commande

142
00:06:10,600 --> 00:06:12,280
arguments de main.

143
00:06:12,280 --> 00:06:17,390
Rappelez-vous que nous pourrions dire int
principaux int argc parenthèses chaîne de argv.

144
00:06:17,390 --> 00:06:20,400
Donc, ici, nous disons simplement vide à nous dire
sont ignorant les arguments de ligne de commande.

145
00:06:20,400 --> 00:06:21,840

146
00:06:21,840 --> 00:06:25,225
>> Expliquer, par rapport à la mémoire, exactement
ce GetString en ligne six retours.

147
00:06:25,225 --> 00:06:27,040

148
00:06:27,040 --> 00:06:31,640
GetString revient un bloc de
mémoire, un tableau de caractères.

149
00:06:31,640 --> 00:06:34,870
Il est vraiment un retour
pointeur sur le premier caractère.

150
00:06:34,870 --> 00:06:37,170
Rappelez-vous qu'une chaîne est une étoile char.

151
00:06:37,170 --> 00:06:41,360
Donc, s est un pointeur vers le premier
caractère quelle que soit la chaîne est

152
00:06:41,360 --> 00:06:43,510
que l'utilisateur a entré au clavier.

153
00:06:43,510 --> 00:06:47,070
Et que la mémoire arrive à être malloced,
de sorte que la mémoire est dans le tas.

154
00:06:47,070 --> 00:06:49,080

155
00:06:49,080 --> 00:06:50,450
>> Question 13.

156
00:06:50,450 --> 00:06:51,960
Considérons le programme ci-dessous.

157
00:06:51,960 --> 00:06:55,579
Donc, tout ce programme est fait
printf est-ing 1 divisé par 10.

158
00:06:55,579 --> 00:06:57,370
Donc, lors de la compilation et
exécuté, ce programme

159
00:06:57,370 --> 00:07:01,170
sorties 0.0, même si
1 divisé par 10 est de 0,1.

160
00:07:01,170 --> 00:07:02,970
Alors, pourquoi est-il 0.0?

161
00:07:02,970 --> 00:07:05,510
Eh bien, cela est parce que
de division entier.

162
00:07:05,510 --> 00:07:08,580
Ainsi, la figure 1 est un nombre entier, la figure 10 est un nombre entier.

163
00:07:08,580 --> 00:07:11,980
Donc 1 divisé par 10, tout
est traité comme des entiers,

164
00:07:11,980 --> 00:07:16,380
et en C, quand nous faisons la division entière,
on tronque tout point décimal.

165
00:07:16,380 --> 00:07:19,590
Donc 1 divisé par 10 est
0, et puis nous essayons

166
00:07:19,590 --> 00:07:24,410
d'imprimer que comme un flotteur, de sorte
zéro imprimé comme un flotteur est 0.0.

167
00:07:24,410 --> 00:07:27,400
Et voilà pourquoi nous obtenons 0.0.

168
00:07:27,400 --> 00:07:28,940
>> Considérons le programme ci-dessous.

169
00:07:28,940 --> 00:07:31,280
Nous l'impression maintenant de 0,1.

170
00:07:31,280 --> 00:07:34,280
Donc, pas de division entière,
nous sommes juste l'impression de 0,1,

171
00:07:34,280 --> 00:07:37,100
mais nous imprimer
à 28 décimales.

172
00:07:37,100 --> 00:07:41,810
Et nous obtenons ce 0.1000, tout un tas
de zéros, 5 5 5, bla bla bla.

173
00:07:41,810 --> 00:07:45,495
Donc la question est de savoir pourquoi il ne
imprimer que, au lieu de 0,1 exactement?

174
00:07:45,495 --> 00:07:46,620

175
00:07:46,620 --> 00:07:49,640
>> Donc, la raison est ici maintenant
virgule flottante imprécision.

176
00:07:49,640 --> 00:07:53,410
Rappelez-vous qu'un flotteur est à seulement 32 bits.

177
00:07:53,410 --> 00:07:57,540
Nous ne pouvons donc représenter un nombre fini
de valeurs à virgule flottante avec ceux 32

178
00:07:57,540 --> 00:07:58,560
bits.

179
00:07:58,560 --> 00:08:01,760
Eh bien il ya finalement infiniment
de nombreuses valeurs à virgule flottante,

180
00:08:01,760 --> 00:08:04,940
et il ya une infinité de flottant
les valeurs de point de entre 0 et 1,

181
00:08:04,940 --> 00:08:07,860
et nous sommes évidemment en mesure de
représenter encore plus de valeurs que cela.

182
00:08:07,860 --> 00:08:13,230
Donc, nous devons faire des sacrifices pour
être en mesure de représenter la plupart des valeurs.

183
00:08:13,230 --> 00:08:16,960
>> Ainsi, une valeur comme 0.1, apparemment
nous ne pouvons pas représenter exactement ce que.

184
00:08:16,960 --> 00:08:22,500
Ainsi, au lieu de représenter 0,1 nous faisons le
mieux que nous pouvons représenter cette 0.100000 5 5

185
00:08:22,500 --> 00:08:23,260
5.

186
00:08:23,260 --> 00:08:26,306
Et qui est assez proche, mais
pour un grand nombre d'applications

187
00:08:26,306 --> 00:08:28,430
vous avez à vous soucier de
Point imprécision flottant,

188
00:08:28,430 --> 00:08:30,930
parce que nous ne pouvons pas représenter
tous les points flottant exactement.

189
00:08:30,930 --> 00:08:32,500

190
00:08:32,500 --> 00:08:33,380
>> Question 15.

191
00:08:33,380 --> 00:08:34,679
Considérons le code ci-dessous.

192
00:08:34,679 --> 00:08:36,630
Nous sommes en train d'imprimer 1 plus 1.

193
00:08:36,630 --> 00:08:38,289
Il n'y a donc pas de truc ici.

194
00:08:38,289 --> 00:08:41,780
1 plus 1 évalue à 2, et
puis nous l'impression que.

195
00:08:41,780 --> 00:08:42,789
Cette affiche seulement 2.

196
00:08:42,789 --> 00:08:43,850

197
00:08:43,850 --> 00:08:44,700
>> Question 16.

198
00:08:44,700 --> 00:08:49,450
Maintenant, nous sommes l'impression du caractère
1 plus le caractère 1.

199
00:08:49,450 --> 00:08:52,110
Alors, pourquoi ne pas ce
imprimer la même chose?

200
00:08:52,110 --> 00:08:57,680
Eh bien le caractère 1 plus le caractère
1, le personnage a une valeur ASCII 49.

201
00:08:57,680 --> 00:09:04,840
Donc, ce qui est vraiment dit, plus de 49 49, et
finalement cela va imprimer 98.

202
00:09:04,840 --> 00:09:06,130
Donc, ce ne pas imprimer 2.

203
00:09:06,130 --> 00:09:08,070

204
00:09:08,070 --> 00:09:09,271
>> Question 17.

205
00:09:09,271 --> 00:09:11,520
Compléter la mise en œuvre
impair de dessous de telle manière

206
00:09:11,520 --> 00:09:14,615
que la fonction renvoie vrai si
n est impair et faux si n est pair.

207
00:09:14,615 --> 00:09:16,710

208
00:09:16,710 --> 00:09:19,330
Ceci est un grand dessein
pour l'opérateur mod.

209
00:09:19,330 --> 00:09:24,530
Donc, nous prenons notre argument n,
si n mod 2 est égal à 1, et

210
00:09:24,530 --> 00:09:28,030
cela signifie que n divise
par 2 avait un solde.

211
00:09:28,030 --> 00:09:33,270
Si n divisé par 2 eu un reste, que
signifie que n est impair, alors nous retourner vrai.

212
00:09:33,270 --> 00:09:34,910
Sinon nous retournons faux.

213
00:09:34,910 --> 00:09:39,070
Vous pouvez aussi avez fait n mod 2 égaux
zéro, return false, sinon retourne vrai.

214
00:09:39,070 --> 00:09:41,600

215
00:09:41,600 --> 00:09:43,640
>> Considérons la fonction récursive ci-dessous.

216
00:09:43,640 --> 00:09:46,920
Donc, si n est inférieur ou
égale à 1, renvoie 1,

217
00:09:46,920 --> 00:09:50,430
d'autre retour n fois f de n moins 1.

218
00:09:50,430 --> 00:09:52,556
Alors, quelle est cette fonction?

219
00:09:52,556 --> 00:09:54,305
Eh bien, ceci est juste le
fonction factorielle.

220
00:09:54,305 --> 00:09:55,410

221
00:09:55,410 --> 00:09:57,405
Ceci est bien représenté
comme factorielle de n.

222
00:09:57,405 --> 00:09:58,720

223
00:09:58,720 --> 00:10:02,310
>> Donc, la question 19 maintenant, nous voulons
prendre cette fonction récursive.

224
00:10:02,310 --> 00:10:04,530
Nous voulons qu'il soit itératif.

225
00:10:04,530 --> 00:10:05,874
Alors, comment faisons-nous cela?

226
00:10:05,874 --> 00:10:07,790
Eh bien pour le personnel
solution, et encore, il est

227
00:10:07,790 --> 00:10:11,090
de multiples façons vous auriez pu faire
que, nous commençons avec ce produit int

228
00:10:11,090 --> 00:10:11,812
est égal à 1.

229
00:10:11,812 --> 00:10:13,520
Et tout au long de cette
pour la boucle, nous allons

230
00:10:13,520 --> 00:10:17,590
à multiplier produit en fin de compte à
finir avec le factoriel complet.

231
00:10:17,590 --> 00:10:21,870
Donc, pour int i est égal à 2, i est
inférieur ou égal à n, i ++.

232
00:10:21,870 --> 00:10:24,130
>> Vous pourriez vous demander pourquoi i est égal à 2.

233
00:10:24,130 --> 00:10:28,380
Eh bien, rappelez-vous que nous avons ici à
assurez-vous que notre scénario de base est correcte.

234
00:10:28,380 --> 00:10:32,180
Donc, si n est inférieur ou égal
à 1, nous sommes juste de retour 1.

235
00:10:32,180 --> 00:10:34,830
Donc, ici, nous commençons à i est égal à 2.

236
00:10:34,830 --> 00:10:39,090
Eh bien, si je devais 1, puis the-- ou
si n étaient 1, puis la boucle

237
00:10:39,090 --> 00:10:40,600
ne serait pas exécuter du tout.

238
00:10:40,600 --> 00:10:43,190
Et si nous irions
retour de produit, qui est de 1.

239
00:10:43,190 --> 00:10:45,920
De même, si n était
rien de moins que 1--

240
00:10:45,920 --> 00:10:49,290
si elle était 0, 1 négatif, whatever--
nous serions encore connus 1,

241
00:10:49,290 --> 00:10:52,260
qui est exactement ce que le
Version récursive fait.

242
00:10:52,260 --> 00:10:54,660
>> Maintenant, si n est supérieur
à 1, alors nous allons

243
00:10:54,660 --> 00:10:56,550
à faire au moins un
itération de cette boucle.

244
00:10:56,550 --> 00:11:00,630
Donc, disons que n est 5, alors nous sommes
va faire des temps de produit est égal à 2.

245
00:11:00,630 --> 00:11:02,165
Alors maintenant, est produit 2.

246
00:11:02,165 --> 00:11:04,040
Maintenant, nous allons faire
temps de produits est égal à trois.

247
00:11:04,040 --> 00:11:04,690
Maintenant, il est 6.

248
00:11:04,690 --> 00:11:07,500
fois du produit est égal à 4, il est maintenant 24.

249
00:11:07,500 --> 00:11:10,420
fois du produit est égal à 5, il est maintenant de 120.

250
00:11:10,420 --> 00:11:16,730
Alors en fin de compte, nous sommes de retour
120, qui est correctement 5 factorielle.

251
00:11:16,730 --> 00:11:17,510
>> Question 20.

252
00:11:17,510 --> 00:11:22,480
Ceci est celle où vous devez remplir
dans ce tableau avec un algorithme donné,

253
00:11:22,480 --> 00:11:25,735
tout ce que nous avons vu, que
répond à ces parcours algorithmique

254
00:11:25,735 --> 00:11:28,060
fois ces des temps d'exécution asymptotique.

255
00:11:28,060 --> 00:11:33,270
Alors, quel est un algorithme qui
est l'oméga de 1, mais grand O de n?

256
00:11:33,270 --> 00:11:35,970
Il pourrait donc y être infiniment
beaucoup de réponses ici.

257
00:11:35,970 --> 00:11:39,790
Celui que nous avons vu probablement plus
est souvent juste une recherche linéaire.

258
00:11:39,790 --> 00:11:42,050
>> Donc, dans le meilleur des cas
scénario, l'article nous sommes

259
00:11:42,050 --> 00:11:44,050
cherche est à la
au début de la liste

260
00:11:44,050 --> 00:11:47,400
et donc en oméga de 1 étapes,
la première chose que nous vérifions,

261
00:11:47,400 --> 00:11:49,740
nous revenons juste immédiatement
que nous avons trouvé l'article.

262
00:11:49,740 --> 00:11:52,189
Dans le pire des cas,
l'article se trouve à la fin,

263
00:11:52,189 --> 00:11:53,730
ou l'article est pas dans la liste du tout.

264
00:11:53,730 --> 00:11:56,700
Nous devons donc rechercher
la liste entière, tout n

265
00:11:56,700 --> 00:11:58,480
éléments, et qui est pourquoi il est o n.

266
00:11:58,480 --> 00:11:59,670

267
00:11:59,670 --> 00:12:04,880
>> Alors maintenant, il est quelque chose qui est à la fois
oméga de n log n, et grand O de n log n.

268
00:12:04,880 --> 00:12:08,650
Eh bien la chose la plus pertinente
nous avons vu ici est le tri par fusion.

269
00:12:08,650 --> 00:12:12,950
Donc, le tri par fusion, rappelez-vous,
Theta est en fin de compte

270
00:12:12,950 --> 00:12:16,920
de n log n, où thêta est défini
si les deux oméga et grand O sont les mêmes.

271
00:12:16,920 --> 00:12:17,580
Les deux n log n.

272
00:12:17,580 --> 00:12:18,690

273
00:12:18,690 --> 00:12:21,970
>> Qu'est-ce quelque chose qui est oméga
de n, et n au carré de O?

274
00:12:21,970 --> 00:12:23,990
Eh bien, encore une fois il ya
plusieurs réponses possibles.

275
00:12:23,990 --> 00:12:26,440
Ici nous nous trouvons à dire tri à bulles.

276
00:12:26,440 --> 00:12:28,840
Le tri par insertion serait également travailler ici.

277
00:12:28,840 --> 00:12:31,400
Rappelez-vous que tri à bulles
où a que l'optimisation,

278
00:12:31,400 --> 00:12:34,630
si vous êtes en mesure d'obtenir
toute la liste

279
00:12:34,630 --> 00:12:37,402
sans avoir à faire
des swaps, alors, eh bien,

280
00:12:37,402 --> 00:12:40,110
nous pouvons retourner immédiatement que
la liste a été triée pour commencer.

281
00:12:40,110 --> 00:12:43,185
Ainsi, dans le meilleur des cas,
il est juste oméga de n.

282
00:12:43,185 --> 00:12:45,960
Si il est pas seulement un bien
liste pour commencer à trier,

283
00:12:45,960 --> 00:12:48,270
puis nous avons O n carré swaps.

284
00:12:48,270 --> 00:12:49,330

285
00:12:49,330 --> 00:12:55,610
Et enfin, nous avons sorte sélection
pour n au carré, à la fois grand et oméga O.

286
00:12:55,610 --> 00:12:56,850
>> Question 21.

287
00:12:56,850 --> 00:12:58,870
Qu'est-ce débordement d'entier?

288
00:12:58,870 --> 00:13:02,160
Eh bien encore une fois, même à l'heure,
nous avons seulement un nombre fini de bits

289
00:13:02,160 --> 00:13:04,255
pour représenter un nombre entier,
Alors peut-être 32 bits.

290
00:13:04,255 --> 00:13:06,300

291
00:13:06,300 --> 00:13:09,180
Disons que nous avons un entier signé.

292
00:13:09,180 --> 00:13:12,800
Puis, en fin de compte le plus élevé
nombre positif, nous pouvons représenter

293
00:13:12,800 --> 00:13:15,910
2 est au 31 moins 1.

294
00:13:15,910 --> 00:13:19,370
Donc ce qui arrive si nous essayons de
puis incrémenter que entier?

295
00:13:19,370 --> 00:13:25,320
Eh bien, nous allons aller de 2 à 31
moins 1, tout en bas de négatif 2

296
00:13:25,320 --> 00:13:26,490
à la 31.

297
00:13:26,490 --> 00:13:29,470
Donc, ce débordement d'entier est
quand vous gardez l'incrémentation,

298
00:13:29,470 --> 00:13:32,330
et, finalement, vous ne pouvez pas
obtenir de plus et il vient

299
00:13:32,330 --> 00:13:34,520
enveloppe tout le chemin du retour
autour d'une valeur négative.

300
00:13:34,520 --> 00:13:35,850

301
00:13:35,850 --> 00:13:37,779
>> Qu'en est-il un débordement de tampon?

302
00:13:37,779 --> 00:13:39,820
Ainsi, un tampon overflow--
rappelez-vous ce qu'est un tampon est.

303
00:13:39,820 --> 00:13:41,000
Il est juste un morceau de mémoire.

304
00:13:41,000 --> 00:13:43,350
Quelque chose comme un tableau est un tampon.

305
00:13:43,350 --> 00:13:46,120
Ainsi, un débordement de tampon est quand
vous essayez d'accéder à la mémoire

306
00:13:46,120 --> 00:13:47,880
au-delà de la fin de ce tableau.

307
00:13:47,880 --> 00:13:50,410
Donc si vous avez un
tableau de taille 5 et vous

308
00:13:50,410 --> 00:13:53,700
tenter d'accéder support de tableau
5 ou 6 étrier ou support 7,

309
00:13:53,700 --> 00:13:56,610
ou quoi que ce soit au-delà de la
fin, ou même quoi que ce soit

310
00:13:56,610 --> 00:14:00,790
support de tableau below-- négatif 1--
tous ceux qui sont les débordements de tampon.

311
00:14:00,790 --> 00:14:02,810
Vous touchez mémoire dans de mauvaises manières.

312
00:14:02,810 --> 00:14:04,090

313
00:14:04,090 --> 00:14:04,730
>> Question 23.

314
00:14:04,730 --> 00:14:05,760

315
00:14:05,760 --> 00:14:09,100
Donc, dans ce dont vous avez besoin
à mettre en oeuvre strlen.

316
00:14:09,100 --> 00:14:11,630
Et nous vous disons que vous pouvez
Supposons s ne sera pas nulle,

317
00:14:11,630 --> 00:14:13,790
de sorte que vous ne devez pas
faire un chèque pour nulle.

318
00:14:13,790 --> 00:14:16,190
Et il ya de multiples façons
vous auriez pu faire cela.

319
00:14:16,190 --> 00:14:18,440
Ici, nous prenons juste le simple.

320
00:14:18,440 --> 00:14:21,780
Nous commençons avec un compteur, n. n est égal à
comptent le nombre de caractères y sont.

321
00:14:21,780 --> 00:14:25,560
Nous commençons donc à 0, puis nous
parcourir la liste entière.

322
00:14:25,560 --> 00:14:29,092
>> Est de support 0 égale à la
caractère de terminaison nulle?

323
00:14:29,092 --> 00:14:31,425
Rappelez-vous que nous recherchons
le caractère de terminaison null

324
00:14:31,425 --> 00:14:33,360
pour déterminer combien de temps notre chaîne est.

325
00:14:33,360 --> 00:14:35,890
Cela va mettre fin à
toute chaîne concernée.

326
00:14:35,890 --> 00:14:39,400
Il en est de s support 0 égal
à la terminaison nulle?

327
00:14:39,400 --> 00:14:42,850
Si il est pas, alors nous allons
regarder de support 1, de support 2.

328
00:14:42,850 --> 00:14:45,050
Nous continuons jusqu'à ce que nous
trouver la terminaison nulle.

329
00:14:45,050 --> 00:14:48,580
Une fois que nous l'avons trouvé, alors n contient
la longueur totale de la chaîne,

330
00:14:48,580 --> 00:14:49,942
et nous ne pouvons tout simplement le retourner.

331
00:14:49,942 --> 00:14:51,180

332
00:14:51,180 --> 00:14:51,865
>> Question 24.

333
00:14:51,865 --> 00:14:53,010

334
00:14:53,010 --> 00:14:56,050
Donc ceci est celui où vous
avoir à faire le compromis.

335
00:14:56,050 --> 00:14:59,810
Donc, une chose est bonne dans un
manière, mais en quoi est-ce mauvais?

336
00:14:59,810 --> 00:15:02,980
Donc, ici, fusionner tend sorte à
être plus rapide que tri à bulles.

337
00:15:02,980 --> 00:15:06,530
Cela dit that-- bien, il
sont multiples réponses ici.

338
00:15:06,530 --> 00:15:12,930
Mais le principal est que la bulle sorte
est l'oméga de n pour une liste triée.

339
00:15:12,930 --> 00:15:14,950
>> Rappelez-vous que la table nous venons de le voir plus tôt.

340
00:15:14,950 --> 00:15:17,600
Donc bulle trie oméga de
n, le meilleur scénario

341
00:15:17,600 --> 00:15:20,010
est qu'il est capable d'aller un peu plus
la liste une fois, déterminer

342
00:15:20,010 --> 00:15:22,270
hey cette chose est déjà
triés, et retour.

343
00:15:22,270 --> 00:15:25,960
Tri par fusion, peu importe ce que
vous le faites, est l'oméga de n log n.

344
00:15:25,960 --> 00:15:29,200
Donc, pour la liste triée, bulle
Trier va être plus rapide.

345
00:15:29,200 --> 00:15:30,870

346
00:15:30,870 --> 00:15:32,430
>> Maintenant, qu'en est-il des listes chaînées?

347
00:15:32,430 --> 00:15:36,070
Ainsi, une liste chaînée peut grandir et rétrécir
à adapter autant d'éléments que nécessaire.

348
00:15:36,070 --> 00:15:38,489
Cela dit si that--
généralement la comparaison directe

349
00:15:38,489 --> 00:15:40,280
va être un lien
la liste avec un tableau.

350
00:15:40,280 --> 00:15:41,600

351
00:15:41,600 --> 00:15:44,050
Ainsi, même si les tableaux ne peuvent
facilement grandir et rétrécir

352
00:15:44,050 --> 00:15:47,130
à adapter autant d'éléments
au besoin, une liste chaînée

353
00:15:47,130 --> 00:15:49,600
par rapport à une une de array--
tableau a accès aléatoire.

354
00:15:49,600 --> 00:15:52,960
Nous pouvons en tout indice
élément particulier de la matrice.

355
00:15:52,960 --> 00:15:56,430
>> Donc, pour une liste chaînée, nous ne pouvons pas
suffit d'aller sur le cinquième élément,

356
00:15:56,430 --> 00:16:00,260
il faut parcourir depuis le début
jusqu'à ce que nous arrivons à la cinquième élément.

357
00:16:00,260 --> 00:16:03,990
Et cela va nous empêcher de
faire quelque chose comme la recherche binaire.

358
00:16:03,990 --> 00:16:08,150
Parlant de recherche binaire, binaire de recherche
tend à être plus rapide que la recherche linéaire.

359
00:16:08,150 --> 00:16:11,120
Cela dit that--
si, une chose possible

360
00:16:11,120 --> 00:16:13,380
est que vous ne pouvez pas faire binaire
rechercher sur les listes chaînées,

361
00:16:13,380 --> 00:16:14,730
vous ne pouvez le faire sur des tableaux.

362
00:16:14,730 --> 00:16:18,030
Mais sans doute plus important encore,
vous ne pouvez pas faire une recherche binaire

363
00:16:18,030 --> 00:16:20,690
sur un tableau qui ne sont pas triées.

364
00:16:20,690 --> 00:16:23,990
Upfront vous pourriez avoir besoin pour trier
le tableau, et alors seulement, peut

365
00:16:23,990 --> 00:16:25,370
vous faites une recherche binaire.

366
00:16:25,370 --> 00:16:27,660
Donc, si votre truc est pas
triés pour commencer,

367
00:16:27,660 --> 00:16:29,250
puis recherche linéaire peut être plus rapide.

368
00:16:29,250 --> 00:16:30,620

369
00:16:30,620 --> 00:16:31,740
>> Question 27.

370
00:16:31,740 --> 00:16:34,770
Ainsi, considérer le programme ci-dessous,
qui sera dans la diapositive suivante.

371
00:16:34,770 --> 00:16:37,790
Et cela est celui où nous sommes
allez vouloir indiquer explicitement

372
00:16:37,790 --> 00:16:39,980
les valeurs de certaines variables.

373
00:16:39,980 --> 00:16:41,990
Alors regardons cela.

374
00:16:41,990 --> 00:16:43,160
>> Donc, une seule ligne.

375
00:16:43,160 --> 00:16:45,457
Nous avons int x est égal à 1.

376
00:16:45,457 --> 00:16:47,040
Voilà la seule chose qui est arrivé.

377
00:16:47,040 --> 00:16:50,440
Donc, à la ligne une, nous voyons dans notre
table, que y, a, b, et sont tous tmp

378
00:16:50,440 --> 00:16:51,540
noirci.

379
00:16:51,540 --> 00:16:52,280
Alors, quelle est x?

380
00:16:52,280 --> 00:16:53,860
Eh bien, nous venons de mettre ce égal à 1.

381
00:16:53,860 --> 00:16:55,020

382
00:16:55,020 --> 00:16:58,770
Et puis la deuxième ligne, eh bien,
on voit que y a la valeur 2,

383
00:16:58,770 --> 00:17:00,550
et la table est déjà
rempli pour nous.

384
00:17:00,550 --> 00:17:03,040
Ainsi, x est 1 et y est égal à 2.

385
00:17:03,040 --> 00:17:05,890
>> Maintenant, la troisième ligne, nous sommes maintenant
à l'intérieur de la fonction d'échange.

386
00:17:05,890 --> 00:17:07,560
Qu'avons-nous passons à échanger?

387
00:17:07,560 --> 00:17:11,609
Nous avons passé esperluette x pour
un, et esperluette y pour b.

388
00:17:11,609 --> 00:17:15,160
Lorsque le problème plus tôt
déclaré que l'adresse de x

389
00:17:15,160 --> 00:17:17,520
est 0x10, et l'adresse de y est 0x14.

390
00:17:17,520 --> 00:17:18,970

391
00:17:18,970 --> 00:17:21,909
Ainsi, a et b sont égaux à
0x10 0x14 et, respectivement.

392
00:17:21,909 --> 00:17:23,670

393
00:17:23,670 --> 00:17:26,250
>> Maintenant, à la ligne de trois, ce sont X et Y?

394
00:17:26,250 --> 00:17:28,554
Eh bien, rien n'a changé
sur X et Y à ce point.

395
00:17:28,554 --> 00:17:30,470
Même si elles sont
l'intérieur d'un cadre de pile principale,

396
00:17:30,470 --> 00:17:32,469
ils ont toujours le même
valeurs qu'ils ont fait avant.

397
00:17:32,469 --> 00:17:34,030
Nous avons modifié aucun mémoire.

398
00:17:34,030 --> 00:17:35,710
Ainsi, x est 1, y est égal à 2.

399
00:17:35,710 --> 00:17:36,550

400
00:17:36,550 --> 00:17:37,050
Bien.

401
00:17:37,050 --> 00:17:40,300
Alors maintenant, nous l'avons dit int tmp égale à jouer un.

402
00:17:40,300 --> 00:17:44,410
Ainsi, à la quatrième ligne, tout
est la même, sauf pour tmp.

403
00:17:44,410 --> 00:17:47,130
Nous avons pas changé les valeurs
de quoi que ce soit sauf pour tmp.

404
00:17:47,130 --> 00:17:49,230
Nous sommes en train de tmp égale à jouer un.

405
00:17:49,230 --> 00:17:50,620
Quel est l'étoile un?

406
00:17:50,620 --> 00:17:56,240
Eh bien, un des points de X, donc étoile à
va à l'égalité de x, qui est de 1.

407
00:17:56,240 --> 00:18:00,080
Donc, tout est copié
vers le bas, et tmp est mis à 1.

408
00:18:00,080 --> 00:18:01,110
>> Maintenant, la ligne suivante.

409
00:18:01,110 --> 00:18:03,380
Star une égale étoiles b.

410
00:18:03,380 --> 00:18:10,000
Ainsi, en ligne five-- bien encore tout,
est la même quel que soit l'exception étoiles est un.

411
00:18:10,000 --> 00:18:10,830
Quel est l'étoile un?

412
00:18:10,830 --> 00:18:13,720
Eh bien, nous venons de dire est une étoile x.

413
00:18:13,720 --> 00:18:16,400
Nous allons donc changer x à l'égalité étoiles b.

414
00:18:16,400 --> 00:18:18,960
Quel est l'étoile b? y. b des points à y.

415
00:18:18,960 --> 00:18:21,030
Donc étoiles b est y.

416
00:18:21,030 --> 00:18:25,140
Donc, nous posant x égal à y,
et tout le reste est le même.

417
00:18:25,140 --> 00:18:29,130
Ainsi, nous voyons dans la rangée suivante que x est maintenant
2, et le reste est juste copié vers le bas.

418
00:18:29,130 --> 00:18:31,120
>> Maintenant, dans la ligne suivante, étoile b est égale à tmp.

419
00:18:31,120 --> 00:18:34,740
Eh bien, nous venons de dire étoile b est y,
si nous mettons en y égale à tmp.

420
00:18:34,740 --> 00:18:37,450
Tout le reste est le même,
donc tout est copié vers le bas.

421
00:18:37,450 --> 00:18:42,050
Nous mettons en y égal au TMP, qui est
une, et tout le reste est le même.

422
00:18:42,050 --> 00:18:43,210
>> Maintenant, enfin, la septième ligne.

423
00:18:43,210 --> 00:18:44,700
Nous sommes de retour dans la fonction principale.

424
00:18:44,700 --> 00:18:46,350
Nous sommes après swap est terminé.

425
00:18:46,350 --> 00:18:48,972
Nous avons perdu un, b, et
tmp, mais finalement nous

426
00:18:48,972 --> 00:18:51,180
ne sont pas modifier les valeurs
de quoi que ce soit à ce point,

427
00:18:51,180 --> 00:18:52,800
nous copions tout x et y descendre.

428
00:18:52,800 --> 00:18:56,490
Et l'on voit que x et y sont
maintenant 2 et 1 au lieu de 1 et 2.

429
00:18:56,490 --> 00:18:58,160
Le swap a exécuté avec succès.

430
00:18:58,160 --> 00:18:59,500

431
00:18:59,500 --> 00:19:00,105
>> Question 28.

432
00:19:00,105 --> 00:19:01,226

433
00:19:01,226 --> 00:19:03,100
Supposons que vous rencontrez
les messages d'erreur

434
00:19:03,100 --> 00:19:06,790
ci-dessous aux heures de bureau
l'année prochaine, un CA ou TF.

435
00:19:06,790 --> 00:19:08,930
Conseiller sur la façon de fixer chacune de ces erreurs.

436
00:19:08,930 --> 00:19:11,160
Donc référence définie à GetString.

437
00:19:11,160 --> 00:19:12,540
Pourquoi pourriez-vous voir cela?

438
00:19:12,540 --> 00:19:15,380
Eh bien, si un élève utilise
GetString dans leur code,

439
00:19:15,380 --> 00:19:20,310
ils ont bien compris hachage CS50
point h à inclure la bibliothèque CS50.

440
00:19:20,310 --> 00:19:22,380
>> Eh bien, qu'est-ce qu'ils
besoin de corriger cette erreur?

441
00:19:22,380 --> 00:19:26,810
Ils ont besoin de faire un lcs50 de bord à la
ligne de commande quand ils compilation.

442
00:19:26,810 --> 00:19:29,501
Donc, si ils ne passent pas
clang tiret lcs50, ils sont

443
00:19:29,501 --> 00:19:32,000
ne va pas avoir la réelle
code qui implémente GetString.

444
00:19:32,000 --> 00:19:33,190

445
00:19:33,190 --> 00:19:34,170
>> Question 29.

446
00:19:34,170 --> 00:19:36,190
Déclarant implicitement
fonction strlen bibliothèque.

447
00:19:36,190 --> 00:19:37,550

448
00:19:37,550 --> 00:19:40,360
Eh bien maintenant, ils ne l'ont pas
fait le bon hachage inclure.

449
00:19:40,360 --> 00:19:41,440

450
00:19:41,440 --> 00:19:45,410
Dans ce cas particulier, le fichier d'en-tête
ils ont besoin de comprendre est une chaîne point h,

451
00:19:45,410 --> 00:19:48,710
et comprenant le string point h, maintenant
la student-- maintenant le compilateur

452
00:19:48,710 --> 00:19:51,750
a accès à la
déclarations de strlen,

453
00:19:51,750 --> 00:19:54,120
et il sait que votre code
utilise correctement strlen.

454
00:19:54,120 --> 00:19:55,380

455
00:19:55,380 --> 00:19:56,580
>> Question 30.

456
00:19:56,580 --> 00:20:00,240
Plus de conversions pour cent
que des arguments de données.

457
00:20:00,240 --> 00:20:01,540
Alors qu'est-ce?

458
00:20:01,540 --> 00:20:06,470
Eh bien se rappeler que ceux-ci pour cent
signs-- comment elles sont pertinentes à printf.

459
00:20:06,470 --> 00:20:08,890
Ainsi, dans printf nous pourrions percent--
nous pourrions imprimer quelque chose

460
00:20:08,890 --> 00:20:11,380
comme pour cent i Backslash n.

461
00:20:11,380 --> 00:20:15,310
Ou nous pourrions imprimer comme pour cent i,
espace, pour cent i, l'espace, pour cent i.

462
00:20:15,310 --> 00:20:18,950
Ainsi, pour chacune de celles
signes de pourcentage, nous avons besoin

463
00:20:18,950 --> 00:20:21,560
passer une variable à la fin de printf.

464
00:20:21,560 --> 00:20:26,980
>> Donc, si nous disons parenthèse printf pour cent
i Backslash n proches parenthèse,

465
00:20:26,980 --> 00:20:30,270
bien, nous disons que nous sommes
va imprimer un nombre entier,

466
00:20:30,270 --> 00:20:33,970
mais nous ne transmettons pas printf
un nombre entier de fait imprimer.

467
00:20:33,970 --> 00:20:37,182
Donc, ici plus pour cent
conversions que les arguments de données?

468
00:20:37,182 --> 00:20:39,390
Cela disant que nous avons
tout un tas de pourcentages,

469
00:20:39,390 --> 00:20:42,445
et nous ne disposons pas assez de variables
pour réellement combler ces pourcentages.

470
00:20:42,445 --> 00:20:44,850

471
00:20:44,850 --> 00:20:50,010
>> Et puis définitivement, à la question 31,
certainement perdu 40 octets dans un des blocs.

472
00:20:50,010 --> 00:20:52,350
Donc, cela est une erreur Valgrind.

473
00:20:52,350 --> 00:20:54,720
Cela revient à dire que
quelque part dans votre code,

474
00:20:54,720 --> 00:20:59,010
vous avez une allocation qui est de 40
octets grand pour vous malloced 40 octets,

475
00:20:59,010 --> 00:21:00,515
et vous ne le libéra.

476
00:21:00,515 --> 00:21:02,480

477
00:21:02,480 --> 00:21:05,140
Très probablement, vous avez juste besoin
de trouver une fuite de mémoire,

478
00:21:05,140 --> 00:21:07,650
et de trouver où vous devez
libérer ce bloc de mémoire.

479
00:21:07,650 --> 00:21:08,780

480
00:21:08,780 --> 00:21:11,910
>> Et la question 32,
écriture invalide de taille 4.

481
00:21:11,910 --> 00:21:13,250
Encore une fois cela est une erreur Valgrind.

482
00:21:13,250 --> 00:21:15,440
Cela ne doit pas faire
avec des fuites de mémoire maintenant.

483
00:21:15,440 --> 00:21:20,750
Ceci est, plus likely-- Je veux dire, il est
une sorte de droit de mémoire non valide.

484
00:21:20,750 --> 00:21:23,270
Et plus probable que ce soit une certaine
sorte de dépassement de mémoire tampon.

485
00:21:23,270 --> 00:21:26,560
Où vous avez un tableau, peut-être
un tableau d'entiers, et nous allons

486
00:21:26,560 --> 00:21:30,115
dire qu'il est de taille 5, et vous
essayer de toucher tableau 5 support.

487
00:21:30,115 --> 00:21:34,150
Donc, si vous essayez d'écrire pour que
valeur, qui est pas un morceau de mémoire

488
00:21:34,150 --> 00:21:37,440
que vous avez réellement l'accès à, et
si vous allez obtenir cette erreur,

489
00:21:37,440 --> 00:21:39,272
disant écriture invalide de taille 4.

490
00:21:39,272 --> 00:21:42,480
Valgrind va reconnaître que vous êtes
en essayant de toucher la mémoire de façon inappropriée.

491
00:21:42,480 --> 00:21:43,980
>> Et voilà pour quiz0.

492
00:21:43,980 --> 00:21:47,065
Je suis Rob Bowden, et ceci est CS50.

493
00:21:47,065 --> 00:21:51,104