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

2
00:00:02,742 --> 00:00:05,680
>> ENCEINTE 1: Salut tout le monde.

3
00:00:05,680 --> 00:00:07,530
Nous allons commencer.

4
00:00:07,530 --> 00:00:09,330
Je pense que les gens sont toujours en cours
pour être en filtration.

5
00:00:09,330 --> 00:00:12,840
Mais dans l'intérêt de temps, afin que nous puissions
obtenir les gars d'ici à temps,

6
00:00:12,840 --> 00:00:14,110
nous allons commencer.

7
00:00:14,110 --> 00:00:18,780
Alors bienvenue à la CS50 Quiz 0 avis.

8
00:00:18,780 --> 00:00:23,020
Pour ceux d'entre vous qui n'ont pas réalisé
encore, vous avez une question mercredi.

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

10
00:00:25,700 --> 00:00:29,780
>> Si vous n'avez pas encore commencé à étudier ou
n'ont pas réalisé que cela existe encore,

11
00:00:29,780 --> 00:00:34,070
quiz passées et toutes les informations sur
votre quiz sont sur cs50.net/quizzes.

12
00:00:34,070 --> 00:00:38,090
Il ya des trucs assez bon là-bas,
quiz dernières de la dernière 10

13
00:00:38,090 --> 00:00:43,760
ans ainsi que des informations
sur ce quiz et sujets

14
00:00:43,760 --> 00:00:46,250
qui seront couverts.

15
00:00:46,250 --> 00:00:48,980
Donc, nous allons commencer.

16
00:00:48,980 --> 00:00:54,240
>> Alors vous avez peut-souvenir, le premier
jour de classe David avait ces lampes sur.

17
00:00:54,240 --> 00:00:59,650
Donc, essentiellement, tout ce qui va
sous le capot d'un ordinateur

18
00:00:59,650 --> 00:01:00,860
fait en binaire.

19
00:01:00,860 --> 00:01:04,080
Binaire signifie ce que cela
comme, 0 et de 1.

20
00:01:04,080 --> 00:01:09,290
Il dispose de deux valeurs que
peuvent être représentées.

21
00:01:09,290 --> 00:01:14,675
>> Ainsi, tout comme dans le premier jour de l'article
quand David allumé une lumière

22
00:01:14,675 --> 00:01:21,990
Ampoule pour représenter sur, ou 1, notre ordinateur
comprend binaire 0 et de

23
00:01:21,990 --> 00:01:24,110
De 1, allumé ou éteint.

24
00:01:24,110 --> 00:01:25,360
Notions de base binaire.

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

26
00:01:29,440 --> 00:01:32,470
Chaque lieu est représenté
en base deux.

27
00:01:32,470 --> 00:01:36,260
Donc, vous ajoutez 2 à 0 au
1 à 2 sur toute la hauteur.

28
00:01:36,260 --> 00:01:41,970
>> Pour calculer ce que votre binaire est de
décimal, il vous suffit de suivre cette équation

29
00:01:41,970 --> 00:01:42,840
ce genre de chose.

30
00:01:42,840 --> 00:01:49,510
Si vous avez un 1 dans l'un de ces endroits,
vous multipliez par quelque

31
00:01:49,510 --> 00:01:53,820
fonder c'est, ajoutez-le, et
vous obtenez la décimale.

32
00:01:53,820 --> 00:01:57,930
Voilà donc comment vous comptez
à 5 en binaire.

33
00:01:57,930 --> 00:02:01,400
Tout comme ce que nous faisions sur le
dernière diapositive, c'est la façon dont vous le feriez

34
00:02:01,400 --> 00:02:02,650
représenter de 1 à 5.

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

36
00:02:05,320 --> 00:02:09,660
>> De même, comme vous venez vous pouvez ajouter et
soustraire en décimal ou en base 10, ou

37
00:02:09,660 --> 00:02:13,040
vraiment n'importe quelle base, sur peut ajouter
et soustraire en binaire.

38
00:02:13,040 --> 00:02:18,400
Exactement ce que vous attendez lorsque vous
ajouter les deux jusqu'à, si elle est égale à une plus grande

39
00:02:18,400 --> 00:02:24,220
à 1, vous portez un 1, en font un 0,
et faire le plus de cette façon, juste

40
00:02:24,220 --> 00:02:29,910
comme on pourrait s'y attendre régulière
décimal ou toute autre base.

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

42
00:02:30,970 --> 00:02:35,140
>> Donc, comme je l'ai déjà dit, tout ce qui
qui se passe sous le capot de votre ordinateur

43
00:02:35,140 --> 00:02:37,560
se fait dans, ou binaire de 0 et de 1.

44
00:02:37,560 --> 00:02:43,470
Alors, comment pouvons-nous exprimer, par exemple,
lettres ou des chiffres, ou des caractères?

45
00:02:43,470 --> 00:02:45,560
Et la réponse à cette question est ASCII.

46
00:02:45,560 --> 00:02:49,380
>> ASCII est une correspondance entre caractères
que nous aurions normalement voir dans le

47
00:02:49,380 --> 00:02:53,360
Langue anglaise comme A, le B de,
C de, souligner, des tirets, et

48
00:02:53,360 --> 00:02:54,910
quelque chose comme ça.

49
00:02:54,910 --> 00:02:57,260
Et il maps que pour une valeur ASCII.

50
00:02:57,260 --> 00:03:03,080
Une valeur ASCII est juste un nombre qui
peut être compris par votre ordinateur.

51
00:03:03,080 --> 00:03:07,430
Et comme vous pouvez faire plus et
soustraction avec les chiffres, vous pouvez faire

52
00:03:07,430 --> 00:03:10,890
les valeurs ASCII.

53
00:03:10,890 --> 00:03:14,050
>> Donc, dans cet exemple, ce qui
sera présent imprimer?

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

55
00:03:26,790 --> 00:03:35,480
Ouais, juste un espace B C espace espace
D. D'où vient ma souris aller?

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

57
00:03:39,200 --> 00:03:43,380
Notez que vous pouvez définir un int à 65.

58
00:03:43,380 --> 00:03:47,080
Et lorsque vous imprimez à l'aide que
pour cent C, il va interpréter que comme une

59
00:03:47,080 --> 00:03:49,330
caractère et imprimera A.

60
00:03:49,330 --> 00:03:52,800
>> De même, vous pouvez déclarer
comme un produit de carbonisation.

61
00:03:52,800 --> 00:03:56,860
Et lorsque vous l'imprimez en utilisant pour cent
C, il va interpréter que comme

62
00:03:56,860 --> 00:04:05,240
pour cent D. Et comme vous pouvez ajouter un
nombre, vous pouvez ajouter des caractères sont

63
00:04:05,240 --> 00:04:06,878
valeurs ASCII, dans ce cas.

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

65
00:04:11,370 --> 00:04:16,130
>> Donc un peu de pointeur pour tout le monde.

66
00:04:16,130 --> 00:04:19,610
5, comme une chaîne, qui ne fonctionne pas
5 en fait égaux.

67
00:04:19,610 --> 00:04:26,610
Alors, comment pouvons-nous transformer l'
5 cordes à l'entier le 5?

68
00:04:26,610 --> 00:04:28,930
Des idées?

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

70
00:04:31,630 --> 00:04:36,720
>> Donc, si nous avons 5 sous forme de chaîne,
nous pouvons soustraire 0.

71
00:04:36,720 --> 00:04:37,820
Et qui nous donnera 5.

72
00:04:37,820 --> 00:04:41,670
Et de même, si nous avons 5 comme
entier, l'ajouter à la chaîne 0.

73
00:04:41,670 --> 00:04:43,112
Et cela nous donne la chaîne 5.

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

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

76
00:04:48,350 --> 00:04:52,940
>> Maintenant, rappelez-retour pour donner des conférences où un
nous avons parlé des algorithmes.

77
00:04:52,940 --> 00:04:57,260
Alors, comment voulons-nous réellement un ordinateur
à faire des choses intéressantes?

78
00:04:57,260 --> 00:05:00,460
Vous savez, juste additionner et soustraire
des chiffres et des choses d'impression n'est pas sur

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

80
00:05:01,730 --> 00:05:04,620
Habituellement, nous voulons que notre ordinateur
effectuer une sorte d'algorithme.

81
00:05:04,620 --> 00:05:07,820
Quelque chose d'un peu plus complexe
qu'une simple arithmétique.

82
00:05:07,820 --> 00:05:11,930
>> Un algorithme est juste une étape par étape ensemble de
des instructions sur la façon d'effectuer

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

84
00:05:14,640 --> 00:05:15,660
tout comme une recette.

85
00:05:15,660 --> 00:05:19,990
Vous vous souvenez peut le premier jour de
classe où David nous avait compter une chambre

86
00:05:19,990 --> 00:05:22,550
de personnes et combien de personnes
sont dans la chambre.

87
00:05:22,550 --> 00:05:24,480
Vous pourriez être utilisé pour le comptage
une par une.

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

89
00:05:25,860 --> 00:05:28,010
Dans ce cas, un algorithme en temps linéaire.

90
00:05:28,010 --> 00:05:31,710
>> Mais David a présenté un algorithme pour
vous comptez les gens dans la salle

91
00:05:31,710 --> 00:05:37,340
où tout le monde se lève, vous dites que votre
nombre à une autre personne, d'ajouter que

92
00:05:37,340 --> 00:05:39,200
nombre, et une personne s'assied.

93
00:05:39,200 --> 00:05:40,410
Et vous répétez cela.

94
00:05:40,410 --> 00:05:42,910
C'est un type d'algorithme.

95
00:05:42,910 --> 00:05:47,520
Nous pouvons analyser une façon efficace
algorithme est basé sur il est géré temps.

96
00:05:47,520 --> 00:05:49,680
Mais nous allons parler un peu
plus à ce sujet plus tard.

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

98
00:05:52,740 --> 00:05:57,090
>> Donc, tous les algorithmes peuvent aussi
être écrit en pseudo-code.

99
00:05:57,090 --> 00:06:01,120
Pseudocode est juste un Anglais comme
la syntaxe utilisée pour représenter

100
00:06:01,120 --> 00:06:02,420
un langage de programmation.

101
00:06:02,420 --> 00:06:06,070
Par exemple, si nous voulions demander à un utilisateur
de deviner mon numéro préféré, nous

102
00:06:06,070 --> 00:06:08,390
pseudocode peut avoir en tant que tel.

103
00:06:08,390 --> 00:06:09,850
>> Inscrivez-vous pour les utilisateurs de deviner.

104
00:06:09,850 --> 00:06:13,570
Si l'hypothèse est correcte, dites-leur
ils sont corrects, sinon leur dire

105
00:06:13,570 --> 00:06:15,560
ils ne sont pas correctes.

106
00:06:15,560 --> 00:06:22,530
Et pseudo est un moyen de facilement
représentant une idée ou un algorithme.

107
00:06:22,530 --> 00:06:26,910
Alors maintenant, nous pourrions réellement écrire
ce qui dans le langage de l'ordinateur

108
00:06:26,910 --> 00:06:27,980
pourrait comprendre.

109
00:06:27,980 --> 00:06:35,660
Donc, nous pourrions écrire notre pseudo et
interpréter que dans le code source.

110
00:06:35,660 --> 00:06:41,320
>> Jusqu'à présent, le code source doit respecter
à un certain syntaxe de

111
00:06:41,320 --> 00:06:42,490
un langage de programmation.

112
00:06:42,490 --> 00:06:45,430
Et jusqu'à présent, dans CS50, nous avons
été en utilisant la plupart du temps c.

113
00:06:45,430 --> 00:06:48,320
Donc, c'est peut-être le code source de c.

114
00:06:48,320 --> 00:06:51,440
Plus tard dans le cours, vous venez nuit
en contact avec d'autres programmes

115
00:06:51,440 --> 00:06:52,480
langues telles que PHP.

116
00:06:52,480 --> 00:06:57,540
Ou si vous prenez encore d'autres classes, vous
pourrait faire Java, Python, ou même OCML.

117
00:06:57,540 --> 00:07:01,570
Mais dans notre langage de programmation c, c'est
comment nous pourrions écrire le code source pour

118
00:07:01,570 --> 00:07:04,760
l'algorithme de pseudocode que
Je viens de décrire plus haut.

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

120
00:07:08,630 --> 00:07:11,430
>> Alors, comment fonctionne votre ordinateur fait
comprendre cela?

121
00:07:11,430 --> 00:07:14,490
Comme je l'ai déjà dit, il n'est vraiment
comprend des zéros et des uns.

122
00:07:14,490 --> 00:07:17,880
Alors, comment obtient-il de la source
code pour quelque chose qui peut être

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

124
00:07:18,960 --> 00:07:22,920
Eh bien, nous avons quelque chose
appelé un compilateur.

125
00:07:22,920 --> 00:07:28,450
>> Si vous vous souvenez de retour dans la plupart de votre
psets, vous aviez une sorte de programme

126
00:07:28,450 --> 00:07:30,370
écrit dans un fichier de point de c.

127
00:07:30,370 --> 00:07:32,550
Et puis vous tapez make.

128
00:07:32,550 --> 00:07:35,970
Alors, que faire est en train de faire?

129
00:07:35,970 --> 00:07:39,970
>> Vous pouvez taper make pour compiler votre
programme parce someone--

130
00:07:39,970 --> 00:07:42,730
celui qui a écrit votre jeu de p;
probablement David--

131
00:07:42,730 --> 00:07:44,190
créé un fichier de marque.

132
00:07:44,190 --> 00:07:51,320
Et qui dit faire savoir pour faire fonctionner votre
compilateur, appelé bruit, que la volonté

133
00:07:51,320 --> 00:07:55,560
puis compiler votre code source de s'opposer
code, qui est zéros et de uns

134
00:07:55,560 --> 00:07:57,720
que votre ordinateur comprend.

135
00:07:57,720 --> 00:08:01,610
Mais un peu plus tard, nous irons
plus en profondeur sur les compilateurs.

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

137
00:08:05,640 --> 00:08:10,800
>> Donc rappeler pset 0, where-- oui,
Vous avez une question?

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

139
00:08:11,620 --> 00:08:12,490
>> ENCEINTE 1: Oui.

140
00:08:12,490 --> 00:08:14,960
Je pense qu'ils ont effectivement
devrait être en ligne.

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

142
00:08:15,120 --> 00:08:16,572
>> PUBLIC: Est-ce comme [inaudible]?

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

144
00:08:19,476 --> 00:08:20,830
>> ENCEINTE 1: Il ne s'agit pas.

145
00:08:20,830 --> 00:08:25,810
Le sont sur cs50.net/quizzes.

146
00:08:25,810 --> 00:08:32,900
>> PUBLIC: quiz de Slash, slash 2013,
slash 0, et il suffit de cliquer à travers

147
00:08:32,900 --> 00:08:35,956
quiz 2013 et quizz 0,
examiner les diapositives de la section.

148
00:08:35,956 --> 00:08:40,380
>> ENCEINTE 1: Ouais, donc si vous voulez les gars à
tirer vers le haut et regarder sur votre

149
00:08:40,380 --> 00:08:42,740
propre ordinateur, c'est très bien aussi.

150
00:08:42,740 --> 00:08:43,130
Le dire.

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

152
00:08:44,546 --> 00:08:48,780
>> ENCEINTE 1: Ouais, [inaudible]
est la variable muette.

153
00:08:48,780 --> 00:08:49,644
Oh, oui?

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

155
00:08:51,372 --> 00:08:54,300
>> ENCEINTES 1: Non, les grèves
ne sont pas à l'examen.

156
00:08:54,300 --> 00:08:55,950
Désolé, sa question était, était
grèves sur l'examen.

157
00:08:55,950 --> 00:08:59,530
Et il n'est pas.

158
00:08:59,530 --> 00:09:05,780
Donc pset 0, les gars devrait avoir tous
mis en place quelque chose avec rien.

159
00:09:05,780 --> 00:09:13,100
Et nous avons appris un peu de programmation de base
blocs de construction à l'aide de scratch.

160
00:09:13,100 --> 00:09:15,590
>> Donc, nous allons jeter un oeil à certains
de ces blocs de construction

161
00:09:15,590 --> 00:09:18,170
qui constituent un programme.

162
00:09:18,170 --> 00:09:20,570
Le premier est l'expression booléenne.

163
00:09:20,570 --> 00:09:24,540
Les expressions booléennes sont ceux et
0 de ou quoi que ce soit qui a

164
00:09:24,540 --> 00:09:25,700
deux valeurs possibles.

165
00:09:25,700 --> 00:09:30,320
Dans ce cas, vrai ou faux,
allumé ou éteint, et oui ou non.

166
00:09:30,320 --> 00:09:35,390
Un exemple d'une méthode simple, très simple,
programme qui utilise un booléen

167
00:09:35,390 --> 00:09:39,140
expression ici.

168
00:09:39,140 --> 00:09:43,220
>> Donc, pour les expressions booléennes à
être utile, nous avons des opérateurs booléens.

169
00:09:43,220 --> 00:09:48,920
Ce sont des opérateurs qui peuvent être utilisés
de comparer certaines valeurs.

170
00:09:48,920 --> 00:09:52,820
Alors que nous avons et ou non égal à, moins
supérieur ou égal à, supérieur ou

171
00:09:52,820 --> 00:09:55,130
égal à, et moins de
ou supérieure.

172
00:09:55,130 --> 00:09:59,060
Mais ces opérateurs ne sont pas très utiles
si nous ne pouvons les regrouper en

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

174
00:10:00,320 --> 00:10:04,370
>> Alors vous avez peut rappeler à partir de zéro
et à partir de votre p définit que nous

175
00:10:04,370 --> 00:10:05,400
eu conditions.

176
00:10:05,400 --> 00:10:09,710
Ils sont, pour l'essentiel, comme des fourches
la logique de votre programme

177
00:10:09,710 --> 00:10:12,670
exécute selon que
une condition est remplie.

178
00:10:12,670 --> 00:10:18,150
Donc l'une des conditions que nous avions
utilisé de nombreuses fois dans ce cours est la

179
00:10:18,150 --> 00:10:21,470
si, d'autre, si, et les conditions d'autre.

180
00:10:21,470 --> 00:10:24,060
>> Voici un exemple de la façon dont
vous pourriez utiliser.

181
00:10:24,060 --> 00:10:28,430
Est-ce que quelqu'un sait la différence entre
simplement en utilisant if tous

182
00:10:28,430 --> 00:10:32,530
la façon dont les couplets si, d'autre,
si, et d'autre combiné?

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

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

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

186
00:10:40,741 --> 00:10:42,160
>> ENCEINTE 1: Exactement.

187
00:10:42,160 --> 00:10:50,210
Donc, si je devais si tout le long de ce
Ainsi, même si cette condition retours

188
00:10:50,210 --> 00:10:52,800
vrai, il faudra encore continuer
tester les deux suivants.

189
00:10:52,800 --> 00:11:00,120
Considérant que, dans un autre-si, un autre
déclaration, si l'un renvoie true,

190
00:11:00,120 --> 00:11:02,640
les autres ne sont pas testés.

191
00:11:02,640 --> 00:11:05,955
Pour toute question à ce sujet?

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

193
00:11:06,890 --> 00:11:12,240
>> Donc, vous utilisez un autre si-d'un autre
déclaration si vous savez qu'il ne peut

194
00:11:12,240 --> 00:11:14,470
être un de ces cas.

195
00:11:14,470 --> 00:11:21,550
Donc, nous savons si x est inférieur à 0, il est
certainement ne va pas être

196
00:11:21,550 --> 00:11:22,890
supérieur à 0.

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

198
00:11:26,940 --> 00:11:31,480
>> Ensuite, un autre bloc de construction
que nous avons appris des boucles.

199
00:11:31,480 --> 00:11:33,310
Nous avons trois types de boucles.

200
00:11:33,310 --> 00:11:35,830
Pour les boucles, les boucles while,
et faire des boucles while.

201
00:11:35,830 --> 00:11:38,730
Et généralement, quand vous vous asseyez à
écrire quelque chose, vous devez décider

202
00:11:38,730 --> 00:11:40,060
lequel des trois vous souhaitez utiliser.

203
00:11:40,060 --> 00:11:41,900
Alors, comment pouvons-nous décider lequel?

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

205
00:11:44,920 --> 00:11:48,790
>> Nous utilisons généralement une boucle for si nous savons
combien de fois nous voulons parcourir

206
00:11:48,790 --> 00:11:53,650
par quelque chose ou combien de fois
nous voulons effectuer une tâche.

207
00:11:53,650 --> 00:11:58,830
Nous utilisons des boucles while si nous avons besoin d'
état pour être vrai pour continuer à fonctionner.

208
00:11:58,830 --> 00:12:03,730
Et nous utilisons ne bien que très similaire à
temps, mais nous voulons que notre code fonctionne à

209
00:12:03,730 --> 00:12:04,880
moins une fois.

210
00:12:04,880 --> 00:12:09,410
>> Donc faire tout, tout ce qui est dans le faire la volonté
toujours exécuter au moins une fois.

211
00:12:09,410 --> 00:12:13,120
Considérant que, avec le temps, il
peuvent ne pas fonctionner du tout si l'

212
00:12:13,120 --> 00:12:15,490
condition n'est pas satisfaite.

213
00:12:15,490 --> 00:12:16,740
Toute question qui?

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

215
00:12:20,480 --> 00:12:22,860
>> Donc, la structure d'une boucle for.

216
00:12:22,860 --> 00:12:23,620
Les gars, vous avez tout vu.

217
00:12:23,620 --> 00:12:25,320
Vous l'initialiser.

218
00:12:25,320 --> 00:12:26,600
Vous avez une sorte de condition.

219
00:12:26,600 --> 00:12:32,340
Ainsi, par exemple, nous pourrions initialiser
en tant que i est égal à 0.

220
00:12:32,340 --> 00:12:34,040
i est inférieur à 10.

221
00:12:34,040 --> 00:12:35,442
Et je ++.

222
00:12:35,442 --> 00:12:39,010
Très simple que nous avons fait.

223
00:12:39,010 --> 00:12:42,210
>> Pour une boucle while, de même, vous avez
d'avoir une sorte de l'initialisation,

224
00:12:42,210 --> 00:12:44,980
une sorte de condition, et
une sorte de mise à jour.

225
00:12:44,980 --> 00:12:51,990
Donc, nous pouvons mettre en œuvre notre boucle aussi
comme une boucle lors de l'utilisation.

226
00:12:51,990 --> 00:12:56,000
Et de même avec une boucle Do While,
nous pourrions avoir une initialisation,

227
00:12:56,000 --> 00:12:58,640
exécuter quelque chose, le mettre à jour, et
alors vérifier l'état.

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

229
00:13:03,500 --> 00:13:05,140
>> Alors maintenant fonctions.

230
00:13:05,140 --> 00:13:06,460
Nous mettons tout ensemble.

231
00:13:06,460 --> 00:13:10,140
Nous pourrions écrire un peu
type de fonction.

232
00:13:10,140 --> 00:13:12,790
Fonction commune que vous pourriez
ont déjà vu est le principal.

233
00:13:12,790 --> 00:13:13,770
Principal est une fonction.

234
00:13:13,770 --> 00:13:16,160
Il a un type de retour, int.

235
00:13:16,160 --> 00:13:18,470
Il a un nom de fonction, principal.

236
00:13:18,470 --> 00:13:20,810
Et il a des arguments, argc et argv.

237
00:13:20,810 --> 00:13:24,040
Alors principal est juste une fonction.

238
00:13:24,040 --> 00:13:27,230
>> Autres fonctions que vous pourriez avoir utilisées,
printf printf-- est un function--

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

240
00:13:29,330 --> 00:13:32,010
Mais ceux-ci se produisent à avoir été
mis en œuvre pour nous par

241
00:13:32,010 --> 00:13:33,270
une sorte de bibliothèque.

242
00:13:33,270 --> 00:13:37,400
Si vous les gars me souviens notamment
cette bibliothèque ou le CS50.h

243
00:13:37,400 --> 00:13:38,510
Je norme / O bibliothèque.

244
00:13:38,510 --> 00:13:39,200
Oui, la question?

245
00:13:39,200 --> 00:13:41,610
>> PUBLIC: Est-principale juste inhérent à c?

246
00:13:41,610 --> 00:13:44,740
Est-ce que c'est en quelque sorte [inaudible]?

247
00:13:44,740 --> 00:13:47,370
>> ENCEINTE 1: La question est de
si principal est inhérent à c.

248
00:13:47,370 --> 00:13:51,460
Et oui, toutes les fonctions
avoir une fonction principale.

249
00:13:51,460 --> 00:13:55,290
C'est une sorte de nécessaire pour l'ordinateur
à savoir par où commencer

250
00:13:55,290 --> 00:13:55,993
l'exécution du code.

251
00:13:55,993 --> 00:13:58,108
>> PUBLIC: Donc, vous ne serait pas [inaudible]?

252
00:13:58,108 --> 00:13:59,480
>> ENCEINTE 1: Non

253
00:13:59,480 --> 00:14:00,760
D'autres questions?

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

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

256
00:14:04,770 --> 00:14:08,050
Donc, comme vous pouvez utiliser une fonction
que c'est écrit pour vous, vous pouvez également

257
00:14:08,050 --> 00:14:10,380
écrire votre propre fonction.

258
00:14:10,380 --> 00:14:17,050
C'est une fonction que quelqu'un pourrait
ont écrit pour calculer le volume

259
00:14:17,050 --> 00:14:18,395
d'un q, par exemple.

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

261
00:14:21,300 --> 00:14:29,500
Il ya un type de retour ici, dans ce cas
int, notre nom de la fonction q et notre

262
00:14:29,500 --> 00:14:31,360
liste des paramètres.

263
00:14:31,360 --> 00:14:34,550
>> Et notez que vous devez écrire les données
type de paramètre que vous voulez

264
00:14:34,550 --> 00:14:38,660
utiliser ou bien la fonction n'est pas
savoir quel genre de

265
00:14:38,660 --> 00:14:41,650
paramètre devrais-je accepter.

266
00:14:41,650 --> 00:14:48,110
Donc, dans ce cas, nous voulons
un entier comme notre contribution.

267
00:14:48,110 --> 00:14:50,390
Alors, pourquoi aurions nous voulons utiliser les fonctions?

268
00:14:50,390 --> 00:14:52,800
>> Tout d'abord, une grande pour l'organisation.

269
00:14:52,800 --> 00:14:56,350
Ils aident à briser votre code en
plus de morceaux organisé et faire

270
00:14:56,350 --> 00:14:57,960
plus facile à lire.

271
00:14:57,960 --> 00:14:59,760
Simplification.

272
00:14:59,760 --> 00:15:01,740
Ce qui est bon pour la conception.

273
00:15:01,740 --> 00:15:04,570
Lorsque vous lisez un morceau de code
et la fonction principale est vraiment,

274
00:15:04,570 --> 00:15:07,750
très long, il pourrait être plus difficile à
raisonner sur ce qui se passe.

275
00:15:07,750 --> 00:15:11,710
Donc, si vous le décomposer en fonctions,
il pourrait être plus facile à lire.

276
00:15:11,710 --> 00:15:12,750
Et réutiliser-capacité.

277
00:15:12,750 --> 00:15:16,940
Si vous avez un morceau de code qui est d'être
appelé ou exécuté plusieurs fois,

278
00:15:16,940 --> 00:15:20,690
au lieu de réécrire ce code 10 fois
dans votre fonction principale, vous pourriez

279
00:15:20,690 --> 00:15:21,440
vouloir réutiliser.

280
00:15:21,440 --> 00:15:25,740
Et puis à chaque fois que vous devez utiliser
morceau de code, appelez la fonction.

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

282
00:15:30,550 --> 00:15:35,380
>> Alors maintenant, si nous nous souvenons de revenir à zéro,
nous avons également parlé de quelques concepts,

283
00:15:35,380 --> 00:15:37,680
dont l'un est Threading.

284
00:15:37,680 --> 00:15:41,120
Le fil est le concept de multiple
les séquences de code

285
00:15:41,120 --> 00:15:43,040
exécuter en même temps.

286
00:15:43,040 --> 00:15:47,490
Donc penser à un jour où David avait
vous les gars Comptez le nombre de

287
00:15:47,490 --> 00:15:48,440
personnes dans la salle.

288
00:15:48,440 --> 00:15:50,550
>> Essentiellement, ce qui se passait
On est tout de vous les gars étaient

289
00:15:50,550 --> 00:15:52,370
l'exécution des threads séparés.

290
00:15:52,370 --> 00:15:55,540
Et ces discussions ont été s'unissent
pour obtenir une sorte de réponse.

291
00:15:55,540 --> 00:15:58,890
De même, dans Scratch, lorsque vous avez
plusieurs sprites, vous pourriez

292
00:15:58,890 --> 00:16:01,070
avoir un chat et un chien.

293
00:16:01,070 --> 00:16:08,770
Et ils seraient simultanément
la gestion de leurs propres scripts.

294
00:16:08,770 --> 00:16:10,020
C'est un exemple de filetage.

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

296
00:16:12,860 --> 00:16:18,000
>> Et l'autre concept qui a été
mis en place en scratch était évènements.

297
00:16:18,000 --> 00:16:22,550
Et les événements sont si plusieurs parties du
le code de communiquer les uns avec les autres.

298
00:16:22,550 --> 00:16:26,840
Dans Scratch, c'est à ce moment que vous avez utilisé la
contrôle et la diffusion Quand je

299
00:16:26,840 --> 00:16:29,500
Recevez blocs.

300
00:16:29,500 --> 00:16:35,170
>> Et aussi, dans le problème Set 4, nous avons vu
un peu d'événements aussi bien.

301
00:16:35,170 --> 00:16:38,250
Les gars, vous pourriez avoir utilisées
la bibliothèque Gevent.

302
00:16:38,250 --> 00:16:42,450
Et il y avait une fonction waitForClick
dans lequel vous attendiez

303
00:16:42,450 --> 00:16:44,300
pour l'utilisateur de cliquer.

304
00:16:44,300 --> 00:16:47,870
Et votre clic, dans ce cas, serait
l'événement et attendre clic est votre

305
00:16:47,870 --> 00:16:49,120
gestionnaire d'événement.

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

307
00:16:53,690 --> 00:16:58,630
>> Et aussi, tout au long de l'exécution de vos psets
et travailler sur vos psets, vous

308
00:16:58,630 --> 00:17:01,920
auraient pu entrer en contact avec
certaines de ces commandes.

309
00:17:01,920 --> 00:17:05,579
C'est ce que vous avez tapé dans votre
fenêtre de terminal ou tout autre fenêtre

310
00:17:05,579 --> 00:17:12,119
qui montre sur votre g, modifier à,
essentiellement, naviguer dans votre ordinateur.

311
00:17:12,119 --> 00:17:19,440
>> Ainsi, par exemple, indique le LS
contenu d'un répertoire.

312
00:17:19,440 --> 00:17:22,510
Faire répertoire crée un nouveau dossier.

313
00:17:22,510 --> 00:17:24,819
CD, changement de répertoire.

314
00:17:24,819 --> 00:17:28,400
RM, supprimer, supprime un fichier
ou un répertoire.

315
00:17:28,400 --> 00:17:31,050
Et puis supprimer le répertoire
supprime un répertoire.

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

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

318
00:17:36,978 --> 00:17:38,370
>> ENCEINTE 1: Oui, bien sûr.

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

320
00:17:42,530 --> 00:17:46,040
Désolé, la question était de savoir si vous
suggère de mettre ce

321
00:17:46,040 --> 00:17:48,840
sur la feuille de triche.

322
00:17:48,840 --> 00:17:49,440
Il pourrait aider.

323
00:17:49,440 --> 00:17:51,490
Si vous avez de la place, vous pouvez le mettre sur.

324
00:17:51,490 --> 00:17:56,170
Il est également juste en général assez bon
à retenir, car lorsque vous l'utilisez

325
00:17:56,170 --> 00:17:59,060
vous voudrez peut-être juste
l'ont mémorisé.

326
00:17:59,060 --> 00:18:02,750
Ça va vous rendre la vie beaucoup plus facile.

327
00:18:02,750 --> 00:18:04,000
Ai-je répondu à votre question?

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

329
00:18:10,528 --> 00:18:14,290
>> Alors maintenant, nous avons parlé un peu
brièvement sur les bibliothèques.

330
00:18:14,290 --> 00:18:18,570
Mais les deux principaux qui nous ont été
en utilisant jusqu'à présent dans le cadre sont

331
00:18:18,570 --> 00:18:20,860
I / O et CS50 standard.

332
00:18:20,860 --> 00:18:25,410
Quel genre de choses sont inclus
dans la bibliothèque standard d'E / S?

333
00:18:25,410 --> 00:18:28,410
>> Oui, jusqu'à présent, nous avons utilisé printf.

334
00:18:28,410 --> 00:18:31,150
Dans CS50, nous avons utilisé getint
et GetString.

335
00:18:31,150 --> 00:18:37,200
Et la chaîne de caractères de type de données se produit également
à déclarer dans cette bibliothèque de CS50.

336
00:18:37,200 --> 00:18:40,250
Nous parlerons un peu plus en profondeur sur
comment les bibliothèques fonctionnent et comment ils

337
00:18:40,250 --> 00:18:41,870
interagir avec le reste de votre code.

338
00:18:41,870 --> 00:18:46,220
Mais ce sont les deux principales que nous
avoir été en contact avec la mesure dans

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

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

341
00:18:50,050 --> 00:18:58,120
Ce sont de bonnes à rappeler combien
chaque type est représenté par ou comment

342
00:18:58,120 --> 00:19:02,840
le nombre d'octets de chaque type de requires--

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

344
00:19:04,990 --> 00:19:06,550
Float est de 4 octets.

345
00:19:06,550 --> 00:19:07,782
Qu'est-ce que c'est une double?

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

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

348
00:19:11,398 --> 00:19:16,240
>> ENCEINTE 1: Ouais, donc un flotteur
mais doubler la taille.

349
00:19:16,240 --> 00:19:17,150
Qu'en est-il de temps?

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

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

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

353
00:19:24,680 --> 00:19:25,410
Qu'est-ce que c'est long?

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

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

356
00:19:29,400 --> 00:19:31,450
>> ENCEINTE 1: Ouais, doubler un int.

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

358
00:19:34,240 --> 00:19:34,705
Oui.

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

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

361
00:19:38,030 --> 00:19:41,860
Et puis un long long est double.

362
00:19:41,860 --> 00:19:42,814
>> PUBLIC: Non, non.

363
00:19:42,814 --> 00:19:47,107
Une longue est juste un int.

364
00:19:47,107 --> 00:19:50,910
Il dépend de l'architecture
avant la [inaudible]

365
00:19:50,910 --> 00:19:52,922
int et ont la même taille.

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
>> ENCEINTE 1: Donc une longue et
un int sont les mêmes.

369
00:20:00,920 --> 00:20:02,943
Et puis un long long
est le double de la int.

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

371
00:20:03,910 --> 00:20:05,550
Et puis, ce qui est le dernier type?

372
00:20:05,550 --> 00:20:06,510
>> PUBLIC: Pointeur.

373
00:20:06,510 --> 00:20:10,350
>> ENCEINTE 1: Ouais, donc nous avons appris
un peu de pointeurs.

374
00:20:10,350 --> 00:20:14,015
Et indépendamment de ce qu'est un pointeur
pointant to-- il pourrait être une étoile char

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

376
00:20:15,880 --> 00:20:20,530
c'est toujours 4 octets pour un pointeur.

377
00:20:20,530 --> 00:20:21,633
Questions à ce sujet?

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

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

380
00:20:24,531 --> 00:20:29,530
>> ENCEINTE 1: Alors un long et int sont
même dans cet appareil de CS50.

381
00:20:29,530 --> 00:20:32,302
>> PUBLIC: L'appareil est complètement
interchangeable.

382
00:20:32,302 --> 00:20:33,510
>> ENCEINTE 1: Ouais.

383
00:20:33,510 --> 00:20:36,610
Alors un long long est le double int.

384
00:20:36,610 --> 00:20:39,250
>> PUBLIC: Il s'agit de la 32 bits?

385
00:20:39,250 --> 00:20:40,620
>> ENCEINTE 1: 32 bits, ouais.

386
00:20:40,620 --> 00:20:43,572
>> PUBLIC: Donc [inaudible]?

387
00:20:43,572 --> 00:20:46,790
>> ENCEINTE 1: Oui, si ce n'est pas
dire explicitement, vous

388
00:20:46,790 --> 00:20:47,870
devrait assumer un peu 32.

389
00:20:47,870 --> 00:20:50,040
>> PUBLIC: Il dirait quelque chose
comme l'hypothèse d'une

390
00:20:50,040 --> 00:20:51,498
l'architecture comme l'appareil.

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

392
00:20:58,800 --> 00:21:01,710
Pour 64 bits, les seules choses qui
changement sont longs et les pointeurs.

393
00:21:01,710 --> 00:21:05,614
Ils ont tous deux [inaudible].

394
00:21:05,614 --> 00:21:06,590
>> ENCEINTE 1: Oui?

395
00:21:06,590 --> 00:21:07,566
>> PUBLIC: Question.

396
00:21:07,566 --> 00:21:10,982
Ainsi, sur l'un des questionnaires de pratique,
il pose des questions sur un unsigned int.

397
00:21:10,982 --> 00:21:15,374
Alors, comment cela serait-il déterminé
d'un int [inaudible]?

398
00:21:15,374 --> 00:21:18,140
>> ENCEINTE 1: Un non signé
en est également de 4 octets.

399
00:21:18,140 --> 00:21:21,172
Mais ce qui est différent d'un signé
int et un unsigned int?

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

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

402
00:21:24,868 --> 00:21:25,630
>> ENCEINTE 1: Droit.

403
00:21:25,630 --> 00:21:27,570
On peut représenter les valeurs négatives.

404
00:21:27,570 --> 00:21:28,580
Mais comment fait-elle cela?

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

406
00:21:30,536 --> 00:21:36,370
>> ENCEINTE 1: Ouais, il enregistre une
bit pour représenter le signe.

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

408
00:21:40,910 --> 00:21:45,040
La signature a un peu qui
représente le signe.

409
00:21:45,040 --> 00:21:48,886
Et non signé est juste tous positifs.

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

411
00:21:50,365 --> 00:21:54,230
Donc, vous dites que c'est une double
deux fois la taille d'un flotteur?

412
00:21:54,230 --> 00:21:58,202
>> ENCEINTE 1: Double est deux fois
la taille d'un flotteur, oui.

413
00:21:58,202 --> 00:22:01,639
>> PUBLIC: Comment un pointeur
pour un long long [inaudible]?

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

415
00:22:06,058 --> 00:22:10,870
>> ENCEINTE 1: Donc la question est de savoir comment
le pointeur sur un long long--

416
00:22:10,870 --> 00:22:13,800
Comment est-ce que quatre octets
un long long de ses 8 octets.

417
00:22:13,800 --> 00:22:17,310
Alors, n'oubliez pas ce qui est un pointeur,
essentiellement, à la valeur très base.

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

419
00:22:19,046 --> 00:22:22,670
>> ENCEINTE 1: Ouais, donc un pointeur
est tout simplement un emplacement de mémoire.

420
00:22:22,670 --> 00:22:28,040
Donc, il n'a pas d'importance combien d'espace
ce pointeur pointe.

421
00:22:28,040 --> 00:22:32,060
Il suffit de 4 octets à suivre
de cet emplacement de mémoire.

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

423
00:22:34,760 --> 00:22:36,010
D'autres questions?

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

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

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

427
00:22:42,920 --> 00:22:47,460
>> Ainsi, la dernière chose que je dois
est la sortie standard.

428
00:22:47,460 --> 00:22:51,020
Vous devez les utiliser fréquemment
assez que vous vous souvenez.

429
00:22:51,020 --> 00:22:54,800
Mais c'est à ce moment que nous utilisons
printf, par exemple.

430
00:22:54,800 --> 00:22:59,260
Et nous avons ces espaces réservés
ont été appelés codes de format.

431
00:22:59,260 --> 00:23:03,910
>> Donc pour cent c char, pour cent i pour int,
et nous pouvons aussi utiliser pour cent d.

432
00:23:03,910 --> 00:23:05,130
C'est la même chose.

433
00:23:05,130 --> 00:23:08,200
Mais, en général, on en CS50
essayer d'utiliser pour cent i.

434
00:23:08,200 --> 00:23:09,860
F pour cent du flottant.

435
00:23:09,860 --> 00:23:15,620
Pour cent ld pour long long et
pour cent s pour une chaîne.

436
00:23:15,620 --> 00:23:18,550
>> De même, nous avons utilisé un peu
de ces séquences d'échappement.

437
00:23:18,550 --> 00:23:22,431
Par exemple, la barre oblique inverse n pour une nouvelle ligne.

438
00:23:22,431 --> 00:23:26,910
C'est juste pour quand vous mettez en forme
votre code pour l'impression f.

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

440
00:23:27,260 --> 00:23:28,906
>> PUBLIC: Quel est pour cent d pour?

441
00:23:28,906 --> 00:23:31,850
>> ENCEINTE 1: Donc la question
est ce qui est pour cent d pour?

442
00:23:31,850 --> 00:23:33,270
Pour cent d est pour ints.

443
00:23:33,270 --> 00:23:37,392
Pour cent pour cent et d i sont les mêmes.

444
00:23:37,392 --> 00:23:41,130
>> PUBLIC: Quelle est la différence entre
barre oblique inverse n et barre oblique inverse r?

445
00:23:41,130 --> 00:23:45,300
>> ENCEINTE 1: Donc la question est quelle est la
la différence entre n et réaction

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

447
00:23:48,615 --> 00:23:50,906
Je pense que la barre oblique inverse r is--

448
00:23:50,906 --> 00:23:54,340
>> PUBLIC: Donc barre oblique inverse r implique seulement
revenir au début de la ligne

449
00:23:54,340 --> 00:23:56,670
sans aller à une nouvelle ligne.

450
00:23:56,670 --> 00:24:01,000
Donc, si vous imprimez une barre oblique inverse r et vous
revenir au début de la ligne

451
00:24:01,000 --> 00:24:04,005
alors vous imprimez plus de choses, vous écrasez
le truc qui est déjà sur

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

453
00:24:04,390 --> 00:24:06,725
Considérant que, n va en fait à une nouvelle
ligne et va à [inaudible].

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

455
00:24:10,525 --> 00:24:13,915
>> ENCEINTE 1: Eh bien, d'autres questions?

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

457
00:24:15,430 --> 00:24:18,617
Je vais la passer à
Dan, qui va se poursuivre.

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

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

460
00:25:08,814 --> 00:25:09,720
>> DAN: Tous droitier.

461
00:25:09,720 --> 00:25:18,590
Donc, je vais vous parler d'un autre grand
éventail d'idées de la classe qui sont

462
00:25:18,590 --> 00:25:23,220
à peu près représentatif de deux semaines et
le début de trois semaines à partir de

463
00:25:23,220 --> 00:25:28,690
la coulée, qui est juste une façon de
traitement d'une valeur d'un certain type que

464
00:25:28,690 --> 00:25:30,830
une valeur d'un type différent.

465
00:25:30,830 --> 00:25:34,110
Donc, nous pouvons le faire avec les caractères à
ints, les flotteurs à ints, et

466
00:25:34,110 --> 00:25:35,360
longues aspire à doubler.

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

468
00:25:38,170 --> 00:25:44,500
>> Toutes ces choses peuvent être utilisés comme moyens
de traiter une certaine valeur numérique

469
00:25:44,500 --> 00:25:48,370
moins char comme un autre
valeur numérique.

470
00:25:48,370 --> 00:25:54,480
Donc, il ya quelques problèmes avec cela,
Bien sûr, ce qui arrive quand vous lancez

471
00:25:54,480 --> 00:25:57,860
des choses comme flotteur pour ints.

472
00:25:57,860 --> 00:26:00,500
Donc, c'est un peu bizarre.

473
00:26:00,500 --> 00:26:03,170
Nous avons un flotteur qui est de 1,31.

474
00:26:03,170 --> 00:26:05,220
Nous multiplions par 10 000.

475
00:26:05,220 --> 00:26:08,380
Et puis nous imprimons comme un int.

476
00:26:08,380 --> 00:26:09,630
Qu'est-ce que cette sortie?

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

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

479
00:26:14,020 --> 00:26:18,761
Donc, 13 000, est que la conjecture?

480
00:26:18,761 --> 00:26:20,685
>> PUBLIC: Je pense que c'est 10 000.

481
00:26:20,685 --> 00:26:24,234
>> DAN: Je suis le multipliant par 10 000
avant que je le jeter.

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

483
00:26:25,202 --> 00:26:27,622
Aurait-il pas un 9
et certains numéros 0?

484
00:26:27,622 --> 00:26:29,270
>> DAN: Vous pourriez avoir des chiffres bizarres.

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

486
00:26:32,410 --> 00:26:37,670
Alors bon, c'est 1,3 fois 10.000.

487
00:26:37,670 --> 00:26:40,040
C'est donc 13 000.

488
00:26:40,040 --> 00:26:41,313
Et ce weird-- supplémentaire

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

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

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

492
00:26:44,910 --> 00:26:46,610
Et ce weirdness-- supplémentaire

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

494
00:26:48,060 --> 00:26:53,860
tout simplement parce que ce casting
fini arrondi vers le bas où

495
00:26:53,860 --> 00:26:55,394
il ne devrait pas avoir.

496
00:26:55,394 --> 00:26:55,871
Ouais.

497
00:26:55,871 --> 00:26:58,256
>> PUBLIC: Le casting se passe
après quoi d'autre?

498
00:26:58,256 --> 00:27:03,865
>> DAN: Donc, parce que j'ai ce papier, il
t-il cette multiplication avant

499
00:27:03,865 --> 00:27:05,230
fait ce casting.

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

501
00:27:06,140 --> 00:27:11,350
>> DAN: Je pense que ce serait jeter les premiers,
oui, ce qui serait de 10.000.

502
00:27:11,350 --> 00:27:12,610
Rien d'autre?

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

504
00:27:13,330 --> 00:27:16,344
Donc, c'est 13 099.

505
00:27:16,344 --> 00:27:17,840
Pourquoi cela se produit?

506
00:27:17,840 --> 00:27:18,900
Imprécision.

507
00:27:18,900 --> 00:27:21,020
>> Flotteurs ne sont pas parfaits.

508
00:27:21,020 --> 00:27:27,550
Ils ne peuvent représenter des nombres à un
certain nombre de chiffres significatifs.

509
00:27:27,550 --> 00:27:35,120
Donc, si nous imprimons sur 8 figues de sig sur
ce flotteur, on obtient une sorte de

510
00:27:35,120 --> 00:27:36,800
laid nombre prospectifs.

511
00:27:36,800 --> 00:27:45,580
Et c'est parce que 1.31 ne peut pas précisément
être représenté par simple

512
00:27:45,580 --> 00:27:49,000
des puissances de deux dans la machine.

513
00:27:49,000 --> 00:27:53,530
Donc, il finit par prendre le plus proche
devinez qui finit par

514
00:27:53,530 --> 00:27:55,710
être un peu faible.

515
00:27:55,710 --> 00:27:57,730
Donner un sens?

516
00:27:57,730 --> 00:27:59,110
Dáccord.

517
00:27:59,110 --> 00:28:05,840
>> Maintenant, commutation sont une autre façon de
faire des déclarations conditionnelles où tous les

518
00:28:05,840 --> 00:28:09,900
nous nous soucions est une seule variable.

519
00:28:09,900 --> 00:28:16,570
Donc, dans cet exemple particulier, nous sommes
obtenir un nombre entier de l'utilisateur.

520
00:28:16,570 --> 00:28:21,070
Et puis nous cherchons à
ce qui est entier.

521
00:28:21,070 --> 00:28:23,500
Vraisemblablement, c'est le numéro
entre un et quatre.

522
00:28:23,500 --> 00:28:24,800
C'est ce que nous demandons.

523
00:28:24,800 --> 00:28:28,450
>> Alors que vous faites un commutateur de
le nom de la variable.

524
00:28:28,450 --> 00:28:34,290
Ensuite, vous configurez les cas de possible
valeurs qu'elle pourrait être.

525
00:28:34,290 --> 00:28:37,730
Donc affaire, un dire que c'est faible.

526
00:28:37,730 --> 00:28:41,080
Et puis vous cassez sortir
de l'état de commutation de sorte

527
00:28:41,080 --> 00:28:43,270
vous ne gardez pas aller.

528
00:28:43,270 --> 00:28:44,830
>> Dans la prochaine case--

529
00:28:44,830 --> 00:28:46,940
donc deux cas et cas three--

530
00:28:46,940 --> 00:28:51,920
si c'est le cas deux il tombe juste en bas de
la première ligne de code qu'il considère comme des

531
00:28:51,920 --> 00:28:55,400
Troisième cas jusqu'à ce qu'il voit une pause.

532
00:28:55,400 --> 00:29:00,430
La raison pour laquelle vous obtenez un cas de
Seule l'impression est faible parce que je

533
00:29:00,430 --> 00:29:01,890
avoir cette pause ici.

534
00:29:01,890 --> 00:29:05,360
Si moi, par exemple, ignoré cette break--
si j'ai jeté ce breakaway--

535
00:29:05,360 --> 00:29:09,740
il imprimer faible, et il serait
imprimer milieu, et il allait se briser.

536
00:29:09,740 --> 00:29:12,200
>> Donc, les pauses sont une partie importante
de changer les conditions et

537
00:29:12,200 --> 00:29:14,340
ils devraient être là.

538
00:29:14,340 --> 00:29:20,070
Tous les cas qui ne sont pas mentionnés explicitement
sont traitées par le défaut

539
00:29:20,070 --> 00:29:26,645
cas dans le commutateur et doit être jeté.

540
00:29:26,645 --> 00:29:31,363
>> PUBLIC: Donc 1, 2, 3,
et 4 serait n?

541
00:29:31,363 --> 00:29:33,310
>> DAN: Les valeurs qui peuvent être n.

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

543
00:29:34,654 --> 00:29:35,146
Ouais?

544
00:29:35,146 --> 00:29:37,606
>> PUBLIC: Alors, quand vous avez
que [inaudible]?

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

546
00:29:44,002 --> 00:29:46,830
>> DAN: Vous imprimer bas, puis
il imprimer milieu, et

547
00:29:46,830 --> 00:29:47,400
il allait se briser.

548
00:29:47,400 --> 00:29:50,244
>> PUBLIC: Pourquoi serait-il imprimer
milieu si [inaudible]?

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

550
00:29:54,036 --> 00:30:00,550
>> DAN: Alors tout sous un cas
avant une pause relève.

551
00:30:00,550 --> 00:30:09,390
Donc cas une impression est le cas sous
un comme l'est cette impression suivante.

552
00:30:09,390 --> 00:30:09,890
Ouais?

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

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

555
00:30:15,890 --> 00:30:22,170
>> DAN: Donc, ce nombre est juste un particulier
valeur de cette variable

556
00:30:22,170 --> 00:30:23,420
peut prendre, non?

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

558
00:30:26,740 --> 00:30:28,490
Cela fait-il sens?

559
00:30:28,490 --> 00:30:28,990
Ouais.

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

561
00:30:31,490 --> 00:30:34,130
>> DAN: Oui, deux cas serait imprimer
milieu, puis se briser.

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

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

564
00:30:37,954 --> 00:30:40,050
>> DAN: Je pense que tout?

565
00:30:40,050 --> 00:30:43,855
Quels sont les autres types de données
pouvez-vous basculer?

566
00:30:43,855 --> 00:30:46,320
>> PUBLIC: Vous pouvez passer
sur tout type de données.

567
00:30:46,320 --> 00:30:50,905
Mais cela signifie que quoi que ce soit sur les caractères
et ints et des trucs comme ça, parce que

568
00:30:50,905 --> 00:30:55,600
si vous êtes de commutation sur un pointeur
qui n'a pas vraiment de sens,

569
00:30:55,600 --> 00:30:59,555
commutation de charges, si elle laisse même de
vous faites cela, en raison de virgule flottante

570
00:30:59,555 --> 00:31:02,840
de précision, vous ne seriez pas vraiment
vouloir faire de toute façon.

571
00:31:02,840 --> 00:31:07,320
Donc, à peu près, à seulement ints et
caractères et des trucs comme ça.

572
00:31:07,320 --> 00:31:12,360
>> DAN: Ouais, c'est quand vous avez explicite
valeurs que vous savez, je pense, peut être

573
00:31:12,360 --> 00:31:14,250
que le passage est réellement utile.

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

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

576
00:31:18,990 --> 00:31:21,370
Dáccord.

577
00:31:21,370 --> 00:31:26,180
>> Scope est la plage qui a déclaré
s'étend variables.

578
00:31:26,180 --> 00:31:32,190
Donc, dans ce petit morceau de code que j'ai,
il serait plein d'erreurs.

579
00:31:32,190 --> 00:31:41,450
Et la raison en est, j'ai déclaré ce int
i dans la portée de cette boucle.

580
00:31:41,450 --> 00:31:46,390
Et puis je suis en train de faire référence à ce que
i l'extérieur de cette boucle portée.

581
00:31:46,390 --> 00:31:50,330
>> Donc, fondamentalement, vous pouvez penser à portée
comme tout ce que vous déclarez

582
00:31:50,330 --> 00:31:59,750
avec à l'intérieur un jeu d'accolades ne
existe au sein de ces accolades.

583
00:31:59,750 --> 00:32:04,990
Et si vous essayez d'utiliser cette variable
en dehors de ces accolades, vous aurez

584
00:32:04,990 --> 00:32:08,356
obtenir une erreur du compilateur.

585
00:32:08,356 --> 00:32:08,812
Ouais?

586
00:32:08,812 --> 00:32:09,724
>> PUBLIC: Donc celui-ci ne fonctionne pas?

587
00:32:09,724 --> 00:32:11,790
>> DAN: Cela ne fonctionne pas, oui.

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

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

590
00:32:18,660 --> 00:32:19,780
Chaîne un char *.

591
00:32:19,780 --> 00:32:22,250
Ils sont exactement les mêmes.

592
00:32:22,250 --> 00:32:25,540
Ils sont juste des pointeurs caractères.

593
00:32:25,540 --> 00:32:33,000
Et toutes les chaînes que vous avez doivent se terminer
avec barre oblique inverse zéro, ce qui est juste

594
00:32:33,000 --> 00:32:34,410
une convention de c.

595
00:32:34,410 --> 00:32:36,680
>> Il est appelé le terminateur NULL.

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

597
00:32:39,050 --> 00:32:41,670
N majuscule, U majuscule, le capital
L, capitale L--

598
00:32:41,670 --> 00:32:44,290
n'est pas le même que l'
Terminateur NULL.

599
00:32:44,290 --> 00:32:46,640
Il s'agit d'un pointeur.

600
00:32:46,640 --> 00:32:48,280
Il s'agit d'un caractère.

601
00:32:48,280 --> 00:32:49,530
Ils sont très distinctes.

602
00:32:49,530 --> 00:32:50,200
Rappelez-vous il.

603
00:32:50,200 --> 00:32:52,320
Il sera sur le quiz, probablement.

604
00:32:52,320 --> 00:32:54,040
Je n'ai pas vu le quiz.

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

606
00:32:57,880 --> 00:32:58,840
Ouais?

607
00:32:58,840 --> 00:33:01,232
>> PUBLIC: Donc NULL est, par exemple, le pointeur?

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

609
00:33:01,995 --> 00:33:05,170
>> PUBLIC: Qu'est-ce que [inaudible]?

610
00:33:05,170 --> 00:33:10,050
>> DAN: si, par exemple, malloc est appelé lorsque vous
ne pas avoir suffisamment de mémoire pour obtenir

611
00:33:10,050 --> 00:33:14,400
la taille que vous vous demandez,
malloc retourne NULL.

612
00:33:14,400 --> 00:33:19,550
C'est, en fait, chaque fois qu'une fonction est
supposée retourner un pointeur, vous

613
00:33:19,550 --> 00:33:22,600
besoin de vérifier une valeur NULL parce
NULL est une jolie good--

614
00:33:22,600 --> 00:33:25,260
c'est, en quelque sorte, la valeur des ordures.

615
00:33:25,260 --> 00:33:27,050
C'est un zéro dans la mesure où les pointeurs vont.

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

617
00:33:29,630 --> 00:33:32,250
>> Chaque fois que vous appelez une fonction,
qui renvoie un pointeur.

618
00:33:32,250 --> 00:33:35,960
Vous allez vouloir vérifier pour être
vous que ce pointeur n'est pas NULL

619
00:33:35,960 --> 00:33:37,760
parce que NULL est très commun.

620
00:33:37,760 --> 00:33:40,160
C'est en quelque sorte d'un retour des ordures.

621
00:33:40,160 --> 00:33:44,902
Donc, si quelque chose ne va pas droit,
il suffit de retourner la valeur NULL à la place.

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

623
00:33:45,898 --> 00:33:48,922
>> DAN: Oui, et c'est ce.

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

625
00:33:51,750 --> 00:33:52,800
>> DAN: Sort comme cela.

626
00:33:52,800 --> 00:33:54,150
C'est le terminateur NULL.

627
00:33:54,150 --> 00:33:56,560
C'est minuscule N-U-L-L si
vous l'épeler.

628
00:33:56,560 --> 00:33:59,860
>> PUBLIC: Et je suis juste allé
dos et testé.

629
00:33:59,860 --> 00:34:03,010
Et si vous essayez de mettre une virgule flottante
valeur dans un commutateur, il va crier à vous

630
00:34:03,010 --> 00:34:05,916
dire, déclaration nécessite expression
de type entier.

631
00:34:05,916 --> 00:34:07,166
>> DAN: Il vous allez.

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

633
00:34:09,639 --> 00:34:12,246
Mais oui, quelle était la question?

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

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

636
00:34:16,150 --> 00:34:23,679
>> DAN: Donc capitale N, U majuscule, le capital
L, L majuscule est une chose c réelle.

637
00:34:23,679 --> 00:34:29,719
Il est le pointeur NULL et de la volonté
seulement être traitée comme telle.

638
00:34:29,719 --> 00:34:33,530
Vous ne serez jamais essayer de préciser la
Caractère NULL et voir tout

639
00:34:33,530 --> 00:34:35,630
autre manière que cela.

640
00:34:35,630 --> 00:34:36,610
Ouais?

641
00:34:36,610 --> 00:34:42,490
>> PUBLIC: Donc retour à char max ou
quelque chose dans les notes, ne serait-il

642
00:34:42,490 --> 00:34:43,960
incarner la même fonction
comme [inaudible]?

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

644
00:34:50,655 --> 00:34:54,949
>> PUBLIC: Alors parlez-vous
retour caractères max de getchar, ou

645
00:34:54,949 --> 00:34:55,444
quoi que ce soit?

646
00:34:55,444 --> 00:34:55,940
>> PUBLIC: Ouais.

647
00:34:55,940 --> 00:34:58,620
>> PUBLIC: Ouais, donc le général
terme de toutes ces choses

648
00:34:58,620 --> 00:34:59,920
sont des valeurs sentinelles.

649
00:34:59,920 --> 00:35:03,640
Donc, comme un retour int max de getint
et caractères max de getchar, c'est

650
00:35:03,640 --> 00:35:06,010
censé être comme, tout droit, si
ces choses sont de retour à nous,

651
00:35:06,010 --> 00:35:07,210
quelque chose n'allait pas.

652
00:35:07,210 --> 00:35:09,950
>> Pour pointeurs, nous justement des
cette valeur de sentinelle que tout le monde

653
00:35:09,950 --> 00:35:10,750
accord sur.

654
00:35:10,750 --> 00:35:13,210
Et c'est la chose que vous revenez
quand les choses vont mal.

655
00:35:13,210 --> 00:35:15,910
Donc caractères max est ce que nous utilisons
de représenter quelque chose

656
00:35:15,910 --> 00:35:18,100
comme NULL ou getchar.

657
00:35:18,100 --> 00:35:23,420
>> PUBLIC: Donc, si vous getchar tester,
pourriez-vous mettre NULL?

658
00:35:23,420 --> 00:35:23,910
Cela ferait une différence?

659
00:35:23,910 --> 00:35:25,400
>> DAN: Vous pouvez non seulement vérifier NULL.

660
00:35:25,400 --> 00:35:30,130
Il faudrait vérifier caractères max parce que le
La valeur de retour de la fonction est

661
00:35:30,130 --> 00:35:35,416
un caractère qui n'est pas un pointeur.

662
00:35:35,416 --> 00:35:35,888
Ouais?

663
00:35:35,888 --> 00:35:38,248
>> PUBLIC: Cette question demande
pour la longueur de chaîne.

664
00:35:38,248 --> 00:35:40,136
Est-ce que couvre le caractère NULL?

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

666
00:35:41,000 --> 00:35:45,930
Et c'est effectivement la façon dont la longueur de chaîne
sait d'arrêter car il passe par

667
00:35:45,930 --> 00:35:49,070
votre tableau de caractères jusqu'à ce que
il voit un caractère NULL.

668
00:35:49,070 --> 00:35:51,030
Et puis c'est comme tout
Bon, je suis fait.

669
00:35:51,030 --> 00:35:52,130
>> PUBLIC: [inaudible] cinq?

670
00:35:52,130 --> 00:35:53,990
>> DAN: Bonjour serait de cinq ans.

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

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

673
00:35:59,580 --> 00:36:02,880
Ainsi, les tableaux sont continues
des blocs de mémoire.

674
00:36:02,880 --> 00:36:08,480
Ils ont un accès instantané en disant que le
Nom du tableau et ensuite, bouclés

675
00:36:08,480 --> 00:36:16,720
accolades, quel que soit l'indice vous voulez aller
pour, ils sont indexés à partir de zéro à

676
00:36:16,720 --> 00:36:20,100
la longueur de la matrice moins 1.

677
00:36:20,100 --> 00:36:23,070
>> Et ils sont déclarés par le type de l'
chose que vous stockez dans la

678
00:36:23,070 --> 00:36:29,750
réseau, le nom de la matrice, et ensuite
quelle que soit la taille de ce tableau.

679
00:36:29,750 --> 00:36:36,660
Il s'agit donc d'un tableau de caractères de longueur
qui a six de ces valeurs.

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

681
00:36:42,050 --> 00:36:42,700
Ouais?

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

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

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

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

686
00:36:51,340 --> 00:36:56,700
>> DAN: Si vous avez ce qui se passe
dans le tableau déjà fait.

687
00:36:56,700 --> 00:37:02,260
Ainsi, vous pouvez spécifier ce lieu que,
par exemple, char, quel que soit le nom de votre

688
00:37:02,260 --> 00:37:12,200
tableau est, entre parenthèses vides est égal bouclés
préparez-H virgule E virgule L virgule L virgule

689
00:37:12,200 --> 00:37:16,290
O virgule caractère NULL
et accolade.

690
00:37:16,290 --> 00:37:18,180
Ce serait aussi fonctionner comme une déclaration.

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

692
00:37:20,886 --> 00:37:23,110
>> DAN: Ensuite, vous devez avoir
la taille déjà fait.

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

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

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

696
00:37:30,114 --> 00:37:32,420
Tous droitier.

697
00:37:32,420 --> 00:37:36,430
arguments de ligne de commande sont un moyen de
obtenir les commentaires de l'utilisateur comme

698
00:37:36,430 --> 00:37:39,380
arguments principaux.

699
00:37:39,380 --> 00:37:40,600
Principal prend deux arguments.

700
00:37:40,600 --> 00:37:47,680
Le nombre d'arguments qui est en cours
passé le long de la ligne de commande et un

701
00:37:47,680 --> 00:37:55,340
vecteur de chaîne ou un tableau de chaînes
de tous les arguments.

702
00:37:55,340 --> 00:38:07,840
>> Donc, si je, par exemple, appelé une fonction telle que
un point sur 1 espace 2 espace, trois,

703
00:38:07,840 --> 00:38:10,110
argc serait 4.

704
00:38:10,110 --> 00:38:17,370
Et la argv 0 serait un point sur.

705
00:38:17,370 --> 00:38:19,130
Argv1 serait 1.

706
00:38:19,130 --> 00:38:23,030
argv2 serait 2. argv3 seraient
3, dans ce cas particulier.

707
00:38:23,030 --> 00:38:23,310
Ouais?

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

709
00:38:25,400 --> 00:38:34,010
>> DAN: Le dernier élément du tableau
car le tableau est la longueur argc, plus

710
00:38:34,010 --> 00:38:41,050
l'un des ARGB, le dernier élément
est le pointeur NULL.

711
00:38:41,050 --> 00:38:42,580
Il est argc plus 1.

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

713
00:38:46,210 --> 00:38:52,150
Donc, dans le cas que je viens de dire, il
serait argv 0 est un point sur.

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

715
00:38:56,330 --> 00:39:03,490
argv 4, qui est une plus grande
que argc serait nulle.

716
00:39:03,490 --> 00:39:04,870
>> Et c'est le pointeur NULL.

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

718
00:39:06,590 --> 00:39:11,250
Et c'est parce que la chaîne est
une étoile de char est un pointeur.

719
00:39:11,250 --> 00:39:14,102
Donc, il doit être du même type.

720
00:39:14,102 --> 00:39:14,595
Ouais?

721
00:39:14,595 --> 00:39:16,074
>> PUBLIC: Deux questions.

722
00:39:16,074 --> 00:39:21,004
Donc un, quelle est la différence entre
ce et GetString autre d'un type

723
00:39:21,004 --> 00:39:22,483
dans le moteur de l'utilisateur?

724
00:39:22,483 --> 00:39:25,934
Et de deux, il est stocké dans
votre mémoire récente?

725
00:39:25,934 --> 00:39:28,399
Donc, comme, GetString serait
être [inaudible]?

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

727
00:39:31,357 --> 00:39:33,650
>> DAN: Où est-il stocké?

728
00:39:33,650 --> 00:39:34,905
Je ne sais pas où il est stocké.

729
00:39:34,905 --> 00:39:40,000
>> PUBLIC: Donc, en fait, vous savez comment tout
la fonction que vous appelez c'est arguments

730
00:39:40,000 --> 00:39:42,170
sont stockées dans la pile?

731
00:39:42,170 --> 00:39:46,610
Donc argc et argv sont arguments de main
et ils sont sur la pile, ou vraiment

732
00:39:46,610 --> 00:39:49,131
juste au-dessus ce que vous pensez que
le début de la pile.

733
00:39:49,131 --> 00:39:53,490
Ce qui était l'autre partie
de la question?

734
00:39:53,490 --> 00:39:56,821
>> PUBLIC: Alors, quelle est la [inaudible]?

735
00:39:56,821 --> 00:40:00,990
>> DAN: Oui, c'est juste une façon différente
d'obtenir l'entrée de l'utilisateur.

736
00:40:00,990 --> 00:40:06,030
Un peu plus efficace et celui-ci est
il est plus pratique pour les scripts parce que vous

737
00:40:06,030 --> 00:40:10,070
peut juste passer des arguments à votre principal
fonction plutôt que d'avoir à attendre

738
00:40:10,070 --> 00:40:13,400
pour les utilisateurs si vous n'avez pas tous les utilisateurs.

739
00:40:13,400 --> 00:40:16,280
>> PUBLIC: Et oui, obtenir les chaînes
serait [inaudible].

740
00:40:16,280 --> 00:40:17,922
Il serait stocker les choses dont vous avez besoin.

741
00:40:17,922 --> 00:40:18,834
>> DAN: Ouais?

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

743
00:40:21,114 --> 00:40:27,545
>> DAN: Oui, argv 0 comprend toujours le
point slash de l'appel de fonction.

744
00:40:27,545 --> 00:40:28,042
Ouais?

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

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

747
00:40:33,509 --> 00:40:37,310
>> DAN: Oui, chacun des arguments sont
terminé à caractère NULL parce qu'ils

748
00:40:37,310 --> 00:40:38,310
sont des chaînes.

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

750
00:40:40,892 --> 00:40:44,116
>> DAN: Oui, argv argc est un pointeur NULL.

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

752
00:40:45,112 --> 00:40:47,104
>> DAN: Oh oui.

753
00:40:47,104 --> 00:40:48,100
Ouais, désolé.

754
00:40:48,100 --> 00:40:49,594
>> PUBLIC: Donc [inaudible]?

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

756
00:41:08,518 --> 00:41:16,340
>> DAN: Donc la question est de savoir si vous avez eu l'
ligne de commande point slash un point sur 1, 2,

757
00:41:16,340 --> 00:41:20,410
serait le nombre de ligne de commande
arguments soient deux ou serait-il trois?

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

759
00:41:24,420 --> 00:41:28,240
>> PUBLIC: Je pense que ce n'est pas le
vraiment d'importance.

760
00:41:28,240 --> 00:41:31,370
J'ai tendance à dire, oh, vous n'avez pas passé
des arguments de ligne de commande lorsque,

761
00:41:31,370 --> 00:41:32,730
de toute évidence, vous avez appelé la fonction.

762
00:41:32,730 --> 00:41:37,950
J'ai donc tendance à exclure vocalement l'
fonction de la ligne de commande

763
00:41:37,950 --> 00:41:40,350
arguments, même si c'est
inclus dans argv.

764
00:41:40,350 --> 00:41:42,600
>> DAN: Mais si c'était le test--

765
00:41:42,600 --> 00:41:46,550
yeah-- et aussi si vous dites quelque chose
comme argc est égal à 3,

766
00:41:46,550 --> 00:41:48,512
vous êtes en position de sécurité.

767
00:41:48,512 --> 00:41:49,416
Ouais?

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

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

770
00:42:00,990 --> 00:42:09,510
>> DAN: Je pense que si, au lieu de l'appel de cette
dans argc et argv chaîne supports

771
00:42:09,510 --> 00:42:14,350
mais a gardé les mêmes types et juste appelé
les quelque chose de différent comme un

772
00:42:14,350 --> 00:42:16,640
et b, serait-il encore travailler?

773
00:42:16,640 --> 00:42:18,790
Et il serait encore travailler,
vous just--

774
00:42:18,790 --> 00:42:21,520
au lieu d'utiliser argc--
vous devriez utiliser a et b.

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

776
00:42:24,436 --> 00:42:25,408
Ouais?

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

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

779
00:42:34,642 --> 00:42:38,850
>> DAN: Donc la question est GetString est
allez stocker la mémoire dans le tas

780
00:42:38,850 --> 00:42:42,280
parce GetString est char *.

781
00:42:42,280 --> 00:42:47,530
Il stocke la mémoire dans le tas, car il
appelle maintenant malloc dans le réel

782
00:42:47,530 --> 00:42:49,258
la mise en oeuvre de GetString.

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

784
00:42:53,210 --> 00:42:55,090
OK, passer.

785
00:42:55,090 --> 00:42:55,950
>> Sécurité.

786
00:42:55,950 --> 00:43:01,090
Donc, pour être vraiment sûr, vous comptez sur aucune
un et vous permettez à personne l'accès à tout

787
00:43:01,090 --> 00:43:04,540
de votre information, ce qui explique pourquoi
chacun construit leurs propres machines,

788
00:43:04,540 --> 00:43:09,580
leurs propres systèmes d'exploitation, tout leur
programmes à partir de zéro, et de toute évidence

789
00:43:09,580 --> 00:43:13,410
ne pas se connecter à d'autres machines
par l'intermédiaire de l'Internet.

790
00:43:13,410 --> 00:43:17,350
Donc, les ordinateurs ne sont pas sûrs.

791
00:43:17,350 --> 00:43:19,200
Ils sont vraiment.

792
00:43:19,200 --> 00:43:20,940
Nous devons faire confiance à d'autres personnes.

793
00:43:20,940 --> 00:43:26,500
>> Et l'idée de sécurité, c'est que vous êtes
tenter de limiter la quantité d'

794
00:43:26,500 --> 00:43:27,540
la confiance que vous avez besoin.

795
00:43:27,540 --> 00:43:32,080
Et l'un des moyens que vous faites
est par la cryptographie.

796
00:43:32,080 --> 00:43:34,950
La cryptographie est, essentiellement,
nous avons secrets.

797
00:43:34,950 --> 00:43:38,880
>> Parfois, nous devons passer nos secrets
le long de travers, par exemple, l'Internet ou

798
00:43:38,880 --> 00:43:39,980
d'autres choses.

799
00:43:39,980 --> 00:43:43,180
Et nous ne voulons pas que les gens
de connaître ces secrets.

800
00:43:43,180 --> 00:43:50,100
Donc, nous chiffrons nos secrets dans un chemin
que nous espérons que personne ne peut comprendre.

801
00:43:50,100 --> 00:43:51,600
>> Donc nous used--

802
00:43:51,600 --> 00:43:54,340
tout au long de cette class--

803
00:43:54,340 --> 00:44:00,750
des choses comme chiffrement de César et
[Inaudible], qui sont tous deux extrêmement

804
00:44:00,750 --> 00:44:03,200
moyens précaires de chiffrer les choses.

805
00:44:03,200 --> 00:44:07,930
Ils sont faciles à comprendre ce qu'ils
sont et quelles sont vos secrets sont.

806
00:44:07,930 --> 00:44:12,130
Le monde réel utilise beaucoup plus
systèmes de cryptage complexes.

807
00:44:12,130 --> 00:44:13,880
Et nous n'allons pas entrer dans
beaucoup plus que cela.

808
00:44:13,880 --> 00:44:18,280

809
00:44:18,280 --> 00:44:19,430
>> Débogage.

810
00:44:19,430 --> 00:44:20,785
GDB est le meilleur.

811
00:44:20,785 --> 00:44:24,014

812
00:44:24,014 --> 00:44:25,810
Je vais insister sur ce message.

813
00:44:25,810 --> 00:44:30,920
Utilisez GDB tout le temps tous les
fois que vous avez un problème.

814
00:44:30,920 --> 00:44:36,030
Les commandes qui sont utiles dans des GDB
cassez, que vous passez soit une ligne

815
00:44:36,030 --> 00:44:41,330
numéro, un nom de fonction, essentiellement
où dans votre code, vous voulez arrêter,

816
00:44:41,330 --> 00:44:45,600
et être en mesure de prendre le contrôle.

817
00:44:45,600 --> 00:44:54,140
>> Imprimer prend une variable et affiche
quelle que soit la variable est à ce

818
00:44:54,140 --> 00:44:55,990
point dans votre exécution.

819
00:44:55,990 --> 00:45:00,130
Se déplace à côté de votre exécution
le long d'un pas.

820
00:45:00,130 --> 00:45:05,050
Et l'étape marches à l'intérieur d'une fonction
dans votre exécution.

821
00:45:05,050 --> 00:45:10,480
>> D'autres choses sont gérées, qui est de savoir comment
vous avez fait votre code.

822
00:45:10,480 --> 00:45:16,630
Continuer prend toutes les mesures nécessaires
pour obtenir au prochain point de rupture.

823
00:45:16,630 --> 00:45:18,300
Et il ya beaucoup, beaucoup d'autres.

824
00:45:18,300 --> 00:45:19,040
Consultez-les.

825
00:45:19,040 --> 00:45:19,901
Ils sont grands.

826
00:45:19,901 --> 00:45:20,863
Ouais?

827
00:45:20,863 --> 00:45:22,113
>> PUBLIC: [inaudible]?

828
00:45:22,113 --> 00:45:26,635

829
00:45:26,635 --> 00:45:28,200
>> DAN: Oui, ce qui est un débogueur.

830
00:45:28,200 --> 00:45:34,230
Ainsi, un débogueur est un programme qui
permet de déboguer votre programme.

831
00:45:34,230 --> 00:45:39,931
Ce n'est pas un programme qui trouve des bugs pour
vous, mais ce serait génial.

832
00:45:39,931 --> 00:45:43,020

833
00:45:43,020 --> 00:45:46,040
>> Et enfin pour moi, c'est la recherche.

834
00:45:46,040 --> 00:45:51,470
Ainsi, les types de recherche dont nous avons parlé
dans cette classe sont la recherche linéaire,

835
00:45:51,470 --> 00:45:55,960
qui est exactement ce que vous regardez à travers chaque
élément de l'espace de recherche, un

836
00:45:55,960 --> 00:46:00,410
élément à la fois, jusqu'à ce que vous trouviez ce que
vous cherchez ou jusqu'à ce que vous atteignez

837
00:46:00,410 --> 00:46:03,350
la fin de votre espace de recherche au cours de laquelle
point vous dites que vous ne pouviez pas trouver

838
00:46:03,350 --> 00:46:06,360
l'élément que vous recherchez.

839
00:46:06,360 --> 00:46:13,450
Et cela prend du temps, au mieux, constante,
qui est de 0 1 et au pire linéaire

840
00:46:13,450 --> 00:46:16,070
temps, qui est de 0 n.

841
00:46:16,070 --> 00:46:19,250
>> Recherche binaire, qui doit
éléments sordides.

842
00:46:19,250 --> 00:46:24,230
Vous allez à la moyenne de vos éléments,
voir si l'élément que vous cherchez

843
00:46:24,230 --> 00:46:30,120
est plus grand ou plus petit que l'élément
que vous êtes au milieu.

844
00:46:30,120 --> 00:46:36,510
Il lui est plus grand, vous dites que le fond
de votre espace de recherche est votre

845
00:46:36,510 --> 00:46:41,550
emplacement actuel, au milieu,
et vous redémarrez le processus.

846
00:46:41,550 --> 00:46:46,150
Si elle est plus petite, vous regardez dire
que the-- ouais, quoi de neuf?

847
00:46:46,150 --> 00:46:47,400
>> PUBLIC: [inaudible]?

848
00:46:47,400 --> 00:46:51,000

849
00:46:51,000 --> 00:46:54,260
>> DAN: Oui.

850
00:46:54,260 --> 00:46:58,360
Toute sorte de tri qui a été enseigné dans
la classe est un jeu équitable pour le test.

851
00:46:58,360 --> 00:47:01,504

852
00:47:01,504 --> 00:47:04,920
>> [Rires]

853
00:47:04,920 --> 00:47:10,260
>> DAN: Et le fait que vous n'avez pas eu
de le faire pour un ensemble de problème, il est juste

854
00:47:10,260 --> 00:47:12,420
Jeu pour le test.

855
00:47:12,420 --> 00:47:15,186
>> PUBLIC: Peut-on aller au-dessus comment to--

856
00:47:15,186 --> 00:47:17,052
>> DAN: Il ne sera plus là-dessus.

857
00:47:17,052 --> 00:47:20,496
>> ENCEINTE 2: Le code réel pour
[Inaudible] est sur study.cs50.net.

858
00:47:20,496 --> 00:47:25,910

859
00:47:25,910 --> 00:47:32,680
Donc, si vous regardez le problème de la pratique
dans la page de tri par fusion de

860
00:47:32,680 --> 00:47:35,880
study.cs50.net, il s'agit du code
pour la mise en œuvre le tri par fusion.

861
00:47:35,880 --> 00:47:38,550
Donc, vous n'avez pas à mettre en œuvre
vous-même ce soir.

862
00:47:38,550 --> 00:47:42,090
Mais assurez-vous de comprendre plutôt
que de le mémoriser.

863
00:47:42,090 --> 00:47:45,035
>> PUBLIC: [inaudible]?

864
00:47:45,035 --> 00:47:49,720
>> ENCEINTE 2: La page de tri par fusion sur
study.cs50.net, il existe une pratique

865
00:47:49,720 --> 00:47:53,570
problème qui, si vous cliquez sur le
problème, à la fin il est

866
00:47:53,570 --> 00:47:56,280
solution, qui est la fusion
la mise en œuvre de tri.

867
00:47:56,280 --> 00:47:58,510
Mais assurez-vous que vous comprenez
plutôt que de simplement mémoriser

868
00:47:58,510 --> 00:47:59,760
ou en le copiant vers le bas.

869
00:47:59,760 --> 00:48:02,870

870
00:48:02,870 --> 00:48:06,340
>> PUBLIC: Et un parfaitement valable
problème pour l'examen serait

871
00:48:06,340 --> 00:48:07,990
quelque chose comme voici une liste.

872
00:48:07,990 --> 00:48:12,100
Qu'est-ce que cette liste ressemble après
une étape de sélections sorte ou

873
00:48:12,100 --> 00:48:13,330
tri par insertion ou autre.

874
00:48:13,330 --> 00:48:14,940
Une itération complète de la liste.

875
00:48:14,940 --> 00:48:18,530
Donc, même si vous ne finissent pas par avoir besoin d'
Code pour cela, vous devez comprendre

876
00:48:18,530 --> 00:48:20,440
assez pour savoir comment ça va
à la modification de ce tableau.

877
00:48:20,440 --> 00:48:24,144

878
00:48:24,144 --> 00:48:25,394
>> DAN: C'est tout pour moi.

879
00:48:25,394 --> 00:48:30,604

880
00:48:30,604 --> 00:48:32,588
>> [Applaudissements]

881
00:48:32,588 --> 00:49:06,316

882
00:49:06,316 --> 00:49:07,410
>> LUCAS: Salut tout le monde.

883
00:49:07,410 --> 00:49:08,390
Mon nom est Lucas.

884
00:49:08,390 --> 00:49:16,840
Je vais parler de la récursivité, tout
les sortes que nous avons apprises, et une

885
00:49:16,840 --> 00:49:18,050
peu de tous les pointeurs.

886
00:49:18,050 --> 00:49:18,740
D'accord?

887
00:49:18,740 --> 00:49:20,340
Alors tout d'abord, la récursivité.

888
00:49:20,340 --> 00:49:22,951
Qu'est-ce que cela signifie de dire que
une fonction est récursive?

889
00:49:22,951 --> 00:49:24,675
>> PUBLIC: se dit.

890
00:49:24,675 --> 00:49:26,500
>> LUCAS: OK, appelle lui-même, oui.

891
00:49:26,500 --> 00:49:27,700
Donc, comme cette image, par exemple.

892
00:49:27,700 --> 00:49:30,280
C'est comme l'image dans
d'une image et ainsi de suite.

893
00:49:30,280 --> 00:49:35,740
Ainsi, par exemple, vous pouvez have-- Dan
qui parlait de recherche binaire.

894
00:49:35,740 --> 00:49:41,840
Une façon dont la recherche est binaire
récursif, c'est le fait que vous êtes

895
00:49:41,840 --> 00:49:43,130
essayer de trouver un certain nombre.

896
00:49:43,130 --> 00:49:44,250
Alors vous allez au milieu.

897
00:49:44,250 --> 00:49:47,130
Et puis vous vérifiez si les numéros là
dans la gauche et dans le droit.

898
00:49:47,130 --> 00:49:49,650
>> Et puis si vous trouvez le nombre est
va être sur la gauche, c'est la même chose

899
00:49:49,650 --> 00:49:53,340
chose que faire de la recherche à nouveau
juste à gauche de la liste.

900
00:49:53,340 --> 00:49:57,350
C'est comme ça que ça sonne
comme c'est récursif.

901
00:49:57,350 --> 00:50:01,870
Donc, c'est pour cela que vous les gars ont récursive
solution pour le tri par fusion.

902
00:50:01,870 --> 00:50:04,270
>> OK, alors voici un exemple.

903
00:50:04,270 --> 00:50:07,280
Donc, disons que je veux choisir
tous les nombres de 1 à n.

904
00:50:07,280 --> 00:50:13,790
Je peux comprendre que la somme des n
nombre est n + n moins 1 à 1.

905
00:50:13,790 --> 00:50:17,810
Mais alors, si je regarde n moins 1 plus
n moins 2 plus 1, c'est la même chose

906
00:50:17,810 --> 00:50:20,680
chose que les numéros de sommation
à n moins 1.

907
00:50:20,680 --> 00:50:25,890
Donc je peux dire la somme d'un montant égal
n est égal, plus la somme de n moins 1.

908
00:50:25,890 --> 00:50:28,010
Cela fait-il sens?

909
00:50:28,010 --> 00:50:32,630
>> Et je voudrais aussi avoir quelque chose d'autre
appelé le scénario de base, qui est que

910
00:50:32,630 --> 00:50:37,440
la somme des nombres des
à zéro serait zéro.

911
00:50:37,440 --> 00:50:42,770
Donc dès que je reçois au nombre
zéro, je m'arrête compter.

912
00:50:42,770 --> 00:50:45,330
Cela fait-il sens?

913
00:50:45,330 --> 00:50:48,120
>> Alors, voici un exemple de la façon dont
Je peux mettre en oeuvre.

914
00:50:48,120 --> 00:50:49,860
J'ai donc cette fonction dans certains.

915
00:50:49,860 --> 00:50:51,700
Cela prend un entier n.

916
00:50:51,700 --> 00:50:56,300
Donc ici, je vérifie d'abord si n est
inférieure ou égale à zéro.

917
00:50:56,300 --> 00:51:00,310
Donc, si ce n'est inférieur ou égal à zéro, je
retourner zéro, ce qui est notre cas de base.

918
00:51:00,310 --> 00:51:05,690
Sinon, je peux retourner n plus
la somme des nombres de

919
00:51:05,690 --> 00:51:07,190
une à n moins un.

920
00:51:07,190 --> 00:51:09,360
Donner un sens?

921
00:51:09,360 --> 00:51:10,100
Dáccord.

922
00:51:10,100 --> 00:51:11,610
>> Alors, voici à quoi il ressemble.

923
00:51:11,610 --> 00:51:15,260
Vous avez somme de 2 égaux
2, plus la somme de 1.

924
00:51:15,260 --> 00:51:18,930
Et quelques-uns des 1 est 1 plus le
somme de 0, ce qui est égal à 0.

925
00:51:18,930 --> 00:51:20,216
Donner un sens?

926
00:51:20,216 --> 00:51:25,342
Donc, si on regarde la pile de votre
programme, c'est à quoi il ressemble.

927
00:51:25,342 --> 00:51:26,820
>> Tout d'abord, nous avons la fonction principale.

928
00:51:26,820 --> 00:51:30,320
Et puis la fonction principale
appelé somme 2.

929
00:51:30,320 --> 00:51:36,690
Et puis somme 2 va dire, oh, somme
2 est égal à 2, plus la somme de un.

930
00:51:36,690 --> 00:51:39,460
J'ajoute donc une somme de 1 sur la pile.

931
00:51:39,460 --> 00:51:43,860
Et la somme de 1 va appeler somme de
0, ce qui va également être ajoutée

932
00:51:43,860 --> 00:51:44,630
de la pile.

933
00:51:44,630 --> 00:51:49,240
Et puis chacun de ces ceux qui sont
au-dessus de l'autre à revenir

934
00:51:49,240 --> 00:51:52,020
avant les autres peuvent continuer.

935
00:51:52,020 --> 00:51:56,240
>> Ainsi, par exemple, ici, somme de 0,
la première, va retourner 0.

936
00:51:56,240 --> 00:51:58,320
Et puis choisissez une somme de 1.

937
00:51:58,320 --> 00:52:00,850
Ensuite, une somme de 1 va
revenir 1 à la somme des deux.

938
00:52:00,850 --> 00:52:03,900
Et enfin, une somme de 2 va
pour revenir à 3 principale.

939
00:52:03,900 --> 00:52:05,320
Cela fait-il sens?

940
00:52:05,320 --> 00:52:09,496
>> Il est vraiment important de comprendre comment
la pile fonctionne et essayer de

941
00:52:09,496 --> 00:52:11,980
voir si cela fait sens.

942
00:52:11,980 --> 00:52:13,260
OK, donc le tri.

943
00:52:13,260 --> 00:52:16,170
Alors, pourquoi est tri importante,
tout d'abord?

944
00:52:16,170 --> 00:52:18,260
Pourquoi devrions-nous nous en soucier?

945
00:52:18,260 --> 00:52:20,310
N'importe qui?

946
00:52:20,310 --> 00:52:20,695
Donnez-moi un exemple?

947
00:52:20,695 --> 00:52:21,040
Ouais?

948
00:52:21,040 --> 00:52:22,968
>> PUBLIC: [inaudible].

949
00:52:22,968 --> 00:52:24,700
>> LUCAS: Ouais, OK.

950
00:52:24,700 --> 00:52:26,090
Ainsi, vous pouvez effectuer une recherche plus efficace.

951
00:52:26,090 --> 00:52:28,580
C'est un bon moyen.

952
00:52:28,580 --> 00:52:32,462
Ainsi, par exemple, nous avons beaucoup de
choses, en fait, dans nos vies qui

953
00:52:32,462 --> 00:52:32,920
sont triés.

954
00:52:32,920 --> 00:52:34,830
Par exemple, des dictionnaires.

955
00:52:34,830 --> 00:52:39,210
>> Il est très important d'avoir toutes les
mots un peu d'ordre que nous

956
00:52:39,210 --> 00:52:41,970
peuvent accéder facilement.

957
00:52:41,970 --> 00:52:43,280
Voilà ce qu'il disait.

958
00:52:43,280 --> 00:52:45,530
Vous pouvez effectuer une recherche plus efficace.

959
00:52:45,530 --> 00:52:48,740
Pensez à la façon dont il serait difficile d'avoir un
dictionnaire dans lequel les mots sont en

960
00:52:48,740 --> 00:52:49,500
un ordre aléatoire.

961
00:52:49,500 --> 00:52:53,120
Vous aurez à regarder, à peu près,
chaque mot jusqu'à ce que vous trouviez le

962
00:52:53,120 --> 00:52:54,720
mot que vous cherchez.

963
00:52:54,720 --> 00:52:58,710
>> Si vous utilisez Facebook aussi, quand
vous cherchez à vos amis, vous êtes

964
00:52:58,710 --> 00:53:03,540
allez voir que Facebook a mis à votre
ami proche est au-dessus de ceux

965
00:53:03,540 --> 00:53:05,470
que vous ne parlez pas à grand-chose.

966
00:53:05,470 --> 00:53:08,080
Si vous allez tout le chemin vers le bas de
votre liste d'amis, vous allez voir

967
00:53:08,080 --> 00:53:11,250
les gens que vous n'avez probablement pas encore
n'oubliez pas que vous êtes amis avec.

968
00:53:11,250 --> 00:53:14,590
Et c'est parce que les sortes Facebook
vos amis en fonction de la façon dont

969
00:53:14,590 --> 00:53:16,472
vous êtes proche d'eux.

970
00:53:16,472 --> 00:53:17,930
>> Donc, l'organisation des données.

971
00:53:17,930 --> 00:53:18,450
Aussi Pokemon.

972
00:53:18,450 --> 00:53:21,400
Donc, vous voyez que tous les Pokémons
disposer d'un nombre.

973
00:53:21,400 --> 00:53:27,210
Et c'est comme un simple
chemin d'accès aux données.

974
00:53:27,210 --> 00:53:29,050
>> PUBLIC: Accès Pokemon.

975
00:53:29,050 --> 00:53:29,890
>> LUCAS: Ouais.

976
00:53:29,890 --> 00:53:32,395
>> PUBLIC: [inaudible].

977
00:53:32,395 --> 00:53:33,460
>> LUCAS: Ouais.

978
00:53:33,460 --> 00:53:35,140
OK, donc la sélection sorte.

979
00:53:35,140 --> 00:53:41,610
Sélection sorte va sélectionner le
plus petite valeur d'une liste non triés chaque

980
00:53:41,610 --> 00:53:43,300
temps à chaque itération.

981
00:53:43,300 --> 00:53:46,800
C'est un peu comme le genre que vous faites
dans votre tête quand vous essayez de

982
00:53:46,800 --> 00:53:48,430
trier une liste en main.

983
00:53:48,430 --> 00:53:51,990
>> Fondamentalement, vous ne faites que vous regardez
pour le plus petit nombre.

984
00:53:51,990 --> 00:53:54,280
Vous le mettez dans la liste triée.

985
00:53:54,280 --> 00:53:56,230
Et puis vous regardez pour la
plus petit nombre suivant.

986
00:53:56,230 --> 00:54:00,080
Et puis vous continuez à faire
que et ainsi de suite.

987
00:54:00,080 --> 00:54:04,600
>> Donc, la sélection sorte est, fondamentalement, vous
sélectionner à chaque fois la plus petite

988
00:54:04,600 --> 00:54:05,750
valeur non triés.

989
00:54:05,750 --> 00:54:10,840
Mettre à la fin de la liste triée
partie de la liste.

990
00:54:10,840 --> 00:54:12,370
Et continuer à le faire.

991
00:54:12,370 --> 00:54:15,890
Voyons rapidement ce
cela ressemble.

992
00:54:15,890 --> 00:54:19,340
Alors, voici la liste triée
et la liste non triée.

993
00:54:19,340 --> 00:54:23,350
>> Donc, pour le tri de la liste,
il est initialement vide.

994
00:54:23,350 --> 00:54:26,760
Et puis je vais sélectionner le
plus petit nombre ici, qui est de 2.

995
00:54:26,760 --> 00:54:30,650
Donc, je reçois le numéro 2 et je mets
à l'avant de la liste.

996
00:54:30,650 --> 00:54:34,910
Et puis je regarde pour la prochaine plus petite
élément, qui est de 3.

997
00:54:34,910 --> 00:54:37,050
Donc, je l'ai mis à la fin
de la liste triée.

998
00:54:37,050 --> 00:54:38,140
Et puis je continue à le faire.

999
00:54:38,140 --> 00:54:40,040
Je trouve 4 et le mettre à la fin.

1000
00:54:40,040 --> 00:54:41,360
Trouver 5 et le mettre à la fin.

1001
00:54:41,360 --> 00:54:44,830
>> Et regardez comment tous ces moments que
Je veux dire le mettre à la fin est,

1002
00:54:44,830 --> 00:54:46,850
essentiellement, en échangeant deux valeurs.

1003
00:54:46,850 --> 00:54:48,100
D'accord?

1004
00:54:48,100 --> 00:54:50,140

1005
00:54:50,140 --> 00:54:52,825
Et puis la dernière, que vous venez de
disposer un élément de plus.

1006
00:54:52,825 --> 00:54:55,870
Donc, il est déjà trié.

1007
00:54:55,870 --> 00:54:57,800
>> OK, donc le tri par insertion.

1008
00:54:57,800 --> 00:55:03,180
Le tri par insertion, vous allez avoir également
que chose d'avoir un triés et

1009
00:55:03,180 --> 00:55:04,690
une liste non triée.

1010
00:55:04,690 --> 00:55:14,540
La seule chose, c'est que chaque fois que
vous ajoutez un élément à la liste triée

1011
00:55:14,540 --> 00:55:18,170
liste, il vous suffit de choisir l'élément que
est en face de la liste triée.

1012
00:55:18,170 --> 00:55:20,880
Et puis vous allez trouver ce que
position, il devrait être dans le tri

1013
00:55:20,880 --> 00:55:22,300
partie de la liste.

1014
00:55:22,300 --> 00:55:25,840
>> Voyons ce que cela est si
cela fait plus de sens.

1015
00:55:25,840 --> 00:55:29,360
Donc, d'abord, par exemple, je suis en train
insérer le numéro trois dans le

1016
00:55:29,360 --> 00:55:30,680
partie de la liste triée.

1017
00:55:30,680 --> 00:55:31,800
Ainsi, la liste n'a rien.

1018
00:55:31,800 --> 00:55:34,160
Donc, je ne peux mettre le numéro 3.

1019
00:55:34,160 --> 00:55:37,480
>> Maintenant, je tiens à ajouter le nombre de 5 à
la partie triée de la liste.

1020
00:55:37,480 --> 00:55:38,900
Donc je regarde le nombre 5.

1021
00:55:38,900 --> 00:55:40,450
Je remarque que c'est plus grand que 3.

1022
00:55:40,450 --> 00:55:41,980
Donc, je sais que ce doit être après 3.

1023
00:55:41,980 --> 00:55:44,100
Alors, j'ai mis 3 et 5.

1024
00:55:44,100 --> 00:55:45,940
>> Ensuite, je veux insérer le numéro 2.

1025
00:55:45,940 --> 00:55:51,630
Je remarque que le numéro 2 est en fait
durer alors à la fois 3 et 5.

1026
00:55:51,630 --> 00:55:54,580
J'ai donc fait de mettre tout le
moyen au début de la liste.

1027
00:55:54,580 --> 00:55:59,030
Je dois donc, en quelque sorte, passer tous les
éléments dans la liste triée afin que je puisse

1028
00:55:59,030 --> 00:56:01,970
faire de la place pour le numéro 2.

1029
00:56:01,970 --> 00:56:03,160
>> Puis je vois le nombre 6.

1030
00:56:03,160 --> 00:56:05,450
Je vois que cela devrait être après 5.

1031
00:56:05,450 --> 00:56:06,240
Donc, je l'ai mis là.

1032
00:56:06,240 --> 00:56:07,965
Et enfin, je regarde le nombre 4.

1033
00:56:07,965 --> 00:56:11,030
Et je remarque qu'il devrait
être comprise entre 3 et 5.

1034
00:56:11,030 --> 00:56:14,870
Et puis je l'ai mis là et changement
tous les autres éléments.

1035
00:56:14,870 --> 00:56:16,120
Donner un sens?

1036
00:56:16,120 --> 00:56:17,880

1037
00:56:17,880 --> 00:56:19,150
>> Bubble Sort.

1038
00:56:19,150 --> 00:56:25,730
Alors tri à bulles est essentiellement ce que vous êtes
aller à do-- nous appelons bulle

1039
00:56:25,730 --> 00:56:30,113
sorte parce que vous passez par le films--
c'est en fait mieux si je montre juste

1040
00:56:30,113 --> 00:56:32,300
vous aimez this--

1041
00:56:32,300 --> 00:56:35,030
et vous allez comparer
nombres adjacents.

1042
00:56:35,030 --> 00:56:38,410
Et vous allez échanger leur
positions si elles ne sont pas

1043
00:56:38,410 --> 00:56:39,190
dans le bon ordre.

1044
00:56:39,190 --> 00:56:42,570
>> Donc, fondamentalement, ce qui se passe à
arriver, c'est ici, par exemple,

1045
00:56:42,570 --> 00:56:44,160
vous avez 8 et 6.

1046
00:56:44,160 --> 00:56:47,270
Vous savez que l'ordre de tri sera
effectivement 6 et 5, non?

1047
00:56:47,270 --> 00:56:49,540
Donc, vous allez inverser les commandes.

1048
00:56:49,540 --> 00:56:51,370
Puis je vois 8 et 4 ici.

1049
00:56:51,370 --> 00:56:52,250
Et je fais la même chose.

1050
00:56:52,250 --> 00:56:53,400
J'échange nouveau.

1051
00:56:53,400 --> 00:56:55,070
Et enfin, 2 et 8.

1052
00:56:55,070 --> 00:56:56,670
Je les échanger aussi.

1053
00:56:56,670 --> 00:57:01,690
>> C'est ce qu'on appelle de tri à bulles car après
chacune de ces itérations, en fait,

1054
00:57:01,690 --> 00:57:05,910
le plus grand nombre dans la liste obtient tout
le moyen de la fin de la liste.

1055
00:57:05,910 --> 00:57:06,940
Cela fait-il sens?

1056
00:57:06,940 --> 00:57:11,880
Car il maintient l'échangeant
et le déplacer vers la droite.

1057
00:57:11,880 --> 00:57:14,440
>> OK, c'est donc la seconde itération.

1058
00:57:14,440 --> 00:57:17,200
Ce serait la même chose.

1059
00:57:17,200 --> 00:57:20,190
Je vais faire un échange et
puis le dernier.

1060
00:57:20,190 --> 00:57:23,290
Je qu'il n'y a pas échanges
et la liste est triée.

1061
00:57:23,290 --> 00:57:27,460
Ainsi, dans Bubble Sort, nous gardons essentiellement
en passant par la liste et l'échange

1062
00:57:27,460 --> 00:57:32,310
choses jusqu'à ce que je remarque que je n'ai pas fait
des swaps faisant cette itération, qui

1063
00:57:32,310 --> 00:57:34,270
signifie que la liste est déjà trié.

1064
00:57:34,270 --> 00:57:35,520
Donner un sens?

1065
00:57:35,520 --> 00:57:38,400

1066
00:57:38,400 --> 00:57:40,870
>> Parlons un peu
sur temps de fonctionnement.

1067
00:57:40,870 --> 00:57:45,165
Alors que vous les gars me souviens Big
O, Omega, et Theta?

1068
00:57:45,165 --> 00:57:49,290

1069
00:57:49,290 --> 00:57:50,990
Ouais?

1070
00:57:50,990 --> 00:57:53,070
OK, ce qui est Big O, tout d'abord?

1071
00:57:53,070 --> 00:57:54,315
>> PUBLIC: [inaudible].

1072
00:57:54,315 --> 00:57:59,070
>> LUCAS: Ouais, ça s'appelle le pire des cas
l'exécution, ce qui signifie simplement que c'est

1073
00:57:59,070 --> 00:58:03,470
combien vous vous attendez le programme
à prendre afin de fonctionner.

1074
00:58:03,470 --> 00:58:04,910
Comme, en termes de--

1075
00:58:04,910 --> 00:58:06,660
en ce case-- n.

1076
00:58:06,660 --> 00:58:09,150
Le nombre d'éléments dans le
liste dans le pire des cas.

1077
00:58:09,150 --> 00:58:12,520
Comme, dans le pire des cas.

1078
00:58:12,520 --> 00:58:17,100
>> Donc, pour Bubble Trier, par exemple,
nous avons Big O n place.

1079
00:58:17,100 --> 00:58:20,580
Pourquoi avons-nous cela?

1080
00:58:20,580 --> 00:58:24,716
Pourquoi est-Bubble Trier Big O n place?

1081
00:58:24,716 --> 00:58:27,614
>> PUBLIC: [inaudible].

1082
00:58:27,614 --> 00:58:35,670
>> LUCAS: Ouais, donc le pire des cas sera
que je vais devoir faire n itérations.

1083
00:58:35,670 --> 00:58:39,260
Ainsi, chacune des itérations va
apporter le plus grand élément de la fin

1084
00:58:39,260 --> 00:58:40,290
de la liste.

1085
00:58:40,290 --> 00:58:44,230
Donc le pire des cas, c'est que j'ai
de faire cette chose n fois.

1086
00:58:44,230 --> 00:58:48,550
Et pour chacun de ces moments, je dois
faire n swaps parce que je dois comparer

1087
00:58:48,550 --> 00:58:49,870
chaque fois deux éléments.

1088
00:58:49,870 --> 00:58:53,730
Voilà pourquoi il est n au carré
parce qu'il est n fois n.

1089
00:58:53,730 --> 00:59:00,120
>> Ensuite, la sélection sorte est également n carré
parce que, pour chaque itération, je dois

1090
00:59:00,120 --> 00:59:02,650
regarder chaque élément
dans la liste.

1091
00:59:02,650 --> 00:59:04,980
Et puis trouver le plus petit,
ce qui signifie que je dois

1092
00:59:04,980 --> 00:59:06,130
regarder par n éléments.

1093
00:59:06,130 --> 00:59:11,750
Et je dois faire ce que n fois parce
Je dois sélectionner tous les n éléments.

1094
00:59:11,750 --> 00:59:18,273
>> Un tri par insertion est également n carré
parce que le pire des cas sera

1095
00:59:18,273 --> 00:59:20,950
être, un, je dois insérer
n nombres, non?

1096
00:59:20,950 --> 00:59:22,765
Donc, je sais déjà que je vais
d'avoir n itérations.

1097
00:59:22,765 --> 00:59:25,466

1098
00:59:25,466 --> 00:59:29,840
Mais pour chacun de ces numéros, si j'avais
regarder tous les numéros dans

1099
00:59:29,840 --> 00:59:34,380
la liste triée et il a mis tout le chemin
à l'avant, ce sera n carré

1100
00:59:34,380 --> 00:59:36,230
car il sera n fois n nouveau.

1101
00:59:36,230 --> 00:59:38,280
Donner un sens?

1102
00:59:38,280 --> 00:59:41,512
Qu'en est-il oméga?

1103
00:59:41,512 --> 00:59:42,886
>> PUBLIC: [inaudible].

1104
00:59:42,886 --> 00:59:44,620
>> LUCAS: C'est le meilleur des cas.

1105
00:59:44,620 --> 00:59:48,810
Donc, c'est comme dans un grand nombre de fois pour
le tri, le meilleur scénario est

1106
00:59:48,810 --> 00:59:50,660
lorsque la liste est déjà trié.

1107
00:59:50,660 --> 00:59:52,670
Donc, vous n'avez pas vraiment
de faire quelque chose.

1108
00:59:52,670 --> 00:59:56,290
Bubble Trier a le meilleur
scénario de n.

1109
00:59:56,290 --> 00:59:58,820
Avez-vous les gars savent pourquoi?

1110
00:59:58,820 --> 01:00:00,620
>> PUBLIC: [inaudible].

1111
01:00:00,620 --> 01:00:05,640
>> LUCAS: Ouais, si vous gardez une trace de
si ration de données avait des swaps ou

1112
01:00:05,640 --> 01:00:10,533
pas, si vous avez quelque chose comme mis à
vrai si il y avait une itération, si la

1113
01:00:10,533 --> 01:00:15,140
liste est déjà trié, essentiellement,
ce qui va se passer, c'est que je vais

1114
01:00:15,140 --> 01:00:17,890
essayer de déplacer chaque deux
les éléments adjacents.

1115
01:00:17,890 --> 01:00:19,920
Je vais voir ce que
il n'y a pas de swaps.

1116
01:00:19,920 --> 01:00:21,230
Et je viens de revenir tout de suite.

1117
01:00:21,230 --> 01:00:24,240
>> Donc, cela signifie que j'ai juste eu à
parcourir la liste une fois.

1118
01:00:24,240 --> 01:00:28,990
C'est donc n parce que je regarde
à n éléments.

1119
01:00:28,990 --> 01:00:30,930
Pourquoi la sélection sorte n carré?

1120
01:00:30,930 --> 01:00:35,150

1121
01:00:35,150 --> 01:00:45,520
>> Oui, même si la liste est triée, pour
chaque itération de la sélection sorte, je

1122
01:00:45,520 --> 01:00:47,590
avoir à sélectionner l'élément minimum.

1123
01:00:47,590 --> 01:00:49,980
Donc, cela signifie que je dois à sa recherche
à tous les éléments de la non triés

1124
01:00:49,980 --> 01:00:53,350
la liste et trouver le minimum
pour chaque itération.

1125
01:00:53,350 --> 01:00:54,600
Cela fait-il sens?

1126
01:00:54,600 --> 01:00:56,880

1127
01:00:56,880 --> 01:01:04,690
>> Et l'insertion épée est n parce que dans le
cas que je suis en train d'insérer la

1128
01:01:04,690 --> 01:01:09,320
nombres et tous les chiffres, lorsque je
essayer de les insérer, je vois qu'ils

1129
01:01:09,320 --> 01:01:10,510
sont dans la bonne position.

1130
01:01:10,510 --> 01:01:15,120
Je n'ai pas à aller voir tous les autres
numéros de la liste non triée.

1131
01:01:15,120 --> 01:01:17,170
Voilà pourquoi il sera n.

1132
01:01:17,170 --> 01:01:19,480
Donner un sens?

1133
01:01:19,480 --> 01:01:21,035
Et ce qui est thêta?

1134
01:01:21,035 --> 01:01:23,410
>> PUBLIC: [inaudible].

1135
01:01:23,410 --> 01:01:24,380
>> LUCAS: Qu'est-ce, désolé?

1136
01:01:24,380 --> 01:01:24,960
Dites-le à nouveau.

1137
01:01:24,960 --> 01:01:25,666
>> PUBLIC: [inaudible].

1138
01:01:25,666 --> 01:01:26,490
>> LUCAS: Exactement.

1139
01:01:26,490 --> 01:01:31,280
Donc vous pouvez voir que seule la sélection
stockée dans Merge avoir thetas sorte.

1140
01:01:31,280 --> 01:01:39,920
Et c'est parce que vous avez seulement thêta
si les deux Big O et Omega sont les mêmes.

1141
01:01:39,920 --> 01:01:41,520
Dáccord.

1142
01:01:41,520 --> 01:01:44,210
Et enfin, le tri par fusion-dire dans le journal n.

1143
01:01:44,210 --> 01:01:48,910
>> Et puis, comme Dan a dit, le tri par fusion
est un peu comme de la même manière que

1144
01:01:48,910 --> 01:01:50,320
vous faites une recherche binaire.

1145
01:01:50,320 --> 01:01:53,530
Ainsi, vous obtenez la liste.

1146
01:01:53,530 --> 01:01:55,170
Et vous allez couper en deux.

1147
01:01:55,170 --> 01:02:00,580
Et puis, vous les coupez
en petites parties.

1148
01:02:00,580 --> 01:02:01,730
Et puis, vous les fusionner.

1149
01:02:01,730 --> 01:02:02,960
Les gars, vous vous souvenez que, non?

1150
01:02:02,960 --> 01:02:04,960
OK, comme il disait.

1151
01:02:04,960 --> 01:02:08,330
>> OK, pointeurs.

1152
01:02:08,330 --> 01:02:11,078
Donc, ce qui est un pointeur?

1153
01:02:11,078 --> 01:02:12,050
>> PUBLIC: [inaudible].

1154
01:02:12,050 --> 01:02:12,820
>> LUCAS: Une adresse.

1155
01:02:12,820 --> 01:02:13,720
Dáccord.

1156
01:02:13,720 --> 01:02:18,530
Je sais que David montre un tas de
vidéos de Binky et les choses pointant

1157
01:02:18,530 --> 01:02:19,080
l'un l'autre.

1158
01:02:19,080 --> 01:02:22,960
Mais je me plais à penser de pointeurs
comme une simple adresse.

1159
01:02:22,960 --> 01:02:26,110
Donc, c'est une variable qui va
pour stocker une adresse.

1160
01:02:26,110 --> 01:02:31,940
>> Donc, c'est juste cette variable spéciale
c'est-à quatre octets de long.

1161
01:02:31,940 --> 01:02:36,550
Rappelez-vous, ce pointeur à quoi que ce soit est
toujours quatre octets de long pour notre 32-bit

1162
01:02:36,550 --> 01:02:39,370
machine pour le cas
l'appareil.

1163
01:02:39,370 --> 01:02:41,920

1164
01:02:41,920 --> 01:02:47,050
Et il vient de l'emplacement
d'une variable à l'intérieur de celui-ci.

1165
01:02:47,050 --> 01:02:50,240
>> OK, donc il ya cette mémoire, essentiellement.

1166
01:02:50,240 --> 01:02:57,420
Ainsi, chaque bloc de mémoire a effectivement un
étiquette, qui est l'adresse de l'

1167
01:02:57,420 --> 01:02:58,890
mémoire slotty.

1168
01:02:58,890 --> 01:03:02,370
Donc, cela signifie que je peux avoir
un pointeur vers

1169
01:03:02,370 --> 01:03:03,380
l'une de ces adresses.

1170
01:03:03,380 --> 01:03:09,930
Donc la raison pour laquelle nous allons utiliser des pointeurs est
si je dois me rappeler de l'emplacement

1171
01:03:09,930 --> 01:03:12,300
une variable qui est spécifique d'une mémoire.

1172
01:03:12,300 --> 01:03:16,560
>> Et vous les gars n'oubliez pas que l'un de ceux
cas était si j'ai une fonction

1173
01:03:16,560 --> 01:03:20,820
si j'ai fait vous voulez
swap pour reals, j'ai effectivement

1174
01:03:20,820 --> 01:03:22,110
avoir à envoyer un pointeur.

1175
01:03:22,110 --> 01:03:23,460
Pas la variable.

1176
01:03:23,460 --> 01:03:25,200
Avez-vous les gars Rappelez-vous que?

1177
01:03:25,200 --> 01:03:26,450
La différence de between--

1178
01:03:26,450 --> 01:03:33,350

1179
01:03:33,350 --> 01:03:34,120
quel est le nom?

1180
01:03:34,120 --> 01:03:36,010
Appel par valeur et en appelant
par référence, non?

1181
01:03:36,010 --> 01:03:36,840
>> OK, ouais.

1182
01:03:36,840 --> 01:03:38,330
Alors, appelez en valeur.

1183
01:03:38,330 --> 01:03:43,570
Lorsque vous suffit d'envoyer une variable à
la fonction que vous êtes juste envoyer une valeur.

1184
01:03:43,570 --> 01:03:45,610
Donc vous êtes en train d'envoyer
une copie de la variable.

1185
01:03:45,610 --> 01:03:49,720
Et votre programme s'en fout
Et si la même variable effectivement

1186
01:03:49,720 --> 01:03:51,650
fait une copie.

1187
01:03:51,650 --> 01:03:56,330
>> Et appelant par des moyens de référence qui
Je suis en train d'envoyer une copie de la

1188
01:03:56,330 --> 01:03:57,550
pointeur vers cette variable.

1189
01:03:57,550 --> 01:04:00,970
Donc, cela signifie que je suis l'envoi de la
emplacement de cette variable.

1190
01:04:00,970 --> 01:04:04,440
Donc, je dois sentir l'emplacement de l'
variables, quand je l'appelle la fonction

1191
01:04:04,440 --> 01:04:09,700
avec des pointeurs, je suis en mesure de réellement
modifier les données qui étaient en principal.

1192
01:04:09,700 --> 01:04:12,050
Donner un sens?

1193
01:04:12,050 --> 01:04:17,560
>> Bien que, le pointeur est une copie, la
pointeur a toujours l'adresse réelle de

1194
01:04:17,560 --> 01:04:20,090
la variable que je veux changer.

1195
01:04:20,090 --> 01:04:21,920
Donner un sens?

1196
01:04:21,920 --> 01:04:24,290
>> Créant ainsi des pointeurs.

1197
01:04:24,290 --> 01:04:28,410
Rappelez-vous, le pointeur ont toujours
le type que c'est pointant

1198
01:04:28,410 --> 01:04:29,890
puis à une étoile.

1199
01:04:29,890 --> 01:04:31,030
Et puis vous mettez le nom.

1200
01:04:31,030 --> 01:04:35,765
Alors, n'oubliez pas que chaque fois que vous avez
quelle que soit étoiles, c'est comme un pointeur vers

1201
01:04:35,765 --> 01:04:38,990
que toute variable
taper que vous aviez.

1202
01:04:38,990 --> 01:04:42,850
>> Donc, ici en étoile, par exemple, il est
un pointeur et un entier.

1203
01:04:42,850 --> 01:04:47,680
Et puis l'omble étoiles est un pointeur
étoiles de carbonisation et ainsi de suite.

1204
01:04:47,680 --> 01:04:47,960
Ouais?

1205
01:04:47,960 --> 01:04:52,710
>> PUBLIC: Que faire si nous avons un
pointeur de n à l'étoile x.

1206
01:04:52,710 --> 01:04:55,255
Je sais que cela crée un pointeur vers x.

1207
01:04:55,255 --> 01:04:59,432
Est-il aussi déclarer x un entier?

1208
01:04:59,432 --> 01:05:05,170
>> LUCAS: OK, donc quand vous dites n star du x,
vous n'êtes pas la création d'un pointeur vers une

1209
01:05:05,170 --> 01:05:06,000
variable x.

1210
01:05:06,000 --> 01:05:08,170
Vous créez un pointeur nommé x.

1211
01:05:08,170 --> 01:05:09,396
>> PUBLIC: [inaudible].

1212
01:05:09,396 --> 01:05:14,250
>> LUCAS: Alors quand je dis n star du x, je suis
dire, hey, dans la mémoire, je vais

1213
01:05:14,250 --> 01:05:16,390
obtenir un de ces trois cases.

1214
01:05:16,390 --> 01:05:20,750
Et je vais vous dire que ce
va être x, qui est

1215
01:05:20,750 --> 01:05:22,000
va être un pointeur.

1216
01:05:22,000 --> 01:05:26,860

1217
01:05:26,860 --> 01:05:30,640
Et quelque chose d'intéressant à propos des pointeurs
c'est que nous disent qu'ils ont

1218
01:05:30,640 --> 01:05:32,620
4 octets pour une machine de 32 bits.

1219
01:05:32,620 --> 01:05:36,320
Et la raison en est que
4 octets sont 32 bits.

1220
01:05:36,320 --> 01:05:40,490
>> Et les machines qui sont 64 bits fait
avoir des adresses des pointeurs

1221
01:05:40,490 --> 01:05:43,480
qui sont de 64 bits.

1222
01:05:43,480 --> 01:05:49,820
Donc, cela signifie juste que la taille de la
adresses de la machine est différente.

1223
01:05:49,820 --> 01:05:52,270
>> Donc, le référencement et déréférencement.

1224
01:05:52,270 --> 01:05:54,310
Il ya deux opérateurs
Vous devriez retenir.

1225
01:05:54,310 --> 01:05:55,450
Le premier est esperluette.

1226
01:05:55,450 --> 01:05:56,810
La seconde est l'étoile.

1227
01:05:56,810 --> 01:06:05,060
Ne vous trompez pas de cette étoile et ce
STAR souvenir parce que, dans

1228
01:06:05,060 --> 01:06:06,950
ce cas, vous avez n étoiles.

1229
01:06:06,950 --> 01:06:08,700
>> C'est comme une chose tout à l'autre.

1230
01:06:08,700 --> 01:06:10,720
Il n'y a pas étoile n de l'espace.

1231
01:06:10,720 --> 01:06:12,070
Donc, cela signifie que c'est le type.

1232
01:06:12,070 --> 01:06:14,870
Rappelez-vous que, lorsque vous avez
l'étoile variable, vous êtes

1233
01:06:14,870 --> 01:06:16,230
parler de ce type.

1234
01:06:16,230 --> 01:06:20,540
>> Lorsque vous avez juste étoiles puis l'
Nom de la variable, cela signifie que

1235
01:06:20,540 --> 01:06:24,100
vous déréférencement du pointeur, qui
signifie que vous êtes à la recherche à la

1236
01:06:24,100 --> 01:06:28,290
pointeur, trouver l'adresse c'est
montrant, d'aller à cette adresse,

1237
01:06:28,290 --> 01:06:30,850
et en regardant chaque fois
vous avez là.

1238
01:06:30,850 --> 01:06:34,310
Donc, je dis à mes étudiants que lorsque vous avez
étoiles, vous devriez penser que c'est

1239
01:06:34,310 --> 01:06:36,850
l'abréviation du contenu de.

1240
01:06:36,850 --> 01:06:39,770
>> Donc si vous avez un pointeur et vous
faire pointeur étoiles, c'est le

1241
01:06:39,770 --> 01:06:41,720
le contenu du pointeur.

1242
01:06:41,720 --> 01:06:44,580
Alors vous allez à ce qu'il pointe vers
et regarder le contenu constant.

1243
01:06:44,580 --> 01:06:47,730
Et l'esperluette est le même
chose que l'adresse du.

1244
01:06:47,730 --> 01:06:52,560
>> Donc, si j'ai une variable un-- comme, disons
dire que j'ai fait un int est égal 3--

1245
01:06:52,560 --> 01:06:56,900
si je veux trouver l'adresse de ce
une mémoire de variables, je ne peux faire

1246
01:06:56,900 --> 01:06:58,240
Ampersand a.

1247
01:06:58,240 --> 01:07:00,280
C'est donc l'adresse d'un.

1248
01:07:00,280 --> 01:07:01,530
Donner un sens?

1249
01:07:01,530 --> 01:07:03,790

1250
01:07:03,790 --> 01:07:05,040
>> Alors, voici un exemple.

1251
01:07:05,040 --> 01:07:08,370

1252
01:07:08,370 --> 01:07:11,530
Ce manque int b et c int.

1253
01:07:11,530 --> 01:07:16,520
Donc int a est égal à 3 signifie que
Je vais aller à la mémoire.

1254
01:07:16,520 --> 01:07:19,870
Et je vais trouver un logement
et mettre le numéro 3 ici.

1255
01:07:19,870 --> 01:07:22,200
>> Et puis int b est égal à 4.

1256
01:07:22,200 --> 01:07:23,100
Je vais faire la même chose.

1257
01:07:23,100 --> 01:07:25,840
Aller à la mémoire et mettre un certain nombre
4 dans l'une des boîtes.

1258
01:07:25,840 --> 01:07:27,100
Et int est égal à 5.

1259
01:07:27,100 --> 01:07:29,740
Trouver une autre boîte et mettre un nombre à 5.

1260
01:07:29,740 --> 01:07:36,160
>> Alors, quelle est cette ligne de faire sortir?
n pa étoiles est égal à un esperluette.

1261
01:07:36,160 --> 01:07:37,800
Alors tout d'abord, n pa étoiles.

1262
01:07:37,800 --> 01:07:39,050
Que fait-il?

1263
01:07:39,050 --> 01:07:40,930

1264
01:07:40,930 --> 01:07:42,298
>> PUBLIC: [inaudible].

1265
01:07:42,298 --> 01:07:47,890
>> LUCAS: Ouais, donc n pa étoiles, d'abord,
déclare un pointeur appelé pa.

1266
01:07:47,890 --> 01:07:53,720
Et puis il est affectant la valeur
ce pointeur pour être l'adresse d'un.

1267
01:07:53,720 --> 01:07:55,790
Donc esperluette un.

1268
01:07:55,790 --> 01:07:58,510
Ensuite, si je fais pb étoiles,
ce qui est un pb étoiles?

1269
01:07:58,510 --> 01:08:02,418

1270
01:08:02,418 --> 01:08:03,150
>> Oh, désolé.

1271
01:08:03,150 --> 01:08:06,330
Ceci est également absente. n pb étoiles.

1272
01:08:06,330 --> 01:08:07,905
Je veux dire pc étoiles.

1273
01:08:07,905 --> 01:08:11,200
Je suis tellement désolé.

1274
01:08:11,200 --> 01:08:11,940
C'est la même chose.

1275
01:08:11,940 --> 01:08:16,408
Mais maintenant je suis bien ar la création d'un pointeur
à b et un pointeur vers c.

1276
01:08:16,408 --> 01:08:16,886
Ouais?

1277
01:08:16,886 --> 01:08:18,136
>> PUBLIC: [inaudible]?

1278
01:08:18,136 --> 01:08:25,490

1279
01:08:25,490 --> 01:08:26,670
>> LUCAS: Oui.

1280
01:08:26,670 --> 01:08:32,630
Donc, si vous allez à la mémoire et vous allez à
la boîte qui est l'indicateur de pa,

1281
01:08:32,630 --> 01:08:37,149
vous allez effectivement
voir l'adresse d'un.

1282
01:08:37,149 --> 01:08:38,399
D'accord?

1283
01:08:38,399 --> 01:08:42,970

1284
01:08:42,970 --> 01:08:43,300
Ouais?

1285
01:08:43,300 --> 01:08:45,605
>> PUBLIC: [inaudible]?

1286
01:08:45,605 --> 01:08:49,260
>> LUCAS: Ouais, pointeur est une adresse.

1287
01:08:49,260 --> 01:08:50,120
Ne jamais oublier.

1288
01:08:50,120 --> 01:08:52,800
C'est comme le plus important
partie sur des pointeurs.

1289
01:08:52,800 --> 01:08:56,180
Il ya le stockage et l'adresse
à une variable.

1290
01:08:56,180 --> 01:08:56,890
Rien d'autre?

1291
01:08:56,890 --> 01:08:58,370
D'autres questions?

1292
01:08:58,370 --> 01:08:59,189
Dáccord.

1293
01:08:59,189 --> 01:09:00,399
>> Donc, et ensembles.

1294
01:09:00,399 --> 01:09:08,189
Rappelez-vous que quand je fais int tableau 3,
fondamentalement, ce que je fais, c'est que je suis, genre

1295
01:09:08,189 --> 01:09:12,779
de, déclarant dans un pointeur.

1296
01:09:12,779 --> 01:09:18,960
Donc tableau est un peu comme un pointeur vers une
lieu précis en mémoire dans laquelle je

1297
01:09:18,960 --> 01:09:21,999
alloué trois fentes pour les entiers.

1298
01:09:21,999 --> 01:09:23,430
Cela fait-il sens?

1299
01:09:23,430 --> 01:09:30,250
>> Donc, quand je fais int tableau 3, ce que je suis
faire, au fond, est la création de trois

1300
01:09:30,250 --> 01:09:31,479
fentes de mémoire.

1301
01:09:31,479 --> 01:09:33,899
Je trouve juste trois emplacements dans la mémoire.

1302
01:09:33,899 --> 01:09:38,810
Donc, si je le fais, alors, un réseau en étoile, il
signifie essentiellement le contenu de la matrice,

1303
01:09:38,810 --> 01:09:46,180
ce qui signifie que j'efface le pointeur, je vais
à cet endroit qu'il pointe vers,

1304
01:09:46,180 --> 01:09:47,939
et j'ai mis le numéro un.

1305
01:09:47,939 --> 01:09:53,729
>> Et puis, si je fais éventail étoiles plus 1,
c'est la même chose que faire ensemble

1306
01:09:53,729 --> 01:09:59,690
crochets l'une, ce qui signifie que je vais à
la place qui lui est pointé.

1307
01:09:59,690 --> 01:10:03,000
Et puis les plus 1 marques
me décale d'une position.

1308
01:10:03,000 --> 01:10:06,510
Donc, je vais à cette position, en fait,
et mettre le numéro deux.

1309
01:10:06,510 --> 01:10:10,900
>> Et puis, enfin, quand je fais
tableau plus 2, je vais là où

1310
01:10:10,900 --> 01:10:11,825
Le pointage au tableau à.

1311
01:10:11,825 --> 01:10:14,690
Et puis je passe à des blocs de mémoire.

1312
01:10:14,690 --> 01:10:16,240
Et puis j'ai mis le numéro trois ici.

1313
01:10:16,240 --> 01:10:16,600
Ouais?

1314
01:10:16,600 --> 01:10:21,400
>> PUBLIC: array Donc étoiles est tout simplement
disant que le tout premier point.

1315
01:10:21,400 --> 01:10:25,090
Et vous pouvez ajouter 1, juste parce que
nous ne sommes vraiment

1316
01:10:25,090 --> 01:10:27,295
référençant cette première adresse.

1317
01:10:27,295 --> 01:10:28,545
>> LUCAS: Ouais.

1318
01:10:28,545 --> 01:10:32,720

1319
01:10:32,720 --> 01:10:36,020
Pourquoi avons-nous, par exemple, disons tableau
0, tableau 1, et tableau 2?

1320
01:10:36,020 --> 01:10:38,970

1321
01:10:38,970 --> 01:10:42,790
Je veux dire, pourquoi faites-vous 0,
1, 2, 3 au lieu de 1, 2, 3?

1322
01:10:42,790 --> 01:10:46,550
L'une des raisons en est un, ordinateur
programmeurs préfèrent commencer

1323
01:10:46,550 --> 01:10:47,750
compter à partir de 0.

1324
01:10:47,750 --> 01:10:52,370
Deux, c'est parce que quand vous faites tableau 0,
c'est la même chose que faire ensemble

1325
01:10:52,370 --> 01:10:56,330
ainsi que 0, ce qui signifie que je vais à
cette position, et je ne sais pas

1326
01:10:56,330 --> 01:10:59,320
sauter des blocs de mémoire.

1327
01:10:59,320 --> 01:11:01,750
Donc, je ne bouge pas tous les blocs mémoires.

1328
01:11:01,750 --> 01:11:02,015
Ouais?

1329
01:11:02,015 --> 01:11:03,265
>> PUBLIC: [inaudible]?

1330
01:11:03,265 --> 01:11:05,928

1331
01:11:05,928 --> 01:11:12,670
>> LUCAS: Donc elle demande ce qui est
la différence entre faire

1332
01:11:12,670 --> 01:11:14,000
ceci ou cela malloc.

1333
01:11:14,000 --> 01:11:17,550
L'une des différences est que
int tableau 3 est la création d'un

1334
01:11:17,550 --> 01:11:19,260
matrice dans la pile.

1335
01:11:19,260 --> 01:11:23,080
Et quand je fais malloc, il
crée sur le tas.

1336
01:11:23,080 --> 01:11:25,250
Cela fait-il sens?

1337
01:11:25,250 --> 01:11:28,870
>> Alors, comment ne malloc réellement?

1338
01:11:28,870 --> 01:11:32,245
Alors pourquoi avons-nous encore besoin d'utiliser malloc?

1339
01:11:32,245 --> 01:11:35,730

1340
01:11:35,730 --> 01:11:39,700
Votre compilateur genre de chiffres sur tous
les variables que vous avez déclarés.

1341
01:11:39,700 --> 01:11:44,040
Et il crée de l'espace pour tous
d'entre eux dans la pile.

1342
01:11:44,040 --> 01:11:47,180
Donc, tous vos variables vont
à se situer dans la pile.

1343
01:11:47,180 --> 01:11:49,460
Voici donc les variables d'environnement.

1344
01:11:49,460 --> 01:11:53,850
>> Donc, fondamentalement, un espace pour les variables
dans la mémoire est allouée à

1345
01:11:53,850 --> 01:11:55,080
moment de la compilation.

1346
01:11:55,080 --> 01:11:58,790
Donc, cela signifie que votre ordinateur dispose d'
Pour connaître toutes les variables

1347
01:11:58,790 --> 01:11:59,790
l'avance.

1348
01:11:59,790 --> 01:12:02,500
Il n'a pas besoin de savoir quelle est la valeur
vous allez mettre dedans.

1349
01:12:02,500 --> 01:12:05,490
Mais il a besoin de savoir comment
la quantité de mémoire dont vous avez besoin.

1350
01:12:05,490 --> 01:12:09,380
>> Mais maintenant, disons que, par exemple,
vous créez un tableau ou prendre un

1351
01:12:09,380 --> 01:12:13,430
chaîne que vous prenez
à partir de l'utilisateur.

1352
01:12:13,430 --> 01:12:17,300
Vous ne savez pas combien de temps la chaîne
va être, par exemple.

1353
01:12:17,300 --> 01:12:20,600
Donc vous ne savez pas exactement combien
blocs de mémoire que vous allouez, non?

1354
01:12:20,600 --> 01:12:24,120
>> Donc, il n'a pas vraiment de sens pour
vous dites mis 100 caractères.

1355
01:12:24,120 --> 01:12:26,420
Et puis si l'utilisateur écrit 150?

1356
01:12:26,420 --> 01:12:27,670
Vous allez être vissé.

1357
01:12:27,670 --> 01:12:30,160

1358
01:12:30,160 --> 01:12:34,620
>> Donc, fondamentalement, vous ne pouvez pas être sûr de la façon dont
la quantité de mémoire dont vous avez besoin pour allouer

1359
01:12:34,620 --> 01:12:35,960
lorsque vous compilez le programme.

1360
01:12:35,960 --> 01:12:38,240
Vous savez juste que le temps d'exécution.

1361
01:12:38,240 --> 01:12:39,950
Donc, c'est pourquoi vous avez le tas.

1362
01:12:39,950 --> 01:12:47,610
Ainsi, le tas va avoir la mémoire
que vous allouer au cours de la

1363
01:12:47,610 --> 01:12:50,810
durée du programme en cours.

1364
01:12:50,810 --> 01:12:55,780
>> Donc, fondamentalement, quand vous faites malloc, ce
vous faites est l'allocation de mémoire à

1365
01:12:55,780 --> 01:13:00,160
l'exécution, ce qui signifie que vous êtes
décider à ce moment précis que vous

1366
01:13:00,160 --> 01:13:02,670
doit avoir cette mémoire.

1367
01:13:02,670 --> 01:13:04,210
Donc, c'est quand vous leur attribution.

1368
01:13:04,210 --> 01:13:06,430
Cela fait-il sens?

1369
01:13:06,430 --> 01:13:11,690
>> Donc n'oubliez pas, la pile contient des variables
qui sont créés sur la compilation.

1370
01:13:11,690 --> 01:13:14,560
Et puis le tas contient des variables
qui sont créés au fur et à

1371
01:13:14,560 --> 01:13:15,600
avec malloc, par exemple.

1372
01:13:15,600 --> 01:13:16,850
>> PUBLIC: [inaudible]?

1373
01:13:16,850 --> 01:13:19,179

1374
01:13:19,179 --> 01:13:24,340
>> LUCAS: Donc GetString est
vais appeler malloc.

1375
01:13:24,340 --> 01:13:26,710
Permettez-moi de parler de malloc, et
Je vais vous expliquer GetString.

1376
01:13:26,710 --> 01:13:32,000
Donc malloc est la même chose
comme l'allocation de mémoire.

1377
01:13:32,000 --> 01:13:34,600
Donc, il va allouer
mémoire sur le tas.

1378
01:13:34,600 --> 01:13:40,010
Et il va renvoyer un pointeur vers
où la mémoire a été allouée à.

1379
01:13:40,010 --> 01:13:43,090
>> Ainsi, lorsque vous do--

1380
01:13:43,090 --> 01:13:44,910
ici pour exemple--

1381
01:13:44,910 --> 01:13:45,830
n pointeur étoiles.

1382
01:13:45,830 --> 01:13:50,520
Et puis pointeur est égale à malloc
taille de temps de 10 pouces.

1383
01:13:50,520 --> 01:13:52,110
Je crée un pointeur.

1384
01:13:52,110 --> 01:13:59,020
Et puis je suis attribuant ce pointeur à
la valeur du pointeur qui malloc

1385
01:13:59,020 --> 01:13:59,680
est de me donner.

1386
01:13:59,680 --> 01:14:04,150
>> Malloc Je demande donc peut vous affecter
l'espace de 10 nombres entiers.

1387
01:14:04,150 --> 01:14:05,390
C'est ce qu'il dit.

1388
01:14:05,390 --> 01:14:09,020
Et malloc me redonne un
pointeur à cet endroit.

1389
01:14:09,020 --> 01:14:11,460
Donner un sens?

1390
01:14:11,460 --> 01:14:12,270
Dáccord.

1391
01:14:12,270 --> 01:14:17,940
Je Et GetString est, fondamentalement, fait un
appel à malloc de sorte que vous pouvez allouer

1392
01:14:17,940 --> 01:14:21,680
la mémoire lors de l'exécution.

1393
01:14:21,680 --> 01:14:26,460
>> Rappelez-vous toujours de vérifier null
parce malloc va retourner null

1394
01:14:26,460 --> 01:14:28,200
si elle ne peut pas allouer de la mémoire.

1395
01:14:28,200 --> 01:14:31,660
Disons que vous demandez un ridicule
quantité de mémoire.

1396
01:14:31,660 --> 01:14:33,950
Votre ordinateur ne va pas être
en mesure d'allouer beaucoup.

1397
01:14:33,950 --> 01:14:36,410
>> Donc malloc va juste
pour retourner null.

1398
01:14:36,410 --> 01:14:42,210
Alors, n'oubliez pas de toujours vérifier si le
pointeur que vous avez obtenu de malloc

1399
01:14:42,210 --> 01:14:45,640
nulle ou pas, parce que si c'est le cas, vous pourriez
être de déréférencer un pointeur et

1400
01:14:45,640 --> 01:14:48,340
provoquant des défauts latéraux.

1401
01:14:48,340 --> 01:14:50,930
Et enfin, n'oubliez pas
votre mémoire libre.

1402
01:14:50,930 --> 01:14:57,800

1403
01:14:57,800 --> 01:15:00,560
>> Malloc crée la mémoire dans le tas.

1404
01:15:00,560 --> 01:15:03,436
Et vous devez libérer la mémoire
avant la fin du programme.

1405
01:15:03,436 --> 01:15:05,370
OK, c'est tout pour moi.

1406
01:15:05,370 --> 01:15:07,900
Désolé, Rob.

1407
01:15:07,900 --> 01:15:07,950
Merci.

1408
01:15:07,950 --> 01:15:09,878
>> [Applaudissements]

1409
01:15:09,878 --> 01:15:12,679
>> LUCAS: Les dernières questions
Rob vient avant?

1410
01:15:12,679 --> 01:15:13,138
Non?

1411
01:15:13,138 --> 01:15:13,597
Ouais?

1412
01:15:13,597 --> 01:15:15,892
>> PUBLIC: Je ne vois pas
celui-ci en ligne.

1413
01:15:15,892 --> 01:15:17,269
Avez-vous téléchargé il encore?

1414
01:15:17,269 --> 01:15:19,106
>> LUCAS: Je pense que Dave est
téléchargeant bientôt.

1415
01:15:19,106 --> 01:15:19,880
>> DAVE: Ça va être affiché.

1416
01:15:19,880 --> 01:15:20,310
>> LUCAS: Il sera en ligne.

1417
01:15:20,310 --> 01:15:21,175
>> PUBLIC: C'est.

1418
01:15:21,175 --> 01:15:22,090
>> LUCAS: C'est?

1419
01:15:22,090 --> 01:15:23,157
Dáccord.

1420
01:15:23,157 --> 01:15:23,644
Ouais?

1421
01:15:23,644 --> 01:15:27,053
>> PUBLIC: [inaudible]?

1422
01:15:27,053 --> 01:15:30,285
>> LUCAS: Oui, vous devez libérer toutes les
la mémoire qui est mis en tas.

1423
01:15:30,285 --> 01:15:31,535
>> PUBLIC: [inaudible]?

1424
01:15:31,535 --> 01:15:34,518

1425
01:15:34,518 --> 01:15:36,160
>> LUCAS: Oui.

1426
01:15:36,160 --> 01:15:39,980
Chaque fois que vous avez un malloc de la culture,
vous devriez avoir une culture libre

1427
01:15:39,980 --> 01:15:42,640
après vous arrêtez d'utiliser cette variable.

1428
01:15:42,640 --> 01:15:44,800
Donc malloc et free sont
toujours ensemble.

1429
01:15:44,800 --> 01:15:45,410
Leurs meilleurs amis.

1430
01:15:45,410 --> 01:15:46,720
Ouais.

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: Je vais rapidement.

1434
01:15:56,850 --> 01:16:00,466
Et aussi la vidéo sera mis en place.

1435
01:16:00,466 --> 01:16:01,716
J'ai le micro.

1436
01:16:01,716 --> 01:16:24,060

1437
01:16:24,060 --> 01:16:26,230
>> OK, donc la semaine de cinq trucs.

1438
01:16:26,230 --> 01:16:27,970
La première chose que nous avons est la pile.

1439
01:16:27,970 --> 01:16:33,390
Donc, n'oubliez pas qu'il ya une seule pile
image par appel de fonction active.

1440
01:16:33,390 --> 01:16:34,710
Nous verrons dans un instant.

1441
01:16:34,710 --> 01:16:37,850
Et rappelez-vous aussi ce qui se passe réellement
dans chaque cadre de pile vont être

1442
01:16:37,850 --> 01:16:41,880
les variables locales de nos fonctions,
les arguments qui sont passés dans notre

1443
01:16:41,880 --> 01:16:43,880
fonctions, avec un couple
d'autres choses que vous n'avez pas vraiment

1444
01:16:43,880 --> 01:16:45,260
besoin de s'inquiéter.

1445
01:16:45,260 --> 01:16:50,950
>> Alors, voici un exemple de programme où,
avis, le principal est printfing le retour

1446
01:16:50,950 --> 01:16:52,830
valeur de foo 4.

1447
01:16:52,830 --> 01:16:57,930
foo va juste retourner le
valeur de bar 4 virgule 6.

1448
01:16:57,930 --> 01:17:02,380
Et le bar va mettre un certain locale
variable n égal à 4 fois par 6.

1449
01:17:02,380 --> 01:17:03,920
Et puis retour n.

1450
01:17:03,920 --> 01:17:09,130
>> Alors regardons à la pile à travers
l'itération actuelle de ce programme.

1451
01:17:09,130 --> 01:17:10,500
Donc, il ya le fond de notre pile.

1452
01:17:10,500 --> 01:17:12,620
Rappelez-vous que la pile grandit.

1453
01:17:12,620 --> 01:17:15,370
Donc, au fond de notre pile, nous
avoir un cadre de pile pour principale.

1454
01:17:15,370 --> 01:17:17,000
Lorsque le programme démarre, principale
va toujours être à la

1455
01:17:17,000 --> 01:17:18,560
fond de notre pile.

1456
01:17:18,560 --> 01:17:20,880
>> Et ce qui est à l'intérieur de notre
empiler cadre pour principal?

1457
01:17:20,880 --> 01:17:23,810
Ainsi, même si il n'y a pas locale
variables aux principal, comme je l'ai dit avant,

1458
01:17:23,810 --> 01:17:29,670
nous avons argc et RGV prendre de l'espace
l'intérieur du cadre de la pile principale.

1459
01:17:29,670 --> 01:17:33,260
Donc principale va maintenant
appeler la fonction foo.

1460
01:17:33,260 --> 01:17:35,125
Et cela signifie que foo va
obtenir son propre cadre de pile.

1461
01:17:35,125 --> 01:17:36,970
>> Alors maintenant, nous sommes à l'intérieur de
la fonction foo.

1462
01:17:36,970 --> 01:17:38,610
Et ce qui doit aller dans
le cadre de pile de foo?

1463
01:17:38,610 --> 01:17:41,100
Eh bien, foo a un argument n.

1464
01:17:41,100 --> 01:17:45,440
Et n est égal à 4 puisque c'est ce que
principale passe comme argument de foo.

1465
01:17:45,440 --> 01:17:48,490
>> Alors maintenant, foo va appeler bar.

1466
01:17:48,490 --> 01:17:52,070
Qu'est-ce que la barre va avoir à l'intérieur
de son «cadre de pile?

1467
01:17:52,070 --> 01:17:55,610
Il a x égal à 4 y égal à six.

1468
01:17:55,610 --> 01:17:58,540
Ce n'est pas tout ce que nous allons avoir
dans le cadre de pile parce bar

1469
01:17:58,540 --> 01:18:00,580
a également une variable locale n.

1470
01:18:00,580 --> 01:18:03,370
Et n, nous allons établir égal à 24.

1471
01:18:03,370 --> 01:18:05,750
>> Alors maintenant, bar va revenir n.

1472
01:18:05,750 --> 01:18:09,300
Donc barre revient à 24
foo cadre de pile.

1473
01:18:09,300 --> 01:18:12,560
Et parce que la barre est maintenant de retour, que
signifie que nous éclater le cadre de pile

1474
01:18:12,560 --> 01:18:14,250
pour la barre hors de la pile.

1475
01:18:14,250 --> 01:18:18,430
Donc, toute la mémoire qui barre avait été
l'aide est maintenant la pile.

1476
01:18:18,430 --> 01:18:21,550
>> Maintenant, foo va également
à revenir à 24 principale.

1477
01:18:21,550 --> 01:18:25,470
Alors, maintenant que foo est de retour, la mémoire
que foo a été utilise dans son '

1478
01:18:25,470 --> 01:18:27,550
cadre de pile a également disparu.

1479
01:18:27,550 --> 01:18:29,660
Et maintenant, principal va appeler printf.

1480
01:18:29,660 --> 01:18:31,660
Donc printf est juste une autre fonction.

1481
01:18:31,660 --> 01:18:35,320
Lorsque nous appelons printf, ça va être
un autre cadre de pile pour la fonction printf

1482
01:18:35,320 --> 01:18:36,470
appel de fonction.

1483
01:18:36,470 --> 01:18:37,990
>> Que faisons-nous passons printf?

1484
01:18:37,990 --> 01:18:40,090
C'est ce qui va se passer
sur son cadre de pile.

1485
01:18:40,090 --> 01:18:44,970
À tout le moins, nous passons
que pour cent i Backslash n et

1486
01:18:44,970 --> 01:18:47,180
l'argument 24.

1487
01:18:47,180 --> 01:18:50,370
Il pourrait avoir plus dans son cadre de pile
si printf arrive à être en utilisant une

1488
01:18:50,370 --> 01:18:51,200
des variables locales.

1489
01:18:51,200 --> 01:18:51,920
Nous ne savons pas.

1490
01:18:51,920 --> 01:18:53,810
>> Mais tout ce qui va dans printf de
empiler cadre.

1491
01:18:53,810 --> 01:18:55,740
Il va exécuter la fonction printf.

1492
01:18:55,740 --> 01:18:56,830
Puis printf qui est fait.

1493
01:18:56,830 --> 01:18:57,820
Il sera de retour.

1494
01:18:57,820 --> 01:18:58,960
Enfin, le principal est fait.

1495
01:18:58,960 --> 01:18:59,860
Principale sera de retour.

1496
01:18:59,860 --> 01:19:02,020
Et puis notre programme est fait.

1497
01:19:02,020 --> 01:19:02,480
Ouais?

1498
01:19:02,480 --> 01:19:04,505
>> PUBLIC: Êtes-vous voir [inaudible]

1499
01:19:04,505 --> 01:19:05,900
arguments [inaudible]

1500
01:19:05,900 --> 01:19:06,830
paramètres?

1501
01:19:06,830 --> 01:19:09,970
>> ROB: Donc, il ya une différence subtile
entre les arguments et les paramètres.

1502
01:19:09,970 --> 01:19:14,400
Et vraiment, en parler commun, les gens ont tendance
juste mélanger tout le temps.

1503
01:19:14,400 --> 01:19:17,550
Mais paramètres sont formelle
nommer des choses.

1504
01:19:17,550 --> 01:19:20,180
>> Donc argc et argv sont les
paramètres à principale.

1505
01:19:20,180 --> 01:19:23,440
Les arguments sont ce que vous avez réellement
transmis en tant que ces paramètres.

1506
01:19:23,440 --> 01:19:28,340
Il ya donc quand je l'appelle foo de 4, 4
est l'argument que je suis de passage à.

1507
01:19:28,340 --> 01:19:31,460
Et le paramètre n, à l'intérieur de
foo, prend la valeur 4

1508
01:19:31,460 --> 01:19:32,880
depuis le 4 était l'argument.

1509
01:19:32,880 --> 01:19:35,826
>> PUBLIC: [inaudible]?

1510
01:19:35,826 --> 01:19:37,880
>> ROB: n est une variable locale à la barre.

1511
01:19:37,880 --> 01:19:41,420

1512
01:19:41,420 --> 01:19:44,960
n est toujours locale à foo, mais
c'est un paramètre à toto.

1513
01:19:44,960 --> 01:19:48,190
Ce n'est pas une variable locale.

1514
01:19:48,190 --> 01:19:48,546
Ouais?

1515
01:19:48,546 --> 01:19:51,180
>> PUBLIC: [inaudible]?

1516
01:19:51,180 --> 01:19:55,400
>> ROB: bar foo est juste appeler et
retour quel que soit le rendement de la barre.

1517
01:19:55,400 --> 01:19:56,786
>> PUBLIC: [inaudible]?

1518
01:19:56,786 --> 01:19:59,591
>> ROB: Ouais, juste pour voir multiple
trames de pile.

1519
01:19:59,591 --> 01:20:00,082
Ouais?

1520
01:20:00,082 --> 01:20:03,519
>> PUBLIC: Pourquoi foo a été appelé
avant printf?

1521
01:20:03,519 --> 01:20:05,920
>> ROB: Pourquoi foo appelée avant printf?

1522
01:20:05,920 --> 01:20:10,740
Donc je pourrais avoir, au contraire, fait quelque chose
comme int x est égal à foo de 4

1523
01:20:10,740 --> 01:20:12,980
puis imprimé x.

1524
01:20:12,980 --> 01:20:17,900
Mais au lieu, j'ai combiné la fonction
remettre en l'argument de printf.

1525
01:20:17,900 --> 01:20:23,670
>> Mais notez que nous ne pouvons pas réellement
exécuter l'appel à printf jusqu'à ce que nous

1526
01:20:23,670 --> 01:20:25,610
comprendre ce que foo de 4 est.

1527
01:20:25,610 --> 01:20:27,480
Donc, nous allons évaluer cela.

1528
01:20:27,480 --> 01:20:32,504
Et seulement une fois que c'est fait vont
de revenir et d'évaluer cela.

1529
01:20:32,504 --> 01:20:32,990
Ouais?

1530
01:20:32,990 --> 01:20:37,364
>> PUBLIC: Depuis deux bar [inaudible]

1531
01:20:37,364 --> 01:20:41,738
valeur, pourquoi n'avons-nous pas [inaudible]?

1532
01:20:41,738 --> 01:20:44,400
>> ROB: Ils doivent être totalement int.

1533
01:20:44,400 --> 01:20:46,260
Cela n'a pas été pris sur
plusieurs passes.

1534
01:20:46,260 --> 01:20:49,010
Donc, il devrait être int bar et int
foo puisque les deux personnes

1535
01:20:49,010 --> 01:20:50,460
sont de retour entiers.

1536
01:20:50,460 --> 01:20:54,214
Void est que si ils ne vont pas
pour renvoyer des valeurs réelles.

1537
01:20:54,214 --> 01:20:54,692
Ouais?

1538
01:20:54,692 --> 01:20:58,038
>> PUBLIC: Si vous aviez une ligne au-dessus
le retour, [inaudible]?

1539
01:20:58,038 --> 01:21:01,862

1540
01:21:01,862 --> 01:21:03,730
>> ROB: Une ligne au-dessus du rendement?

1541
01:21:03,730 --> 01:21:04,410
>> PUBLIC: Ouais.

1542
01:21:04,410 --> 01:21:10,780
Comme si vous avez printf et [inaudible],
serait-il imprimer deux fois?

1543
01:21:10,780 --> 01:21:12,992
>> ROB: Donc, à l'intérieur de foo?

1544
01:21:12,992 --> 01:21:15,945
Si nous avions un printf ici?

1545
01:21:15,945 --> 01:21:16,750
>> PUBLIC: Ouais.

1546
01:21:16,750 --> 01:21:19,510
>> ROB: Donc, si nous avions le droit de printf
ici, il serait imprimer une fois.

1547
01:21:19,510 --> 01:21:23,400
Depuis que nous appelons foo une fois à droite
ici, nous allons frapper le printf.

1548
01:21:23,400 --> 01:21:24,620
Ensuite, nous appelons bar.

1549
01:21:24,620 --> 01:21:25,710
Et puis foo sera de retour.

1550
01:21:25,710 --> 01:21:26,275
Et c'est tout.

1551
01:21:26,275 --> 01:21:30,985
Nous ne rencontrons jamais
printf fois.

1552
01:21:30,985 --> 01:21:31,482
Ouais?

1553
01:21:31,482 --> 01:21:32,973
>> PUBLIC: [inaudible]

1554
01:21:32,973 --> 01:21:37,950
printf, appeler foo parce que nous sommes les premiers
appelant printf puis nous passons

1555
01:21:37,950 --> 01:21:38,580
les arguments.

1556
01:21:38,580 --> 01:21:40,960
>> ROB: Donc, en théorie, n'est pas
printf, appeler foo?

1557
01:21:40,960 --> 01:21:42,220
Donc pas.

1558
01:21:42,220 --> 01:21:47,360
Il suffit de l'ordre que c va
exécuter ces choses est, avant que nous puissions

1559
01:21:47,360 --> 01:21:49,800
appeler une fonction, tous les arguments
à la fonction doivent

1560
01:21:49,800 --> 01:21:51,600
être complètement évaluées.

1561
01:21:51,600 --> 01:21:53,540
Donc, est-ce complètement évaluée?

1562
01:21:53,540 --> 01:21:54,610
Oui, c'est juste une chaîne.

1563
01:21:54,610 --> 01:21:55,480
C'est juste une valeur.

1564
01:21:55,480 --> 01:21:57,200
>> Ensuite, nous avons complètement
évaluer cette question.

1565
01:21:57,200 --> 01:21:59,720
Une fois cela fait, tout de
ses arguments sont évalués.

1566
01:21:59,720 --> 01:22:01,982
Et maintenant, nous pouvons faire la
appeler à printf.

1567
01:22:01,982 --> 01:22:02,478
Ouais?

1568
01:22:02,478 --> 01:22:03,966
>> PUBLIC: Une question.

1569
01:22:03,966 --> 01:22:06,942
Si vous avez une fonction de vide, doit
vous avez rendement virgule?

1570
01:22:06,942 --> 01:22:09,910
>> ROB: Vous n'avez pas une virgule de retour
si vous avez une fonction de vide.

1571
01:22:09,910 --> 01:22:13,370

1572
01:22:13,370 --> 01:22:14,780
Dáccord.

1573
01:22:14,780 --> 01:22:15,830
Alors maintenant, des trucs de tas.

1574
01:22:15,830 --> 01:22:19,640
Donc tas est de savoir comment nous allons faire face
à une gestion dynamique de la mémoire.

1575
01:22:19,640 --> 01:22:23,100
Et ce contraste directement avec la
pile que nous appellerions automatique

1576
01:22:23,100 --> 01:22:24,100
la gestion de la mémoire.

1577
01:22:24,100 --> 01:22:27,140
>> Donc, sur la pile, vous n'avez jamais vraiment
pour faire face à la façon dont les variables locales

1578
01:22:27,140 --> 01:22:30,400
sont poussés et sauté hors tout
ces cadres de pile et tout ça.

1579
01:22:30,400 --> 01:22:31,070
Vous n'avez pas à vous en préoccuper.

1580
01:22:31,070 --> 01:22:32,070
C'est automatique.

1581
01:22:32,070 --> 01:22:36,990
Ainsi, le tas est manuel.

1582
01:22:36,990 --> 01:22:38,070
Et la [inaudible]

1583
01:22:38,070 --> 01:22:41,260
vient de ces fonctions
malloc et free.

1584
01:22:41,260 --> 01:22:43,550
>> Alors, voici un autre programme.

1585
01:22:43,550 --> 01:22:47,145
Tout ce que nous faisons, c'est allouer de
un nombre entier.

1586
01:22:47,145 --> 01:22:49,360
Nous le stocker dans star du x.

1587
01:22:49,360 --> 01:22:52,520
Bien sûr, nous devons vérifier
pour voir si x est nul.

1588
01:22:52,520 --> 01:22:56,400
Ensuite, nous allons simplement mettre ce
x pointe vers 50.

1589
01:22:56,400 --> 01:23:00,350

1590
01:23:00,350 --> 01:23:03,260
Imprimer ce x pointe vers,
print x, puis libre x.

1591
01:23:03,260 --> 01:23:08,920
>> Alors, comment est-ce vraiment va chercher
si nous regardons notre pile et le tas?

1592
01:23:08,920 --> 01:23:10,950
Nous allons donc commencer à nouveau.

1593
01:23:10,950 --> 01:23:12,580
Le fond de notre pile comme avant.

1594
01:23:12,580 --> 01:23:15,930
Rappelez-vous que toi tas directement
s'oppose à la pile?

1595
01:23:15,930 --> 01:23:18,850
Donc, nous allons avoir l'
haut de notre tas là-haut.

1596
01:23:18,850 --> 01:23:22,590
>> Ainsi, le fond de notre pile, nous avons
notre cadre de pile pour principale.

1597
01:23:22,590 --> 01:23:28,000
Il dispose de l'espace pour argc, argv, et nous
ont maintenant une variable locale x, qui

1598
01:23:28,000 --> 01:23:30,030
est un int étoiles.

1599
01:23:30,030 --> 01:23:32,240
Nous allons donc à parcourir
grâce à ce programme.

1600
01:23:32,240 --> 01:23:34,420
La première chose que nous avons est
un appel à malloc.

1601
01:23:34,420 --> 01:23:36,250
>> Nous faisons donc un appel à malloc.

1602
01:23:36,250 --> 01:23:37,100
Malloc est une fonction.

1603
01:23:37,100 --> 01:23:38,770
Il va y avoir un cadre de pile.

1604
01:23:38,770 --> 01:23:40,180
Que faisons-nous passer à malloc?

1605
01:23:40,180 --> 01:23:41,610
Cela va aller à l'intérieur
du cadre de pile.

1606
01:23:41,610 --> 01:23:45,130
Nous passons la taille de n, qui est de 4.

1607
01:23:45,130 --> 01:23:49,700
Donc, qui est passé à malloc.

1608
01:23:49,700 --> 01:23:50,910
>> Qu'est-ce que malloc faire?

1609
01:23:50,910 --> 01:23:53,820
Il nous prend un peu d'espace sur le tas.

1610
01:23:53,820 --> 01:23:55,320
Donc, nous allons aller au tas.

1611
01:23:55,320 --> 01:23:57,990
Et nous allons saisir
4 octets dans le tas.

1612
01:23:57,990 --> 01:24:01,500
Donnons donc juste que
une adresse arbitraire.

1613
01:24:01,500 --> 01:24:06,680
0x123 Juste prétendent que c'est un
adresse qui se trouve sur le segment de mémoire.

1614
01:24:06,680 --> 01:24:12,300
>> Donc ce qui est réellement à l'intérieur de ce
région de mémoire à l'adresse Ox123?

1615
01:24:12,300 --> 01:24:13,080
Garbage.

1616
01:24:13,080 --> 01:24:15,270
Nous n'avons donc pas stocké rien dedans.

1617
01:24:15,270 --> 01:24:18,830
Pour autant que nous le savons, il
pourrait être n'importe quoi.

1618
01:24:18,830 --> 01:24:20,560
Vous ne devriez pas supposer que c'est zéro.

1619
01:24:20,560 --> 01:24:23,870
Il n'est probablement pas zéro.

1620
01:24:23,870 --> 01:24:26,260
>> Rendements Alors maintenant malloc.

1621
01:24:26,260 --> 01:24:28,020
Et que faisons-nous au retour de malloc?

1622
01:24:28,020 --> 01:24:29,800
Nous avons mis ce qu'il retourne.

1623
01:24:29,800 --> 01:24:32,290
Nous avons mis en x égal à ce
il est de retour.

1624
01:24:32,290 --> 01:24:33,690
Alors qu'est-ce qu'il revient?

1625
01:24:33,690 --> 01:24:38,150
Il est 0x123 retour puisque c'est la
l'adresse du bloc de mémoire qui est

1626
01:24:38,150 --> 01:24:40,850
vient d'allouer dans le tas.

1627
01:24:40,850 --> 01:24:47,160
>> Donc revenir 0x123 x va maintenant être mis en
égale à 0x123 qui, imagée,

1628
01:24:47,160 --> 01:24:52,940
nous attirons souvent que x ayant une réelle
flèche pointant vers ce bloc.

1629
01:24:52,940 --> 01:24:55,820
Mais x est simplement stocker cette adresse.

1630
01:24:55,820 --> 01:24:58,670
Alors maintenant, nous devons vérifier si x est nul.

1631
01:24:58,670 --> 01:24:59,120
Ce n'est pas nulle.

1632
01:24:59,120 --> 01:25:02,170
Nous prétendons que cette malloc réussi.

1633
01:25:02,170 --> 01:25:04,950
>> Alors maintenant, star du x est égal à 50.

1634
01:25:04,950 --> 01:25:08,450
Donc étoiles se souvient que cela signifie
aller à cette adresse.

1635
01:25:08,450 --> 01:25:12,700
Donc 0x123 Nous allons
aller à cette adresse.

1636
01:25:12,700 --> 01:25:14,660
Donc cela nous amène là-haut.

1637
01:25:14,660 --> 01:25:16,310
Que faisons-nous à cette adresse?

1638
01:25:16,310 --> 01:25:19,020
Nous stockage 50.

1639
01:25:19,020 --> 01:25:22,500
>> Donc, après cette ligne, c'est ce que
les choses vont ressembler.

1640
01:25:22,500 --> 01:25:24,640
Alors maintenant, il n'est plus
ordures là-haut.

1641
01:25:24,640 --> 01:25:28,910
Maintenant, nous savons que 50 est dans ce
notamment parce adresse

1642
01:25:28,910 --> 01:25:32,410
nous l'avons mis à cela.

1643
01:25:32,410 --> 01:25:32,790
D'accord?

1644
01:25:32,790 --> 01:25:34,370
Alors maintenant, nous allons imprimer f.

1645
01:25:34,370 --> 01:25:38,490
>> Donc tout d'abord nous allons imprimer star du x.

1646
01:25:38,490 --> 01:25:39,640
Alors, quelle est star du x?

1647
01:25:39,640 --> 01:25:44,300
Encore une fois, la star x signifie aller à l'
chose qui x pointe.

1648
01:25:44,300 --> 01:25:47,140
Donc x est le stockage de 0x123 Go pour cela.

1649
01:25:47,140 --> 01:25:48,490
Nous obtenons 50.

1650
01:25:48,490 --> 01:25:50,540
Donc imprimer f que.

1651
01:25:50,540 --> 01:25:54,900
Et cela signifie qu'il va imprimer 50.

1652
01:25:54,900 --> 01:25:56,850
Et puis qui retourne.

1653
01:25:56,850 --> 01:25:58,340
>> Et puis nous avons la deuxième printf.

1654
01:25:58,340 --> 01:25:59,370
Nous sommes maintenant pour cent p.

1655
01:25:59,370 --> 01:26:01,680
Si vous n'avez pas vu, c'est
à quel point vous imprimez un pointeur.

1656
01:26:01,680 --> 01:26:04,960
Nous avons donc pour cent i, pour cent
f, et tous ceux déjà.

1657
01:26:04,960 --> 01:26:07,160
Donc pour cent p, imprimer un pointeur.

1658
01:26:07,160 --> 01:26:08,920
>> Donc x est un pointeur.

1659
01:26:08,920 --> 01:26:13,440
Donc, si nous allons imprimer x lui-même,
nous imprimons ce qui est réellement à l'intérieur

1660
01:26:13,440 --> 01:26:19,220
x, qui est donc le premier 0x123
f impression va imprimer 50.

1661
01:26:19,220 --> 01:26:23,620
La seconde impression f va
d'imprimer 0x123 Ouais?

1662
01:26:23,620 --> 01:26:27,460
>> PUBLIC: Utilisez-vous des pour cent
x pour imprimer un pointeur?

1663
01:26:27,460 --> 01:26:31,200
>> ROB: Alors utilisez-vous pour cent
x pour imprimer un pointeur?

1664
01:26:31,200 --> 01:26:38,350
Ainsi, vous pouvez, mais pour cent x est juste,
généralement, pour que si vous avez une

1665
01:26:38,350 --> 01:26:40,325
entier et que vous souhaitez imprimer
comme un hexadécimal.

1666
01:26:40,325 --> 01:26:43,250

1667
01:26:43,250 --> 01:26:44,880
C'est juste la façon dont vous le faites.

1668
01:26:44,880 --> 01:26:47,160
>> Considérant que, pour cent d serait
imprimer en décimal.

1669
01:26:47,160 --> 01:26:50,310
C'est là que nous obtenons pour cent
d. i est tout nombre entier.

1670
01:26:50,310 --> 01:26:52,690
p est spécifiquement pour cent
pour des pointeurs.

1671
01:26:52,690 --> 01:26:54,060
>> Donc x est un pointeur.

1672
01:26:54,060 --> 01:26:56,360
Nous voulons utiliser pour cent p.

1673
01:26:56,360 --> 01:26:57,937
Mais pour cent x pourrait fonctionner.

1674
01:26:57,937 --> 01:26:58,414
Ouais?

1675
01:26:58,414 --> 01:26:59,664
>> PUBLIC: [inaudible]?

1676
01:26:59,664 --> 01:27:04,138

1677
01:27:04,138 --> 01:27:05,388
>> ROB: Oui.

1678
01:27:05,388 --> 01:27:07,870

1679
01:27:07,870 --> 01:27:13,440
Au moins pour cette call-- donc je
ne pas l'inclure ici.

1680
01:27:13,440 --> 01:27:19,850
Mais ces deux arguments ne sont pas nécessairement
à l'intérieur de ce cadre de pile

1681
01:27:19,850 --> 01:27:23,040
ainsi que toutes les variables locales
printf arrive à être utiliser.

1682
01:27:23,040 --> 01:27:27,020
Et puis le prochain appel à printf maintenant
l'intérieur de printf cadre de pile est

1683
01:27:27,020 --> 01:27:33,960
pour cent p barre oblique inverse n et quel que soit le
La valeur de x est, ce qui est 0x123.

1684
01:27:33,960 --> 01:27:34,425
Ouais?

1685
01:27:34,425 --> 01:27:35,675
>> PUBLIC: [inaudible]?

1686
01:27:35,675 --> 01:27:38,145

1687
01:27:38,145 --> 01:27:40,880
>> ROB: Ça va imprimer quelque chose
qui ressemble à ceci.

1688
01:27:40,880 --> 01:27:41,846
>> PUBLIC: [inaudible].

1689
01:27:41,846 --> 01:27:44,510
>> ROB: elle imprime donc il sous forme d'adresse.

1690
01:27:44,510 --> 01:27:47,003
Il ressemble à une adresse.

1691
01:27:47,003 --> 01:27:47,494
Ouais?

1692
01:27:47,494 --> 01:27:49,458
>> PUBLIC: [inaudible]?

1693
01:27:49,458 --> 01:27:51,075
>> ROB: Pourquoi est-ce?

1694
01:27:51,075 --> 01:27:52,920
>> PUBLIC: [inaudible]?

1695
01:27:52,920 --> 01:27:55,240
>> ROB: Pourquoi est-ce pointeur de 4 octets?

1696
01:27:55,240 --> 01:27:58,500
Donc, il ya tout un tas
de 0 est en face de cela.

1697
01:27:58,500 --> 01:28:03,740
Donc, c'est vraiment 0x0000000123.

1698
01:28:03,740 --> 01:28:06,510
Sur un système 64 bits, il y aurait
tout un tas de zéros.

1699
01:28:06,510 --> 01:28:11,410

1700
01:28:11,410 --> 01:28:11,900
Ouais?

1701
01:28:11,900 --> 01:28:13,150
>> PUBLIC: [inaudible].

1702
01:28:13,150 --> 01:28:17,290

1703
01:28:17,290 --> 01:28:21,130
>> ROB: Donc la première printf
va print--

1704
01:28:21,130 --> 01:28:21,980
>> PUBLIC: [inaudible].

1705
01:28:21,980 --> 01:28:24,420
>> ROB: Oui, il va imprimer
ce x pointe vers.

1706
01:28:24,420 --> 01:28:27,030

1707
01:28:27,030 --> 01:28:29,070
Star dit quelle est cette
chose montrant.

1708
01:28:29,070 --> 01:28:30,300
Prenez-le.

1709
01:28:30,300 --> 01:28:31,455
Alors qu'est-ce qu'il pointe vers?

1710
01:28:31,455 --> 01:28:31,850
50.

1711
01:28:31,850 --> 01:28:32,410
Prenez-le.

1712
01:28:32,410 --> 01:28:33,390
C'est ce que nous allons imprimer.

1713
01:28:33,390 --> 01:28:37,020
Considérant que, la prochaine, nous sommes
juste l'impression x lui-même.

1714
01:28:37,020 --> 01:28:38,850
Ce qui est à l'intérieur de f?

1715
01:28:38,850 --> 01:28:43,710
0x123.

1716
01:28:43,710 --> 01:28:44,500
Dáccord.

1717
01:28:44,500 --> 01:28:46,620
>> Et puis, enfin, nous avons le libre.

1718
01:28:46,620 --> 01:28:48,040
Que faisons-nous passer à libérer?

1719
01:28:48,040 --> 01:28:49,470
Nous passons x.

1720
01:28:49,470 --> 01:28:52,380
Que fois que j'ai affiché
dans le cadre de pile.

1721
01:28:52,380 --> 01:28:56,370
>> Nous allons donc passer la valeur
0x123 pour libérer.

1722
01:28:56,370 --> 01:28:59,070
Alors maintenant gratuitement sait, tout droit,
Je dois aller jusqu'à le tas

1723
01:28:59,070 --> 01:29:00,050
et sans que la mémoire.

1724
01:29:00,050 --> 01:29:03,920
C'est de ne plus utiliser ce
est à l'adresse 0x123.

1725
01:29:03,920 --> 01:29:07,010
>> Le libre va libérer
que dans le tas.

1726
01:29:07,010 --> 01:29:09,490
Maintenant, notre tas est de nouveau vide.

1727
01:29:09,490 --> 01:29:11,120
Nous n'avons pas de fuites de mémoire.

1728
01:29:11,120 --> 01:29:12,940
Maintenant libre sera de retour.

1729
01:29:12,940 --> 01:29:16,130
Notez que x est toujours 0x123.

1730
01:29:16,130 --> 01:29:18,240
Mais ce n'est pas maintenant mémoire valide.

1731
01:29:18,240 --> 01:29:21,220

1732
01:29:21,220 --> 01:29:23,986
Nous ne devrait plus déréférencer x.

1733
01:29:23,986 --> 01:29:24,440
Ouais?

1734
01:29:24,440 --> 01:29:27,240
>> PUBLIC: Est retourner 0 redondant?

1735
01:29:27,240 --> 01:29:28,290
>> ROB: Est returen 0 redondant?

1736
01:29:28,290 --> 01:29:31,110
Oui.

1737
01:29:31,110 --> 01:29:33,950
Nous mettons juste que là parce que
nous avons un retour un pour l'air.

1738
01:29:33,950 --> 01:29:36,830
Donc, c'est comme, ouais, permet de
inclure le retour 0.

1739
01:29:36,830 --> 01:29:37,310
Ouais?

1740
01:29:37,310 --> 01:29:38,560
>> PUBLIC: [inaudible]?

1741
01:29:38,560 --> 01:29:42,110

1742
01:29:42,110 --> 01:29:45,580
>> ROB: Alors après x gratuits, ce qui se passe si
nous essayons de déréférencer le pointeur?

1743
01:29:45,580 --> 01:29:47,240
Il est possible que tout se passe bien.

1744
01:29:47,240 --> 01:29:49,330
Il est possible que nous obtenons encore 50.

1745
01:29:49,330 --> 01:29:53,590
>> Il est possible, également, que cette mémoire est
maintenant utilisé pour autre chose.

1746
01:29:53,590 --> 01:29:57,140
Il s'agit donc d'un comportement non défini.

1747
01:29:57,140 --> 01:30:00,772
Et indéfini signifie quelque chose
qui peut arriver.

1748
01:30:00,772 --> 01:30:01,250
Ouais?

1749
01:30:01,250 --> 01:30:02,500
>> PUBLIC: [inaudible]?

1750
01:30:02,500 --> 01:30:07,942

1751
01:30:07,942 --> 01:30:10,830
>> ROB: Non, si vous affectez
x à autre chose.

1752
01:30:10,830 --> 01:30:15,870
Donc, si nous avons dit ici x est égal à
quelque chose de malloc else--

1753
01:30:15,870 --> 01:30:17,100
malloc taille event--

1754
01:30:17,100 --> 01:30:20,180
alors que le bloc d'origine
de la mémoire n'est pas libérée.

1755
01:30:20,180 --> 01:30:21,490
Et nous avons officiellement perdu.

1756
01:30:21,490 --> 01:30:23,150
C'est une fuite de mémoire.

1757
01:30:23,150 --> 01:30:25,090
Nous avons perdu toutes les références
pour ce bloc de mémoire.

1758
01:30:25,090 --> 01:30:26,827
Il n'y a donc aucun moyen que nous pouvons jamais libérer.

1759
01:30:26,827 --> 01:30:32,074

1760
01:30:32,074 --> 01:30:36,630
OK, donc puis retourner 0 moyen fait.

1761
01:30:36,630 --> 01:30:37,900
>> Très bien, si débordement pile.

1762
01:30:37,900 --> 01:30:39,320
Quelle est l'idée ici?

1763
01:30:39,320 --> 01:30:41,210
Alors rappelez-vous, tas est à la baisse.

1764
01:30:41,210 --> 01:30:43,480
Pile est à la hausse.

1765
01:30:43,480 --> 01:30:48,000
Donc, ce fut l'exemple de conférence,
Je pense, où principal va tout simplement

1766
01:30:48,000 --> 01:30:51,380
appeler cette fonction foo, qui va
de s'appeler récursivement sur et

1767
01:30:51,380 --> 01:30:52,320
encore.

1768
01:30:52,320 --> 01:30:55,370
>> Donc pile cadres vont
fonctionner exactement de la même.

1769
01:30:55,370 --> 01:30:58,130
Donc, nous allons commencer avec les principaux
que le cadre de pile bas.

1770
01:30:58,130 --> 01:31:02,000
Puis principale va appeler foo, qui
va obtenir un cadre de pile.

1771
01:31:02,000 --> 01:31:04,260
>> Puis foo va appeler foo
nouveau, qui va se faire

1772
01:31:04,260 --> 01:31:05,500
un autre cadre de pile.

1773
01:31:05,500 --> 01:31:08,270
Et puis encore, et encore, et encore,
et encore jusqu'à ce que, finalement, nous courons

1774
01:31:08,270 --> 01:31:09,190
dans le tas.

1775
01:31:09,190 --> 01:31:11,990
Voilà donc comment nous obtenons
un débordement de pile.

1776
01:31:11,990 --> 01:31:14,910
Et à ce stade, vous SEG faute.

1777
01:31:14,910 --> 01:31:17,335
Ou vous voulez vraiment la faute seg avant
ce point, mais oui.

1778
01:31:17,335 --> 01:31:19,660
>> PUBLIC: Est-core dump l'
même que seg faute?

1779
01:31:19,660 --> 01:31:26,140
>> ROB: Donc vous verrez segmentation
noyau de défaut déversés.

1780
01:31:26,140 --> 01:31:28,760
Vous obtenez un core dump quand
vous SEG faute.

1781
01:31:28,760 --> 01:31:32,580
Et c'est comme un dépotoir de tous les
contenu de votre mémoire en cours afin

1782
01:31:32,580 --> 01:31:36,670
que vous pouvez essayer d'identifier
pourquoi vous SEG défaut.

1783
01:31:36,670 --> 01:31:37,135
Ouais?

1784
01:31:37,135 --> 01:31:38,385
>> PUBLIC: [inaudible]?

1785
01:31:38,385 --> 01:31:40,855

1786
01:31:40,855 --> 01:31:45,460
>> ROB: Donc un moyen de segmentation de défaut
il ya un débordement de pile.

1787
01:31:45,460 --> 01:31:47,060
Donc, pas nécessairement.

1788
01:31:47,060 --> 01:31:49,880
Signifie un défaut de segmentation que vous êtes
souvenir ému d'une manière

1789
01:31:49,880 --> 01:31:50,880
vous ne devriez pas l'être.

1790
01:31:50,880 --> 01:31:54,750
Donc, une façon de ce qui se passe, c'est que lorsque
vous empilez trop-plein, nous commençons à toucher

1791
01:31:54,750 --> 01:31:58,736
mémoire d'une manière que nous ne devrions pas être.

1792
01:31:58,736 --> 01:31:59,208
Ouais?

1793
01:31:59,208 --> 01:32:00,458
>> PUBLIC: [inaudible]?

1794
01:32:00,458 --> 01:32:03,456

1795
01:32:03,456 --> 01:32:05,830
>> ROB: Donc, à l'intérieur d'une boucle infinie.

1796
01:32:05,830 --> 01:32:08,770
Comme, c'est comme une infinie récursive
boucle et ainsi nous obtenons une autre

1797
01:32:08,770 --> 01:32:09,770
pile encadrer chaque fois.

1798
01:32:09,770 --> 01:32:13,540
Mais juste à l'intérieur d'un régulier
infini tandis que un--

1799
01:32:13,540 --> 01:32:16,390
Eh bien, même pas imprimer F--

1800
01:32:16,390 --> 01:32:17,040
faire quelque chose.

1801
01:32:17,040 --> 01:32:18,390
Peu importe.

1802
01:32:18,390 --> 01:32:20,610
>> Nous n'allons pas être d'obtenir
un autre cadre de pile.

1803
01:32:20,610 --> 01:32:22,530
Nous allons juste garder boucle
au cours de cette instruction unique.

1804
01:32:22,530 --> 01:32:23,920
La pile ne se développe pas.

1805
01:32:23,920 --> 01:32:27,290
C'est le fait que chaque récursive
appel nous donne un cadre de pile.

1806
01:32:27,290 --> 01:32:31,231
C'est pourquoi nous obtenons un débordement de pile.

1807
01:32:31,231 --> 01:32:31,728
Ouais?

1808
01:32:31,728 --> 01:32:38,189
>> PUBLIC: Donc, si vous avez dit pour obtenir le
tout en boucle, puis [inaudible]?

1809
01:32:38,189 --> 01:32:42,000
>> ROB: Donc, si à l'intérieur de la boucle while
il y avait un printf, vous le feriez encore

1810
01:32:42,000 --> 01:32:42,790
défaut ne seg.

1811
01:32:42,790 --> 01:32:46,090
Je ne voulais pas compliquer les choses.

1812
01:32:46,090 --> 01:32:46,610
Il serait boucle.

1813
01:32:46,610 --> 01:32:48,225
Vous souhaitez obtenir une seule pile
encadrer pour la fonction printf.

1814
01:32:48,225 --> 01:32:49,580
>> Puis printf reviendrait.

1815
01:32:49,580 --> 01:32:50,280
Ensuite, vous feriez encore boucle.

1816
01:32:50,280 --> 01:32:51,460
Vous souhaitez obtenir une seule pile
encadrer pour la fonction printf.

1817
01:32:51,460 --> 01:32:52,850
Il reviendrait.

1818
01:32:52,850 --> 01:32:54,060
Simple cadre de pile.

1819
01:32:54,060 --> 01:33:00,215
Donc, vous n'obtenez pas cet infini
empilant des cadres de pile.

1820
01:33:00,215 --> 01:33:03,185
>> PUBLIC: [inaudible]?

1821
01:33:03,185 --> 01:33:04,040
>> ROB: Oui.

1822
01:33:04,040 --> 01:33:09,360
Donc, ce débordement de pile qui se passe
car aucun de ces

1823
01:33:09,360 --> 01:33:11,600
appels à foo sont de retour.

1824
01:33:11,600 --> 01:33:15,250
Donc, si nous revenons, nous n'aurions
commencer à perdre des trames de pile.

1825
01:33:15,250 --> 01:33:17,870
Et puis, nous ne serions pas empiler trop-plein.

1826
01:33:17,870 --> 01:33:20,070
Et c'est pourquoi vous avez besoin d'un scénario de base
pour vos fonctions personnelles.

1827
01:33:20,070 --> 01:33:22,992

1828
01:33:22,992 --> 01:33:23,479
Ouais?

1829
01:33:23,479 --> 01:33:27,375
>> PUBLIC: La taille potentielle et l'
empiler des tas de même pour

1830
01:33:27,375 --> 01:33:29,880
tous les programmes?

1831
01:33:29,880 --> 01:33:31,910
>> ROB: Environ.

1832
01:33:31,910 --> 01:33:35,090
Est la taille potentielle de la pile et
le segment de mémoire de la même pour tous les programmes?

1833
01:33:35,090 --> 01:33:37,180
Environ.

1834
01:33:37,180 --> 01:33:40,080
Il ya une certaine randomisation à
où l'empilement et commence

1835
01:33:40,080 --> 01:33:42,400
où commence le tas.

1836
01:33:42,400 --> 01:33:45,870
S'il vous arrive d'avoir un tas de
des variables globales et les choses, vous pourriez

1837
01:33:45,870 --> 01:33:49,520
enlever de l'espace
pour votre tas.

1838
01:33:49,520 --> 01:33:54,060
>> Sur un système 64 bits, vous presque
disposer d'une mémoire infinie.

1839
01:33:54,060 --> 01:33:55,820
Il ya tellement de choses.

1840
01:33:55,820 --> 01:33:59,250
Entre 32 et 64 bits, que
une différence significative.

1841
01:33:59,250 --> 01:34:02,350
>> Vous allez obtenir un ensemble beaucoup plus
empiler et de l'espace du segment sur 64 bits

1842
01:34:02,350 --> 01:34:05,810
système, car il ya un peu plus
adresses qu'ils peuvent utiliser.

1843
01:34:05,810 --> 01:34:09,360
Mais sur un système individuel, il sera
être à peu près la même quantité de pile

1844
01:34:09,360 --> 01:34:10,785
et de l'espace du tas.

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
>> Donc, dernière chose est la compilation.

1848
01:34:18,220 --> 01:34:19,810
Donc, vous devez savoir ce processus.

1849
01:34:19,810 --> 01:34:22,240
Il ya quatre grandes étapes.

1850
01:34:22,240 --> 01:34:24,400
Donc, le premier devrait
être facile à retenir.

1851
01:34:24,400 --> 01:34:25,085
Pré-traitement.

1852
01:34:25,085 --> 01:34:28,390
Il a le préfixe pré en elle.

1853
01:34:28,390 --> 01:34:32,080
Donc, il s'agit avant tout le reste.

1854
01:34:32,080 --> 01:34:34,000
>> La chose à retenir est le hachage.

1855
01:34:34,000 --> 01:34:37,250
Donc hachage définit et comprend hachage
Dans l'ensemble de ceux-ci.

1856
01:34:37,250 --> 01:34:39,560
Ce sont tous pré-processeur
directives.

1857
01:34:39,560 --> 01:34:42,030
Ce sont les choses que les
pré-processeur prend en charge.

1858
01:34:42,030 --> 01:34:43,680
>> Alors qu'est-ce un pré-processeur faire?

1859
01:34:43,680 --> 01:34:44,850
C'est une chose vraiment stupide.

1860
01:34:44,850 --> 01:34:49,380
Tout ce qu'il est capable de sont tous ces
copie, et coupées, et coller des opérations.

1861
01:34:49,380 --> 01:34:51,790
>> Donc hachage comprend norme i0 point h.

1862
01:34:51,790 --> 01:34:52,990
Qu'est-ce que faire?

1863
01:34:52,990 --> 01:34:56,610
C'est saisissant le point i0 h norme
déposer et de le coller dans le haut

1864
01:34:56,610 --> 01:34:58,960
où il est dit hachage comprend
norme i0 point h.

1865
01:34:58,960 --> 01:35:02,480
>> Et tout hachage définir que nous avons
vu, ce qui est que faire?

1866
01:35:02,480 --> 01:35:06,730
Son copiant la valeur que le hachage
défini est défini comme et le coller

1867
01:35:06,730 --> 01:35:08,500
partout où vous utilisez la valeur.

1868
01:35:08,500 --> 01:35:13,400
Ainsi, le préprocesseur vraiment
opérations fondées sur des textes simples.

1869
01:35:13,400 --> 01:35:15,870
Il ne fait rien à puce.

1870
01:35:15,870 --> 01:35:18,920
Donc, tout le reste est
plus compliqué.

1871
01:35:18,920 --> 01:35:22,970
>> Alors, maintenant que préprocesseur est
faire, nous compilons fait.

1872
01:35:22,970 --> 01:35:24,320
Alors qu'est-ce compilation veut dire?

1873
01:35:24,320 --> 01:35:27,310
Nous allons maintenant à partir du code c
de code assembleur.

1874
01:35:27,310 --> 01:35:27,570
Ouais?

1875
01:35:27,570 --> 01:35:28,820
>> PUBLIC: [inaudible]?

1876
01:35:28,820 --> 01:35:32,390

1877
01:35:32,390 --> 01:35:34,220
>> ROB: Oui, nous avons pris cela.

1878
01:35:34,220 --> 01:35:36,880

1879
01:35:36,880 --> 01:35:38,660
Donc la compilation.

1880
01:35:38,660 --> 01:35:40,310
Nous allons de c à l'assemblage.

1881
01:35:40,310 --> 01:35:42,470
Il s'agit donc d'un changement de langue réelle.

1882
01:35:42,470 --> 01:35:45,240
Compiler soi, c'est aller de
un langage de haut niveau à

1883
01:35:45,240 --> 01:35:47,340
un langage de niveau inférieur.

1884
01:35:47,340 --> 01:35:50,720
>> Et c est un langage de haut niveau
par rapport à l'assemblage.

1885
01:35:50,720 --> 01:35:52,320
Qu'est-ce que le montage?

1886
01:35:52,320 --> 01:35:56,440
Ses instructions qui sont, assez
beaucoup, fait de votre CPU.

1887
01:35:56,440 --> 01:35:59,130
Mais votre ordinateur ne fonctionne toujours
pas comprendre ensemble.

1888
01:35:59,130 --> 01:36:01,570
Il ne comprend uns et de zéros.

1889
01:36:01,570 --> 01:36:06,160
Donc, la prochaine étape est l'assemblage, qui
nous amène de ces instructions

1890
01:36:06,160 --> 01:36:08,760
votre CPU comprend et fait
les traduit, à

1891
01:36:08,760 --> 01:36:10,820
les uns et de zéros.

1892
01:36:10,820 --> 01:36:13,570
>> Donc C du code assembleur en binaire.

1893
01:36:13,570 --> 01:36:15,870
Mais je n'ai pas encore un exécutable.

1894
01:36:15,870 --> 01:36:19,550
Alors, pensez à la bibliothèque de CS50.

1895
01:36:19,550 --> 01:36:23,070
Nous vous avons fourni un binaire pour
cette bibliothèque de CS50, qui a GetString

1896
01:36:23,070 --> 01:36:24,400
et getint et tout ça.

1897
01:36:24,400 --> 01:36:25,700
>> Mais la CS50 library--

1898
01:36:25,700 --> 01:36:27,650
dans et elle s'est d'abord n'est pas exécutable.

1899
01:36:27,650 --> 01:36:29,570
Elle n'a pas de fonction principale.

1900
01:36:29,570 --> 01:36:32,230
C'est juste un tas de binaire
que vous pouvez utiliser.

1901
01:36:32,230 --> 01:36:41,730
Donc, la liaison est la façon dont nous rassembler tous
de ces différents fichiers binaires

1902
01:36:41,730 --> 01:36:43,110
dans un exécutable réel.

1903
01:36:43,110 --> 01:36:45,900
Celui que vous pouvez taper
point slash un point sur.

1904
01:36:45,900 --> 01:36:51,660
>> Donc, c'est comme le fichier que vous
écrit, - quel que soit votre programme is--

1905
01:36:51,660 --> 01:36:53,620
Ceaser point c.

1906
01:36:53,620 --> 01:36:55,100
Mais maintenant, il a été compilé
jusqu'à binaire.

1907
01:36:55,100 --> 01:36:56,480
Donc Ceaser point o.

1908
01:36:56,480 --> 01:36:59,620
Et c'est notre CS50 bibliothèques binaire.

1909
01:36:59,620 --> 01:37:02,284
Et ils sont en cours de combinés
en un seul exécutable.

1910
01:37:02,284 --> 01:37:02,758
Ouais?

1911
01:37:02,758 --> 01:37:04,008
>> PUBLIC: [inaudible]?

1912
01:37:04,008 --> 01:37:08,800

1913
01:37:08,800 --> 01:37:12,710
>> ROB: comprend donc d'abord, souvenez-vous,
le hachage inclure est en fait un

1914
01:37:12,710 --> 01:37:13,810
pré-processeur étape.

1915
01:37:13,810 --> 01:37:14,750
Mais ce n'est séparée.

1916
01:37:14,750 --> 01:37:20,730
Si vous n'utilisez pas les fonctions que
sont à l'extérieur de votre fichier unique puis,

1917
01:37:20,730 --> 01:37:26,100
non, vous n'avez pas besoin de lier tout
puisque vous avez tout.

1918
01:37:26,100 --> 01:37:30,310
>> Cela dit, printf est liée à.

1919
01:37:30,310 --> 01:37:32,820
Si jamais vous utilisez printf, c'est quelque chose
qui doit être lié à

1920
01:37:32,820 --> 01:37:35,740
parce que vous n'avez pas écrit cela.

1921
01:37:35,740 --> 01:37:39,530
Et, de fait, est automatiquement printf
lié à.

1922
01:37:39,530 --> 01:37:42,760
Vous savez comment à la ligne de commande ou lorsque
vous tapez faites, vous le voyez ont

1923
01:37:42,760 --> 01:37:46,690
tableau de bord l CS50, qui a lien
dans la bibliothèque de CS50?

1924
01:37:46,690 --> 01:37:49,070
Printf, et des trucs comme ça, va
à lier automatiquement.

1925
01:37:49,070 --> 01:37:51,730

1926
01:37:51,730 --> 01:37:53,930
D'autres questions sur quoi que ce soit?

1927
01:37:53,930 --> 01:37:56,280
>> PUBLIC: [inaudible]?

1928
01:37:56,280 --> 01:37:58,300
>> ROB: lier?

1929
01:37:58,300 --> 01:38:03,450
Nous avons tout un tas de
différents fichiers binaires.

1930
01:38:03,450 --> 01:38:06,410
C'est l'exemple canonique
que nous utilisons est une bibliothèque de CS50.

1931
01:38:06,410 --> 01:38:09,960
Nous avons compilé et qui vous est donné le
binaire pour cette bibliothèque CS50.

1932
01:38:09,960 --> 01:38:12,410
>> Vous souhaitez utiliser GetString
dans votre programme.

1933
01:38:12,410 --> 01:38:14,750
Alors vous allez utiliser GetString.

1934
01:38:14,750 --> 01:38:19,700
Mais sans mon code binaire pour
GetString, lorsque vous compilez votre code

1935
01:38:19,700 --> 01:38:23,140
vers le bas, vous ne pouvez pas réellement faire fonctionner votre
programme parce GetString String est

1936
01:38:23,140 --> 01:38:25,080
pas encore totalement définies.

1937
01:38:25,080 --> 01:38:29,220
>> C'est seulement lorsque vous liez à mon binaire
qui contient GetString que maintenant, tout

1938
01:38:29,220 --> 01:38:31,130
droite, je peux effectivement
exécuter GetString.

1939
01:38:31,130 --> 01:38:32,330
Mon dossier est complet.

1940
01:38:32,330 --> 01:38:34,208
Et je peux exécuter ce.

1941
01:38:34,208 --> 01:38:34,697
Ouais?

1942
01:38:34,697 --> 01:38:37,631
>> PUBLIC: Ne reliant convertir
le binaire exécutable à?

1943
01:38:37,631 --> 01:38:42,032
Donc, même si vous n'avez pas d'autres
bibliothèques, ça ne serait pas encore

1944
01:38:42,032 --> 01:38:44,477
nécessaire de traduire
la [inaudible]?

1945
01:38:44,477 --> 01:38:48,640
>> ROB: Donc un exécutable
est encore en binaire.

1946
01:38:48,640 --> 01:38:51,750
C'est juste la combinaison d'un ensemble de
tas de fichiers binaires.

1947
01:38:51,750 --> 01:38:55,124

1948
01:38:55,124 --> 01:38:56,591
>> PUBLIC: Merci beaucoup.

1949
01:38:56,591 --> 01:38:58,560
>> ROB: Pas de problème.

1950
01:38:58,560 --> 01:38:59,540
D'autres questions?

1951
01:38:59,540 --> 01:39:02,001
Sinon, nous sommes tous mis.

1952
01:39:02,001 --> 01:39:02,690
Bien.

1953
01:39:02,690 --> 01:39:02,990
Merci.

1954
01:39:02,990 --> 01:39:03,590
>> [Applaudissements]

1955
01:39:03,590 --> 01:39:04,490
>> PUBLIC: Je vous remercie.

1956
01:39:04,490 --> 01:39:05,740
>> ROB: Oui.

1957
01:39:05,740 --> 01:39:06,582