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

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

3
00:00:05,000 --> 00:00:08,000
>> [C'est CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Hey, tout le monde.

5
00:00:10,000 --> 00:00:15,000
Bienvenue à la session d'examen pour Quiz 0, qui se déroule ce mercredi.

6
00:00:15,000 --> 00:00:19,000
Ce que nous allons faire ce soir, je suis avec 3 autres fonds fiduciaires,

7
00:00:19,000 --> 00:00:24,000
et ensemble, nous allons passer par un examen de ce que nous avons fait au cours jusqu'ici.

8
00:00:24,000 --> 00:00:27,000
Il ne va pas à 100% complet, mais elle devrait vous donner une meilleure idée

9
00:00:27,000 --> 00:00:31,000
de ce que vous avez déjà vers le bas et ce que vous avez encore besoin d'étudier avant mercredi.

10
00:00:31,000 --> 00:00:34,000
Et n'hésitez pas à lever la main avec des questions comme nous allons le long,

11
00:00:34,000 --> 00:00:38,000
mais gardez à l'esprit que nous aurons aussi un peu de temps à la fin-

12
00:00:38,000 --> 00:00:41,000
si nous obtenons par le biais de quelques minutes pour faire de rechange à des questions générales,

13
00:00:41,000 --> 00:00:47,000
donc gardez cela à l'esprit, et nous allons commencer au début de la semaine 0.

14
00:00:47,000 --> 00:00:50,000
>> [Quiz 0 Commentaire!] [Partie 0] [Lexi Ross] Mais avant cela nous allons parler de

15
00:00:50,000 --> 00:00:53,000
la logistique du quiz.

16
00:00:53,000 --> 00:00:55,000
>> [Logistique] [Quiz aura lieu le mercredi 10/10 au lieu de la conférence]

17
00:00:55,000 --> 00:00:57,000
>> [(Voir http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf pour plus de détails)] C'est le mercredi 10 Octobre.

18
00:00:57,000 --> 00:01:00,000
>> C'est ce mercredi, et si vous allez à cette adresse ici,

19
00:01:00,000 --> 00:01:03,000
qui est également accessible à partir CS50.net-il ya un lien vers elle-

20
00:01:03,000 --> 00:01:06,000
vous pouvez voir les informations pour savoir où aller fondée sur

21
00:01:06,000 --> 00:01:10,000
votre nom de famille ou de leur appartenance école ainsi que

22
00:01:10,000 --> 00:01:14,000
il raconte exactement ce que le questionnaire couvrira et les types de questions que vous allez obtenir.

23
00:01:14,000 --> 00:01:19,000
Gardez à l'esprit que vous aurez également l'occasion d'examiner pour le quiz en coupe,

24
00:01:19,000 --> 00:01:21,000
afin que vos FO devrait aller sur certains problèmes pratiques,

25
00:01:21,000 --> 00:01:29,000
et c'est une autre bonne occasion de voir où vous avez encore besoin d'étudier pour le quiz.

26
00:01:29,000 --> 00:01:32,000
Commençons par le début avec Octets Bits 'n'.

27
00:01:32,000 --> 00:01:35,000
Rappelez-vous un peu, c'est juste un 0 ou un 1,

28
00:01:35,000 --> 00:01:38,000
et un octet est un ensemble de 8 de ces bits.

29
00:01:38,000 --> 00:01:42,000
Penchons-nous sur cette collection de morceaux ici.

30
00:01:42,000 --> 00:01:44,000
Nous devrions être en mesure de déterminer combien de bits il ya.

31
00:01:44,000 --> 00:01:48,000
Où l'on compte il ya seulement 8 d'entre eux, huit unités 0 ou 1.

32
00:01:48,000 --> 00:01:51,000
Et comme il ya 8 bits, cela fait 1 octet,

33
00:01:51,000 --> 00:01:53,000
et nous allons la convertir en hexadécimal.

34
00:01:53,000 --> 00:01:58,000
Hexadécimal est en base 16, et il est assez facile de convertir

35
00:01:58,000 --> 00:02:01,000
un nombre en binaire, ce qui est ce que c'est, pour un certain nombre en hexadécimal.

36
00:02:01,000 --> 00:02:04,000
Nous ne faisons que nous regardons groupes de 4,

37
00:02:04,000 --> 00:02:07,000
et nous les convertir au chiffre hexadécimal approprié.

38
00:02:07,000 --> 00:02:11,000
Nous commençons avec le groupe le plus à droite de 4, donc 0011.

39
00:02:11,000 --> 00:02:16,000
Cela va être un 1 et un 2, donc ensemble qui fait 3.

40
00:02:16,000 --> 00:02:19,000
Et puis, regardons l'autre bloc de 4.

41
00:02:19,000 --> 00:02:24,000
1101. Cela va être un 1, un 4 et un 8.

42
00:02:24,000 --> 00:02:28,000
Ensemble, ça va être de 13, ce qui rend D.

43
00:02:28,000 --> 00:02:32,000
Et nous nous souviendrons que nous en hexadécimal ne pas simplement aller de 0 à 9.

44
00:02:32,000 --> 00:02:36,000
Nous allons 0 à F, si bien qu'après 9, 10 correspond à A,

45
00:02:36,000 --> 00:02:40,000
11 à B, et ainsi de suite où F est de 15.

46
00:02:40,000 --> 00:02:44,000
Ici, 13 est un D,

47
00:02:44,000 --> 00:02:49,000
afin de le convertir en décimal nous ne faisons que nous avons fait

48
00:02:49,000 --> 00:02:52,000
traiter chaque situation comme une puissance de 2.

49
00:02:52,000 --> 00:02:58,000
C'est un 1, un 2, zéro 4s, 8s zéro, un 16, et cetera,

50
00:02:58,000 --> 00:03:03,000
et c'est un peu difficile à calculer dans votre tête, mais si nous allons à la diapositive suivante

51
00:03:03,000 --> 00:03:05,000
nous pouvons voir la réponse à cette question.

52
00:03:05,000 --> 00:03:09,000
>> Essentiellement, nous allons en face de la droite vers la gauche,

53
00:03:09,000 --> 00:03:14,000
et nous multiplier chaque chiffre par la puissance correspondante de 2.

54
00:03:14,000 --> 00:03:19,000
Et rappelez-vous, pour hexadécimal on note ces chiffres avec 0x au début

55
00:03:19,000 --> 00:03:23,000
nous n'avons donc pas le confondre avec un nombre décimal.

56
00:03:23,000 --> 00:03:29,000
Poursuivant, il s'agit d'un tableau ASCII,

57
00:03:29,000 --> 00:03:35,000
et ce que nous utilisons pour ASCII est de cartographier de caractères en valeurs numériques.

58
00:03:35,000 --> 00:03:39,000
Rappelez-vous dans le pset cryptographie, nous avons fait un usage intensif de la table ASCII

59
00:03:39,000 --> 00:03:43,000
afin d'utiliser diverses méthodes de cryptographie,

60
00:03:43,000 --> 00:03:47,000
le César et le chiffrement de Vigenère, pour convertir les différentes lettres

61
00:03:47,000 --> 00:03:52,000
dans une chaîne selon la clé fournie par l'utilisateur.

62
00:03:52,000 --> 00:03:56,000
Regardons d'un peu de maths ASCII.

63
00:03:56,000 --> 00:04:02,000
Consultant d''P' + 1, en forme de caractères qui serait Q,

64
00:04:02,000 --> 00:04:07,000
et n'oubliez pas que '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
Et de quelle façon pourrions-nous convertir entre ces 2 formes?

66
00:04:10,000 --> 00:04:13,000
Ce n'est pas vraiment trop dur.

67
00:04:13,000 --> 00:04:16,000
Afin d'obtenir 5 on soustrait '0 '

68
00:04:16,000 --> 00:04:20,000
parce qu'il ya 5 places entre '0 'et '5'.

69
00:04:20,000 --> 00:04:23,000
Pour aller dans l'autre sens nous suffit d'ajouter le 0,

70
00:04:23,000 --> 00:04:25,000
donc c'est un peu comme l'arithmétique ordinaire.

71
00:04:25,000 --> 00:04:29,000
N'oubliez pas que lorsque quelque chose doit guillemets autour de lui c'est un personnage

72
00:04:29,000 --> 00:04:37,000
et correspond donc à une valeur dans la table ASCII.

73
00:04:37,000 --> 00:04:40,000
S'engager dans des sujets plus généraux de l'informatique.

74
00:04:40,000 --> 00:04:43,000
Nous avons appris ce qu'est un algorithme est et comment nous utilisons la programmation

75
00:04:43,000 --> 00:04:45,000
d'implémenter des algorithmes.

76
00:04:45,000 --> 00:04:48,000
Quelques exemples d'algorithmes sont quelque chose de vraiment simple, comme

77
00:04:48,000 --> 00:04:51,000
vérifier si un nombre est pair ou impair.

78
00:04:51,000 --> 00:04:54,000
Pour cela nous rappelle mod le nombre par 2 et vérifier si le résultat est 0.

79
00:04:54,000 --> 00:04:57,000
Si c'est le cas, c'est encore plus. Sinon, c'est bizarre.

80
00:04:57,000 --> 00:04:59,000
Et c'est un exemple d'un algorithme très basique.

81
00:04:59,000 --> 00:05:02,000
>> Un peu d'un plus impliqué est binaire de recherche,

82
00:05:02,000 --> 00:05:05,000
que nous allons passer en revue plus tard dans la session d'examen.

83
00:05:05,000 --> 00:05:09,000
Et la programmation est le terme que nous utilisons pour prendre un algorithme

84
00:05:09,000 --> 00:05:15,000
et les convertit en coder l'ordinateur peut lire.

85
00:05:15,000 --> 00:05:20,000
2 exemples de programmation est Scratch,

86
00:05:20,000 --> 00:05:22,000
qui est ce que nous avons fait dans la semaine 0.

87
00:05:22,000 --> 00:05:25,000
Même si nous ne tapez pas sur le code, c'est une façon de mettre en œuvre

88
00:05:25,000 --> 00:05:29,000
cet algorithme, qui imprime les nombres 1-10,

89
00:05:29,000 --> 00:05:32,000
et ici nous faire la même chose dans le langage de programmation C.

90
00:05:32,000 --> 00:05:41,000
Ceux-ci sont fonctionnellement équivalents, vient d'écrire dans des langues différentes ou de syntaxe.

91
00:05:41,000 --> 00:05:44,000
Nous avons alors appris sur les expressions booléennes,

92
00:05:44,000 --> 00:05:48,000
et un booléen est une valeur qui est soit vraie ou fausse,

93
00:05:48,000 --> 00:05:51,000
et les expressions booléennes souvent ici

94
00:05:51,000 --> 00:05:55,000
aller à l'intérieur de conditions, si (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
eh bien, nous avons déjà mis en x = 5, alors que l'état va évaluer la valeur true.

96
00:06:00,000 --> 00:06:03,000
Et si c'est vrai, quel que soit le code est sous la condition

97
00:06:03,000 --> 00:06:08,000
va être évaluées par l'ordinateur, de sorte que chaîne va être imprimé

98
00:06:08,000 --> 00:06:12,000
sur la sortie standard, et la condition de durée

99
00:06:12,000 --> 00:06:16,000
se réfère à tout ce qui est à l'intérieur des parenthèses de l'instruction if.

100
00:06:16,000 --> 00:06:20,000
Rappelez-vous tous les opérateurs.

101
00:06:20,000 --> 00:06:26,000
N'oubliez pas que c'est && et | | quand nous essayons de combiner 2 ou plusieurs conditions,

102
00:06:26,000 --> 00:06:30,000
== Pas de vérifier si = 2 choses sont égales.

103
00:06:30,000 --> 00:06:36,000
Rappelez-vous que pour l'affectation = est alors == est un opérateur booléen.

104
00:06:36,000 --> 00:06:41,000
≤, ≥, puis la finale 2 sont auto-explicatifs.

105
00:06:41,000 --> 00:06:45,000
Une revue générale de la logique booléenne ici.

106
00:06:45,000 --> 00:06:48,000
Et les expressions booléennes sont également importants dans les boucles,

107
00:06:48,000 --> 00:06:50,000
que nous allons passer en revue maintenant.

108
00:06:50,000 --> 00:06:56,000
Nous avons appris environ 3 types de boucles jusqu'à présent en CS50, for, while, et à faire pendant.

109
00:06:56,000 --> 00:06:59,000
Et il est important de savoir que, bien que dans la plupart des

110
00:06:59,000 --> 00:07:02,000
nous pouvons utiliser n'importe quel type de boucle généralement

111
00:07:02,000 --> 00:07:06,000
il ya certains types de buts communs ou des motifs

112
00:07:06,000 --> 00:07:09,000
dans la programmation qui appellent spécifiquement pour l'une de ces boucles

113
00:07:09,000 --> 00:07:13,000
qui en font le. plus efficace ou élégant de le coder de cette façon

114
00:07:13,000 --> 00:07:18,000
Passons en revue ce que chacune de ces boucles ont tendance à être utilisés le plus souvent.

115
00:07:18,000 --> 00:07:21,000
>> Dans une boucle for nous avons généralement le savez déjà combien de fois nous voulons parcourir.

116
00:07:21,000 --> 00:07:24,000
C'est ce que nous avons mis dans la condition.

117
00:07:24,000 --> 00:07:28,000
Car, i = 0, i <10, par exemple.

118
00:07:28,000 --> 00:07:31,000
Nous savons déjà que nous voulons faire quelque chose de 10 fois.

119
00:07:31,000 --> 00:07:34,000
Maintenant, pour une boucle while, en général, nous n'avons pas nécessairement

120
00:07:34,000 --> 00:07:36,000
combien de fois nous voulons que la boucle de s'exécuter.

121
00:07:36,000 --> 00:07:39,000
Mais nous savons une sorte de condition que nous voulons qu'il

122
00:07:39,000 --> 00:07:41,000
toujours vrai ou toujours faux.

123
00:07:41,000 --> 00:07:44,000
Par exemple, si est réglé.

124
00:07:44,000 --> 00:07:46,000
Disons que c'est une variable booléenne.

125
00:07:46,000 --> 00:07:48,000
Alors c'est vrai que nous voulons le code d'évaluer,

126
00:07:48,000 --> 00:07:52,000
donc un peu plus extensible, un peu plus générale que celle d'une boucle for,

127
00:07:52,000 --> 00:07:55,000
mais toute boucle for peut également être converti en une boucle while.

128
00:07:55,000 --> 00:08:00,000
Enfin, faire des boucles while, qui peuvent être plus délicate à comprendre tout de suite,

129
00:08:00,000 --> 00:08:04,000
sont souvent utilisés lorsque l'on veut évaluer le premier code

130
00:08:04,000 --> 00:08:06,000
avant la première fois que nous vérifier l'état.

131
00:08:06,000 --> 00:08:09,000
Un cas d'utilisation commune pour une boucle Do While

132
00:08:09,000 --> 00:08:12,000
c'est quand vous voulez pour obtenir l'entrée d'utilisateur, et vous savez que vous voulez demander à l'utilisateur

133
00:08:12,000 --> 00:08:15,000
pour l'entrée au moins une fois, mais s'ils ne vous donnent pas une bonne entrée tout de suite

134
00:08:15,000 --> 00:08:18,000
vous voulez garder leur demandant jusqu'à ce qu'ils vous donnent la bonne entrée.

135
00:08:18,000 --> 00:08:21,000
C'est l'utilisation la plus courante d'une boucle Do While,

136
00:08:21,000 --> 00:08:23,000
et regardons la structure réelle de ces boucles.

137
00:08:23,000 --> 00:08:27,000
En général, ils ont toujours tendance à suivre ces tendances.

138
00:08:27,000 --> 00:08:30,000
>> Sur la boucle de l'intérieur vous avez 3 composantes:

139
00:08:30,000 --> 00:08:35,000
l'initialisation, généralement quelque chose comme int i = 0 où i est le compteur,

140
00:08:35,000 --> 00:08:40,000
condition, là où nous voulons dire exécuter ce pour boucle tant que cette condition est toujours valable,

141
00:08:40,000 --> 00:08:44,000
comme i <10, et enfin, mise à jour, qui est de savoir comment on incrémente

142
00:08:44,000 --> 00:08:47,000
la variable de compteur à chaque point dans la boucle.

143
00:08:47,000 --> 00:08:50,000
Une chose commune de voir qu'il ya seulement i + +,

144
00:08:50,000 --> 00:08:52,000
ce qui signifie incrémenter i de 1 à chaque fois.

145
00:08:52,000 --> 00:08:55,000
Vous pouvez aussi faire quelque chose comme i + = 2,

146
00:08:55,000 --> 00:08:58,000
ce qui signifie ajouter 2 à i chaque fois que vous allez à travers la boucle.

147
00:08:58,000 --> 00:09:03,000
Et puis la faire se réfère seulement à un code qui fonctionne effectivement dans le cadre de la boucle.

148
00:09:03,000 --> 00:09:09,000
Et pour une boucle while, cette fois, nous avons fait l'initialisation en dehors de la boucle,

149
00:09:09,000 --> 00:09:12,000
Ainsi, par exemple, disons que nous essayons de faire le même type de boucle que je viens de décrire.

150
00:09:12,000 --> 00:09:16,000
Nous dirions int i = 0 avant que la boucle commence.

151
00:09:16,000 --> 00:09:20,000
Alors nous pourrions dire tout i <10 ce faire,

152
00:09:20,000 --> 00:09:22,000
de sorte que le même bloc de code comme précédemment,

153
00:09:22,000 --> 00:09:26,000
et cette fois, la partie mise à jour du code, par exemple, i + +,

154
00:09:26,000 --> 00:09:29,000
va en fait à l'intérieur de la boucle.

155
00:09:29,000 --> 00:09:33,000
Et enfin, pour faire un tout, il est semblable à la boucle while,

156
00:09:33,000 --> 00:09:36,000
mais nous devons nous rappeler que le code d'évaluer fois

157
00:09:36,000 --> 00:09:40,000
avant que la condition est vérifiée, il est donc beaucoup plus de sens

158
00:09:40,000 --> 00:09:44,000
si vous regardez dans l'ordre de haut en bas.

159
00:09:44,000 --> 00:09:49,000
Dans un, faire boucle while évalue le code avant même de regarder l'état tout en

160
00:09:49,000 --> 00:09:55,000
alors une boucle while, il vérifie d'abord.

161
00:09:55,000 --> 00:09:59,000
Instructions et variables.

162
00:09:59,000 --> 00:10:04,000
Lorsque nous voulons créer une nouvelle variable nous voulons d'abord l'initialiser.

163
00:10:04,000 --> 00:10:07,000
>> Par exemple, un bar int initialise la variable bar,

164
00:10:07,000 --> 00:10:10,000
mais il ne lui donne pas une valeur, alors quelle est la valeur bar maintenant?

165
00:10:10,000 --> 00:10:12,000
Nous ne savons pas.

166
00:10:12,000 --> 00:10:14,000
Il pourrait s'agir d'une valeur ordures qui a été précédemment stocké dans la mémoire là-bas,

167
00:10:14,000 --> 00:10:16,000
et nous ne voulons pas d'utiliser cette variable

168
00:10:16,000 --> 00:10:19,000
jusqu'à ce que nous lui donner une valeur,

169
00:10:19,000 --> 00:10:21,000
si on le déclare ici.

170
00:10:21,000 --> 00:10:24,000
Ensuite, nous avons l'initialiser à 42 ci-dessous.

171
00:10:24,000 --> 00:10:28,000
Maintenant, bien sûr, nous savons que cela peut être fait sur une seule ligne, un bar int = 42.

172
00:10:28,000 --> 00:10:30,000
Mais juste pour être clair les multiples étapes qui sont en cours,

173
00:10:30,000 --> 00:10:34,000
la déclaration et l'initialisation se produisent séparément ici.

174
00:10:34,000 --> 00:10:38,000
Il arrive sur une étape et la suivante, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
cette déclaration ci-dessous, que baz incréments, de sorte qu'à la fin de ce bloc de code

176
00:10:44,000 --> 00:10:48,000
si nous devions imprimer la valeur de baz il serait de 44

177
00:10:48,000 --> 00:10:52,000
parce que nous déclarons et l'initialiser à 1 bar>

178
00:10:52,000 --> 00:10:58,000
et puis nous l'incrémenter une fois de plus avec le + +.

179
00:10:58,000 --> 00:11:02,000
Nous sommes allés au cours de cette brève joli, mais il est bon d'avoir un général

180
00:11:02,000 --> 00:11:04,000
la compréhension de ce que les discussions et les événements sont.

181
00:11:04,000 --> 00:11:06,000
Nous avons principalement fait dans Scratch,

182
00:11:06,000 --> 00:11:09,000
de sorte que vous pouvez penser de threads que plusieurs séquences de code

183
00:11:09,000 --> 00:11:11,000
exécute en même temps.

184
00:11:11,000 --> 00:11:14,000
En réalité, il n'est probablement pas en cours d'exécution dans le même temps,

185
00:11:14,000 --> 00:11:17,000
mais en quelque sorte abstraite, nous pouvons penser que c'est de cette façon.

186
00:11:17,000 --> 00:11:20,000
>> Dans Scratch, par exemple, nous avons eu les sprites multiples.

187
00:11:20,000 --> 00:11:22,000
On pourrait exécuter du code différente en même temps.

188
00:11:22,000 --> 00:11:26,000
On peut se promener pendant que l'autre veut dire quelque chose

189
00:11:26,000 --> 00:11:29,000
dans une autre partie de l'écran.

190
00:11:29,000 --> 00:11:34,000
Les événements sont une autre façon de séparer la logique

191
00:11:34,000 --> 00:11:37,000
entre les différents éléments de votre code,

192
00:11:37,000 --> 00:11:40,000
et dans Scratch, nous avons pu simuler des événements en utilisant la diffusion,

193
00:11:40,000 --> 00:11:43,000
et c'est en fait quand je reçois, pas quand j'entends,

194
00:11:43,000 --> 00:11:47,000
mais essentiellement, c'est une façon de transmettre l'information

195
00:11:47,000 --> 00:11:49,000
d'un sprite à l'autre.

196
00:11:49,000 --> 00:11:52,000
Par exemple, vous voudrez peut-être de transmettre game over,

197
00:11:52,000 --> 00:11:56,000
et quand un autre sprite qui reçoit game over,

198
00:11:56,000 --> 00:11:58,000
il répond d'une certaine manière.

199
00:11:58,000 --> 00:12:03,000
C'est un modèle important de comprendre la programmation.

200
00:12:03,000 --> 00:12:07,000
Juste pour revenir sur la Semaine de base 0, ce que nous avons dépassé à ce jour,

201
00:12:07,000 --> 00:12:10,000
Voyons ce programme C simple.

202
00:12:10,000 --> 00:12:14,000
Le texte peut être un peu petite d'ici, mais je vais aller sur ce très rapide.

203
00:12:14,000 --> 00:12:20,000
Nous avons inclus 2 fichiers d'en-tête en haut, cs50.h et stdio.h.

204
00:12:20,000 --> 00:12:23,000
Nous sommes ensuite définir une limite constante appelée à être 100.

205
00:12:23,000 --> 00:12:26,000
Nous sommes ensuite la mise en œuvre de notre fonction principale.

206
00:12:26,000 --> 00:12:29,000
Comme nous n'avons pas utiliser des arguments de ligne de commande ici, nous devons mettre nulle

207
00:12:29,000 --> 00:12:32,000
que les arguments en faveur principal.

208
00:12:32,000 --> 00:12:38,000
Nous voyons ci-dessus int principale. C'est le type de retour, donc retourner 0 en bas.

209
00:12:38,000 --> 00:12:41,000
Et nous utilisons CS50 fonction de bibliothèque obtenir int

210
00:12:41,000 --> 00:12:45,000
de demander à l'utilisateur d'entrer, et nous le stocker dans cette variable x,

211
00:12:45,000 --> 00:12:51,000
si nous déclarons x ci-dessus, et nous l'initialisons avec x = getInt.

212
00:12:51,000 --> 00:12:53,000
>> Nous avons ensuite vérifier si l'utilisateur nous a donné de bonnes suggestions.

213
00:12:53,000 --> 00:12:59,000
Si c'est LIMITE ≥ nous voulons retourner un code d'erreur 1 et affiche un message d'erreur.

214
00:12:59,000 --> 00:13:02,000
Et enfin, si l'utilisateur nous a donné de bonnes suggestions

215
00:13:02,000 --> 00:13:08,000
nous allons résoudre la quadrature du nombre et imprimer ce résultat.

216
00:13:08,000 --> 00:13:11,000
Juste pour s'assurer que les personnes à la maison tous les succès

217
00:13:11,000 --> 00:13:17,000
vous pouvez voir les étiquettes des différentes parties du code ici.

218
00:13:17,000 --> 00:13:19,000
Je l'ai mentionné constants, les fichiers d'en-tête.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Assurez-vous de se rappeler que c'est une variable locale.

220
00:13:21,000 --> 00:13:24,000
Qu'il contraste d'une variable globale, dont nous parlerons à propos de

221
00:13:24,000 --> 00:13:27,000
un peu plus tard dans la session d'examen,

222
00:13:27,000 --> 00:13:30,000
et nous appelons la fonction de bibliothèque printf,

223
00:13:30,000 --> 00:13:34,000
si nous n'avions pas inclus le fichier d'en-tête stdio.h

224
00:13:34,000 --> 00:13:37,000
nous ne serions pas en mesure d'appeler printf.

225
00:13:37,000 --> 00:13:42,000
Et je crois que la flèche qui a été coupé ici est orientée vers l'% d,

226
00:13:42,000 --> 00:13:45,000
qui est une chaîne de formatage dans printf.

227
00:13:45,000 --> 00:13:52,000
Il affirme imprimer cette variable comme un nombre,% d.

228
00:13:52,000 --> 00:13:58,000
Et c'est tout pour la semaine 0.

229
00:13:58,000 --> 00:14:06,000
Maintenant, Lucas va se poursuivre.

230
00:14:06,000 --> 00:14:08,000
Hé, les gars. Mon nom est Lucas.

231
00:14:08,000 --> 00:14:10,000
Je suis un étudiant en deuxième année dans la meilleure maison sur le campus, Mather,

232
00:14:10,000 --> 00:14:14,000
et je vais vous parler un peu de la semaine 1 et 2,1.

233
00:14:14,000 --> 00:14:16,000
[Semaine 1 et 2.1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Comme Lexi disais, quand nous avons commencé à traduire votre code à partir de zéro à C

235
00:14:19,000 --> 00:14:23,000
l'une des choses que nous avons remarqué, c'est que vous ne pouvez pas simplement

236
00:14:23,000 --> 00:14:26,000
écrire votre code et l'exécuter en utilisant un drapeau vert plus.

237
00:14:26,000 --> 00:14:30,000
En fait, vous devez utiliser certaines mesures pour rendre votre programme C

238
00:14:30,000 --> 00:14:33,000
devenir un fichier exécutable.

239
00:14:33,000 --> 00:14:36,000
Fondamentalement, ce que vous faites quand vous écrivez un programme, c'est que

240
00:14:36,000 --> 00:14:40,000
vous traduire votre idée dans un langage un compilateur peut comprendre,

241
00:14:40,000 --> 00:14:44,000
Ainsi, lorsque vous écrivez un programme en C

242
00:14:44,000 --> 00:14:47,000
ce que vous faites est en train d'écrire quelque chose que votre compilateur va comprendre,

243
00:14:47,000 --> 00:14:50,000
puis le compilateur va traduire ce code

244
00:14:50,000 --> 00:14:53,000
en quelque chose que votre ordinateur va comprendre.

245
00:14:53,000 --> 00:14:55,000
>> Et le truc, c'est que votre ordinateur est vraiment très stupide.

246
00:14:55,000 --> 00:14:57,000
Votre ordinateur ne peut comprendre 0 et de 1,

247
00:14:57,000 --> 00:15:01,000
donc en fait dans les premiers ordinateurs des gens habituellement programmés

248
00:15:01,000 --> 00:15:04,000
en utilisant 0 et de 1, mais pas plus, Dieu merci.

249
00:15:04,000 --> 00:15:07,000
Nous n'avons pas besoin de mémoriser les séquences de 0 et de 1

250
00:15:07,000 --> 00:15:10,000
pour une boucle ou une boucle de temps et ainsi de suite.

251
00:15:10,000 --> 00:15:13,000
C'est pourquoi nous avons un compilateur.

252
00:15:13,000 --> 00:15:17,000
Qu'est-ce qu'un compilateur fait est qu'il se traduit essentiellement le code C,

253
00:15:17,000 --> 00:15:21,000
dans notre cas, à une langue que votre ordinateur va comprendre,

254
00:15:21,000 --> 00:15:25,000
qui est le code de l'objet, et le compilateur que nous utilisons

255
00:15:25,000 --> 00:15:30,000
est appelé bruit, donc c'est en fait le symbole de bruit.

256
00:15:30,000 --> 00:15:33,000
Lorsque vous avez votre programme, vous devez faire 2 choses.

257
00:15:33,000 --> 00:15:37,000
Tout d'abord, vous devez compiler votre programme, puis vous allez exécuter votre programme.

258
00:15:37,000 --> 00:15:41,000
Pour compiler votre programme, vous avez beaucoup d'options pour le faire.

259
00:15:41,000 --> 00:15:44,000
La première est de faire program.c clang

260
00:15:44,000 --> 00:15:47,000
dans lequel le programme est le nom de votre programme.

261
00:15:47,000 --> 00:15:51,000
Dans ce cas, vous pouvez voir qu'ils sont juste en disant "Hé, compiler mon programme."

262
00:15:51,000 --> 00:15:56,000
Vous n'êtes pas en disant "Je veux que ce nom pour mon programme» ou quoi que ce soit.

263
00:15:56,000 --> 00:15:58,000
>> La deuxième option est de donner un nom à votre programme.

264
00:15:58,000 --> 00:16:02,000
Vous pouvez dire clang-o, puis le nom que vous souhaitez

265
00:16:02,000 --> 00:16:06,000
le fichier exécutable d'être nommé, puis program.c.

266
00:16:06,000 --> 00:16:11,000
Et vous pouvez aussi faire faire du programme, et de voir comment, dans les 2 premiers cas

267
00:16:11,000 --> 00:16:15,000
J'ai mis. C, et dans le troisième je n'ai que des programmes?

268
00:16:15,000 --> 00:16:18,000
Ouais, vous avez réellement ne faut pas mettre. C lorsque vous utilisez make.

269
00:16:18,000 --> 00:16:22,000
Sinon, le compilateur qui se passe réellement à hurler à vous.

270
00:16:22,000 --> 00:16:24,000
Et aussi, je ne sais pas si vous vous souvenez,

271
00:16:24,000 --> 00:16:29,000
mais beaucoup de fois nous avons également utilisé lcs50-ou-lm.

272
00:16:29,000 --> 00:16:31,000
C'est ce qu'on appelle la liaison.

273
00:16:31,000 --> 00:16:35,000
Il indique simplement au compilateur que vous allez utiliser ces bibliothèques là,

274
00:16:35,000 --> 00:16:39,000
donc si vous voulez utiliser cs50.h vous avez réellement besoin de taper

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

276
00:16:43,000 --> 00:16:45,000
Si vous ne le faites pas, le compilateur ne va pas de savoir

277
00:16:45,000 --> 00:16:50,000
que vous utilisez ces fonctions dans cs50.h.

278
00:16:50,000 --> 00:16:52,000
Et lorsque vous voulez exécuter votre programme, vous avez 2 options.

279
00:16:52,000 --> 00:16:57,000
Si vous avez program.c clang vous n'avez pas donner un nom à votre programme.

280
00:16:57,000 --> 00:17:01,000
Vous devez l'exécuter en utilisant. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out est un nom standard qui clang donne à votre programme si vous ne lui donnez pas un nom.

282
00:17:06,000 --> 00:17:11,000
Sinon, vous allez faire. / Programme si vous avez donné un nom à votre programme,

283
00:17:11,000 --> 00:17:15,000
et aussi si vous avez fait le programme le nom d'un programme va se faire

284
00:17:15,000 --> 00:17:23,000
est déjà en cours à programmer le même nom que le fichier c.

285
00:17:23,000 --> 00:17:26,000
Puis nous avons parlé des types de données et des données.

286
00:17:26,000 --> 00:17:31,000
>> Fondamentalement, les types de données sont la même chose que de petites boîtes qu'ils utilisent

287
00:17:31,000 --> 00:17:35,000
pour stocker des valeurs, si les types de données sont en fait juste comme Pokémons.

288
00:17:35,000 --> 00:17:39,000
Ils viennent dans toutes les tailles et types.

289
00:17:39,000 --> 00:17:43,000
Je ne sais pas si cela a un sens analogue.

290
00:17:43,000 --> 00:17:46,000
La taille des données dépend en fait de l'architecture de la machine.

291
00:17:46,000 --> 00:17:49,000
Toutes les tailles de données que je vais montrer ici

292
00:17:49,000 --> 00:17:53,000
sont en fait pour une machine 32-bit, ce qui est le cas de notre appareil,

293
00:17:53,000 --> 00:17:56,000
mais si vous êtes réellement coder votre Mac ou Windows aussi

294
00:17:56,000 --> 00:17:59,000
vous allez probablement avoir une machine 64-bit,

295
00:17:59,000 --> 00:18:03,000
donc n'oubliez pas que la taille des données que je vais montrer ici

296
00:18:03,000 --> 00:18:06,000
sont fournies à la machine 32-bit.

297
00:18:06,000 --> 00:18:08,000
Le premier que nous avons vu était un int,

298
00:18:08,000 --> 00:18:10,000
ce qui est assez simple.

299
00:18:10,000 --> 00:18:13,000
Vous utilisez int pour stocker un entier.

300
00:18:13,000 --> 00:18:16,000
Nous avons également vu le caractère, le char.

301
00:18:16,000 --> 00:18:20,000
Si vous souhaitez utiliser une lettre ou un petit symbole que vous allez probablement utiliser un char.

302
00:18:20,000 --> 00:18:26,000
Un char a 1 octet, ce qui signifie 8 bits, comme Lexi dit.

303
00:18:26,000 --> 00:18:31,000
Fondamentalement, nous avons une table ASCII qui a 256

304
00:18:31,000 --> 00:18:34,000
les combinaisons possibles de 0 et de 1,

305
00:18:34,000 --> 00:18:37,000
et puis quand vous tapez un char ça va traduire

306
00:18:37,000 --> 00:18:44,000
le personnage que vous entrées un numéro que vous avez dans la table ASCII, comme Lexi dit.

307
00:18:44,000 --> 00:18:48,000
Nous avons également le flotteur, que nous utilisons pour stocker des nombres décimaux.

308
00:18:48,000 --> 00:18:53,000
Si vous voulez choisir 3.14, par exemple, vous allez utiliser un flotteur

309
00:18:53,000 --> 00:18:55,000
ou un double qui est plus précis.

310
00:18:55,000 --> 00:18:57,000
Un flotteur dispose de 4 octets.

311
00:18:57,000 --> 00:19:01,000
Un double dispose de 8 octets, de sorte que la seule différence est la précision.

312
00:19:01,000 --> 00:19:04,000
Nous avons aussi une longue qui est utilisé pour les nombres entiers,

313
00:19:04,000 --> 00:19:09,000
et vous pouvez voir pour une machine 32-bit d'un int et un long ont la même taille,

314
00:19:09,000 --> 00:19:13,000
de sorte qu'il n'a pas vraiment de sens d'utiliser une longue dans une machine 32-bit.

315
00:19:13,000 --> 00:19:17,000
>> Mais si vous utilisez un ordinateur Mac et 64-bit, en fait un long a une taille 8,

316
00:19:17,000 --> 00:19:19,000
donc cela dépend vraiment de l'architecture.

317
00:19:19,000 --> 00:19:22,000
Pour la machine 32-bit il n'a pas de sens d'utiliser une longue vraiment.

318
00:19:22,000 --> 00:19:25,000
Et puis un long terme, d'autre part, dispose de 8 octets,

319
00:19:25,000 --> 00:19:30,000
il est donc très utile si vous voulez avoir un nombre entier plus.

320
00:19:30,000 --> 00:19:34,000
Et enfin, nous avons chaîne, qui est en fait un char *,

321
00:19:34,000 --> 00:19:37,000
qui est un pointeur sur un char.

322
00:19:37,000 --> 00:19:40,000
Il est très facile de penser que la taille de la chaîne va être comme

323
00:19:40,000 --> 00:19:42,000
le nombre de caractères que vous avez là,

324
00:19:42,000 --> 00:19:45,000
mais en fait le même char *

325
00:19:45,000 --> 00:19:49,000
a la taille d'un pointeur sur un caractère, qui est de 4 octets.

326
00:19:49,000 --> 00:19:52,000
La taille d'un char * est de 4 octets.

327
00:19:52,000 --> 00:19:56,000
Ce n'est pas grave si vous avez un petit mot ou une lettre ou quoi que ce soit.

328
00:19:56,000 --> 00:19:58,000
Il va y avoir 4 octets.

329
00:19:58,000 --> 00:20:01,000
Nous avons aussi appris un peu plus sur la coulée,

330
00:20:01,000 --> 00:20:04,000
de sorte que vous pouvez le voir, si vous avez, par exemple, un programme qui dit

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

332
00:20:08,000 --> 00:20:12,000
Avez-vous les gars savent ce que ça va imprimer sur l'écran?

333
00:20:12,000 --> 00:20:14,000
>> Quelqu'un? >> [Etudiants] 2.

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

335
00:20:16,000 --> 00:20:20,000
Quand vous faites 3/2 ça va obtenir 1,5,

336
00:20:20,000 --> 00:20:24,000
mais puisque nous utilisons un entier, il va ignorer la partie décimale,

337
00:20:24,000 --> 00:20:26,000
et vous allez avoir 1.

338
00:20:26,000 --> 00:20:29,000
Si vous ne voulez pas que cela se produise ce que vous pouvez faire, par exemple,

339
00:20:29,000 --> 00:20:33,000
est de déclarer un flotteur y = x.

340
00:20:33,000 --> 00:20:40,000
Alors x qui étaient de 3 va maintenant être 3.000 en y.

341
00:20:40,000 --> 00:20:44,000
Et puis, vous pouvez imprimer le rapport y / 2.

342
00:20:44,000 --> 00:20:50,000
En fait, je devrais avoir un 2. là-bas.

343
00:20:50,000 --> 00:20:55,000
Il va faire 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
et vous allez obtenir 1,5.

345
00:20:58,000 --> 00:21:06,000
Et nous avons cette f .2 juste pour demander 2 unités décimales dans la partie décimale.

346
00:21:06,000 --> 00:21:12,000
Si vous avez .3 f il va falloir effectivement 1,500.

347
00:21:12,000 --> 00:21:16,000
Si c'est 2 que ça va être de 1,50.

348
00:21:16,000 --> 00:21:18,000
Nous avons aussi le cas ici.

349
00:21:18,000 --> 00:21:22,000
Si vous le faites float x = 3,14 et x vous printf

350
00:21:22,000 --> 00:21:24,000
vous allez obtenir 3,14.

351
00:21:24,000 --> 00:21:29,000
Et si vous faites l'int x = de x,

352
00:21:29,000 --> 00:21:34,000
ce qui signifie traiter x comme un int et que vous imprimez x maintenant

353
00:21:34,000 --> 00:21:36,000
vous allez avoir 3,00.

354
00:21:36,000 --> 00:21:38,000
Est-ce logique?

355
00:21:38,000 --> 00:21:41,000
Parce que vous êtes le premier traitement de x comme un nombre entier, de sorte que vous ne tenez pas compte de la partie décimale,

356
00:21:41,000 --> 00:21:45,000
et puis vous imprimez x.

357
00:21:45,000 --> 00:21:47,000
Et enfin, vous pouvez aussi le faire,

358
00:21:47,000 --> 00:21:52,000
int x = 65, puis vous déclarez un char c = x,

359
00:21:52,000 --> 00:21:56,000
et puis si vous imprimez le c vous allez effectivement d'obtenir

360
00:21:56,000 --> 00:21:59,000
A, donc en gros ce que vous faites ici

361
00:21:59,000 --> 00:22:02,000
se traduit par le nombre entier dans le caractère,

362
00:22:02,000 --> 00:22:05,000
tout comme la table ASCII fait.

363
00:22:05,000 --> 00:22:08,000
Nous avons aussi parlé des opérateurs mathématiques.

364
00:22:08,000 --> 00:22:14,000
La plupart d'entre eux sont assez simples, donc +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
et aussi nous avons parlé de mod, qui est le reste d'une division de 2 nombres.

366
00:22:20,000 --> 00:22:23,000
Si vous avez 10% 3, par exemple,

367
00:22:23,000 --> 00:22:27,000
cela signifie diviser 10 par 3, et quel est le reste?

368
00:22:27,000 --> 00:22:30,000
Il va y avoir 1, donc c'est vraiment très utile pour un grand nombre de programmes.

369
00:22:30,000 --> 00:22:38,000
Pour Vigenère et César, je suis sûr que tous les gars utilisé mod.

370
00:22:38,000 --> 00:22:43,000
À propos des opérateurs mathématiques, soyez très prudent lors de l'association * et /.

371
00:22:43,000 --> 00:22:48,000
>> Par exemple, si vous faites (3/2) * 2 qu'allez-vous obtenir?

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

373
00:22:50,000 --> 00:22:54,000
Ouais, 2, parce 2.3 va être de 1,5,

374
00:22:54,000 --> 00:22:57,000
mais puisque vous faites des opérations entre 2 entiers

375
00:22:57,000 --> 00:22:59,000
vous êtes réellement aller juste de considérer 1,

376
00:22:59,000 --> 00:23:03,000
puis 1 * 2 va être de 2, donc être très, très prudent

377
00:23:03,000 --> 00:23:07,000
quand faire des calculs avec des nombres entiers, car

378
00:23:07,000 --> 00:23:12,000
vous pourriez obtenir ce 2 = 3, dans ce cas.

379
00:23:12,000 --> 00:23:14,000
Et aussi faire très attention à la priorité.

380
00:23:14,000 --> 00:23:21,000
Vous devriez normalement utiliser des parenthèses pour être sûr que vous savez ce que vous faites.

381
00:23:21,000 --> 00:23:27,000
Quelques raccourcis utiles, bien sûr, on est i + + ou i + = 1

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

383
00:23:30,000 --> 00:23:34,000
C'est la même chose que faire i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Vous pouvez également faire i - i ou - = 1,

385
00:23:39,000 --> 00:23:42,000
qui est la même chose que i = i-1,

386
00:23:42,000 --> 00:23:46,000
quelque chose de vous les gars utilisent beaucoup dans les boucles for, au moins.

387
00:23:46,000 --> 00:23:52,000
En outre, pour *, si vous utilisez * = et si vous le faites, par exemple,

388
00:23:52,000 --> 00:23:57,000
i * = 2 est la même chose que de dire i = i * 2,

389
00:23:57,000 --> 00:23:59,000
et la même chose pour la division.

390
00:23:59,000 --> 00:24:08,000
Si vous le faites i / = 2, c'est la même chose que i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Maintenant, sur les fonctions.

392
00:24:10,000 --> 00:24:13,000
Vous les gars ont appris que les fonctions sont une très bonne stratégie pour sauver le code

393
00:24:13,000 --> 00:24:16,000
tandis que vous programmez, donc si vous voulez effectuer la même tâche

394
00:24:16,000 --> 00:24:20,000
dans le code encore et encore, sans doute vous souhaitez utiliser une fonction

395
00:24:20,000 --> 00:24:25,000
juste pour que vous ne devez pas copier et coller le code maintes et maintes fois.

396
00:24:25,000 --> 00:24:28,000
En fait, la principale est une fonction, et quand je vous montre le format d'une fonction

397
00:24:28,000 --> 00:24:32,000
vous allez voir que c'est assez évident.

398
00:24:32,000 --> 00:24:35,000
Nous utilisons également les fonctions de certaines bibliothèques,

399
00:24:35,000 --> 00:24:39,000
par exemple, printf, GETIN, qui provient de la bibliothèque CS50,

400
00:24:39,000 --> 00:24:43,000
et d'autres fonctions telles que toupper.

401
00:24:43,000 --> 00:24:46,000
Toutes ces fonctions sont effectivement mises en œuvre dans d'autres bibliothèques,

402
00:24:46,000 --> 00:24:49,000
et quand vous mettez les fichiers d'attache au début de votre programme

403
00:24:49,000 --> 00:24:53,000
vous dites peut vous s'il vous plaît me donner le code pour les fonctions

404
00:24:53,000 --> 00:24:57,000
donc je n'ai pas à les mettre en œuvre par moi-même?

405
00:24:57,000 --> 00:25:00,000
Et vous pouvez également écrire vos propres fonctions, alors quand vous lancez la programmation

406
00:25:00,000 --> 00:25:04,000
vous vous rendez compte que les bibliothèques ne disposent pas de toutes les fonctions dont vous avez besoin.

407
00:25:04,000 --> 00:25:10,000
Pour le pset dernier, par exemple, nous avons écrit dessiner, bousculade, et rechercher,

408
00:25:10,000 --> 00:25:13,000
et c'est très, très important d'être capable d'écrire des fonctions

409
00:25:13,000 --> 00:25:17,000
parce qu'ils sont utiles, et nous les utilisons tout le temps dans la programmation,

410
00:25:17,000 --> 00:25:19,000
et cela fait gagner beaucoup de code.

411
00:25:19,000 --> 00:25:21,000
Le format d'une fonction est celle-ci.

412
00:25:21,000 --> 00:25:24,000
Nous avons type de retour au début. Quel est le type de retour?

413
00:25:24,000 --> 00:25:27,000
C'est juste au moment où votre fonction va revenir.

414
00:25:27,000 --> 00:25:29,000
Si vous avez une fonction, par exemple, factorielle,

415
00:25:29,000 --> 00:25:31,000
qui va calculer une factorielle d'un nombre entier,

416
00:25:31,000 --> 00:25:34,000
sans doute il va retourner un entier aussi.

417
00:25:34,000 --> 00:25:37,000
Ensuite, le type de retour va être int.

418
00:25:37,000 --> 00:25:41,000
Printf est en fait un type de retour void

419
00:25:41,000 --> 00:25:43,000
parce que vous n'êtes pas retourner quoi que ce soit.

420
00:25:43,000 --> 00:25:45,000
Vous êtes juste l'impression des choses à l'écran

421
00:25:45,000 --> 00:25:48,000
et quitter la fonction de suite.

422
00:25:48,000 --> 00:25:51,000
Ensuite, vous avez le nom de la fonction que vous pouvez choisir.

423
00:25:51,000 --> 00:25:55,000
Vous devriez être un peu raisonnable, comme ne choisissez pas un nom comme xyz

424
00:25:55,000 --> 00:25:58,000
ou comme x2F.

425
00:25:58,000 --> 00:26:02,000
Essayez de faire un nom qui a du sens.

426
00:26:02,000 --> 00:26:04,000
>> Par exemple, si elle est factoriel, factorielle dire.

427
00:26:04,000 --> 00:26:08,000
Si c'est une fonction qui va dessiner quelque chose, appelez-le dessiner.

428
00:26:08,000 --> 00:26:11,000
Et puis nous avons les paramètres, qui sont également appelés arguments,

429
00:26:11,000 --> 00:26:14,000
qui sont comme les ressources que votre fonction a besoin

430
00:26:14,000 --> 00:26:17,000
à partir de votre code d'accomplir sa tâche.

431
00:26:17,000 --> 00:26:20,000
Si vous voulez calculer la factorielle d'un nombre

432
00:26:20,000 --> 00:26:23,000
sans doute vous avez besoin d'avoir un certain nombre de calculer une factorielle.

433
00:26:23,000 --> 00:26:27,000
L'un des arguments que vous allez avoir est le nombre lui-même.

434
00:26:27,000 --> 00:26:31,000
Et puis il va faire quelque chose et retourner la valeur à la fin

435
00:26:31,000 --> 00:26:35,000
sauf s'il s'agit d'une fonction nulle.

436
00:26:35,000 --> 00:26:37,000
Voyons un exemple.

437
00:26:37,000 --> 00:26:40,000
Si je veux écrire une fonction qui additionne tous les chiffres dans un tableau d'entiers,

438
00:26:40,000 --> 00:26:43,000
tout d'abord, le type de retour va être int

439
00:26:43,000 --> 00:26:46,000
parce que j'ai un tableau d'entiers.

440
00:26:46,000 --> 00:26:51,000
Et puis je vais avoir le nom de la fonction comme sumArray,

441
00:26:51,000 --> 00:26:54,000
et puis il va prendre le tableau lui-même, à nums int,

442
00:26:54,000 --> 00:26:58,000
puis la longueur du tableau et je sais combien de numéros que j'ai à résumé.

443
00:26:58,000 --> 00:27:02,000
Ensuite, je dois initialiser une somme variable appelée, par exemple, à 0,

444
00:27:02,000 --> 00:27:08,000
et chaque fois que je vois un élément dans le tableau je devrais l'ajouter à la somme, alors j'ai fait une boucle for.

445
00:27:08,000 --> 00:27:15,000
Tout comme Lexi dit, vous faites int i = 0, i <longueur et i + +.

446
00:27:15,000 --> 00:27:20,000
Et pour chaque élément dans le tableau que j'ai fait la somme + = nums [i],

447
00:27:20,000 --> 00:27:24,000
et puis je suis retourné la somme, il est donc très simple, et il permet d'économiser beaucoup de code

448
00:27:24,000 --> 00:27:28,000
si vous utilisez cette fonction, un grand nombre de fois.

449
00:27:28,000 --> 00:27:32,000
Puis nous avons pris un coup d'oeil à conditions.

450
00:27:32,000 --> 00:27:38,000
Nous avons if, else, et d'autre si.

451
00:27:38,000 --> 00:27:42,000
Voyons quelle est la différence entre les deux.

452
00:27:42,000 --> 00:27:45,000
Jetez un oeil à ces 2 codes. Quelle est la différence entre eux?

453
00:27:45,000 --> 00:27:49,000
La première a-essentiellement les codes veux que vous disiez

454
00:27:49,000 --> 00:27:51,000
si un nombre est +, -, ou 0.

455
00:27:51,000 --> 00:27:55,000
Le premier dit que si il est> 0 alors c'est positif.

456
00:27:55,000 --> 00:28:00,000
Si c'est = à 0 alors il est 0, et si elle est <0 alors il est négatif.

457
00:28:00,000 --> 00:28:04,000
>> Et l'autre fait si, d'autre si, d'autre.

458
00:28:04,000 --> 00:28:07,000
La différence entre les deux est que celui-ci va effectivement

459
00:28:07,000 --> 00:28:13,000
vérifier si> 0, <0 ou = 0 trois fois,

460
00:28:13,000 --> 00:28:17,000
donc si vous avez le numéro 2, par exemple, il va venir ici et dire

461
00:28:17,000 --> 00:28:21,000
if (x> 0), et il va dire oui, alors je imprimer positive.

462
00:28:21,000 --> 00:28:25,000
Mais même si je sais que c'est> 0 et il ne va pas être égal à 0 ou <0

463
00:28:25,000 --> 00:28:29,000
Je vais toujours à faire est de 0, est-il <0,

464
00:28:29,000 --> 00:28:33,000
donc je vais en fait à l'intérieur des ifs que je n'ai pas eu à

465
00:28:33,000 --> 00:28:38,000
parce que je sais déjà que ça ne va pas pour satisfaire une de ces conditions.

466
00:28:38,000 --> 00:28:41,000
Je peux utiliser le if, else if, else.

467
00:28:41,000 --> 00:28:45,000
Il dit en substance si x = 0 je imprimer le positif.

468
00:28:45,000 --> 00:28:48,000
Si ce n'est pas le cas, je vais aussi tester cela.

469
00:28:48,000 --> 00:28:51,000
Si c'est 2 pas, je vais le faire.

470
00:28:51,000 --> 00:28:54,000
En gros, si je devais x = 2 vous dirais

471
00:28:54,000 --> 00:28:57,000
if (x> 0), oui, c'est imprimer cette.

472
00:28:57,000 --> 00:29:00,000
Maintenant que je sais que c'est> 0 et qu'il a satisfait à la première, si

473
00:29:00,000 --> 00:29:02,000
Je ne vais même pas d'exécuter ce code.

474
00:29:02,000 --> 00:29:09,000
Le code s'exécute plus rapidement, en fait, 3 fois plus vite si vous l'utilisez.

475
00:29:09,000 --> 00:29:11,000
Nous avons aussi appris and et or.

476
00:29:11,000 --> 00:29:15,000
Je ne vais pas passer par cette raison Lexi déjà parlé.

477
00:29:15,000 --> 00:29:17,000
C'est juste les opérateurs && et | opérateur |.

478
00:29:17,000 --> 00:29:21,000
>> La seule chose que je vais dire, c'est faire attention lorsque vous avez 3 conditions.

479
00:29:21,000 --> 00:29:24,000
Utilisez les parenthèses parce que c'est très déroutant quand vous avez une condition

480
00:29:24,000 --> 00:29:27,000
et un autre ou un autre.

481
00:29:27,000 --> 00:29:30,000
Utilisez les parenthèses juste pour être sûr que vos conditions de sens

482
00:29:30,000 --> 00:29:34,000
parce que dans ce cas, par exemple, vous pouvez imaginer que

483
00:29:34,000 --> 00:29:38,000
ce pourrait être la première condition et l'une ou l'autre

484
00:29:38,000 --> 00:29:41,000
ou les 2 conditions réunies dans un et

485
00:29:41,000 --> 00:29:45,000
ou le troisième, si juste être prudent.

486
00:29:45,000 --> 00:29:48,000
Et enfin, nous avons parlé des commutateurs.

487
00:29:48,000 --> 00:29:53,000
Un commutateur est très utile lorsque vous avez une variable.

488
00:29:53,000 --> 00:29:55,000
Disons que vous avez une variable comme n

489
00:29:55,000 --> 00:29:59,000
qui peut être 0, 1, ou 2, et pour chacun de ces cas,

490
00:29:59,000 --> 00:30:01,000
vous allez effectuer une tâche.

491
00:30:01,000 --> 00:30:04,000
Vous pouvez dire passer la variable, et il indique que

492
00:30:04,000 --> 00:30:08,000
la valeur est alors comme valeur1 je vais faire,

493
00:30:08,000 --> 00:30:12,000
et puis je me casse, ce qui signifie que je ne vais pas chercher à tout les autres cas

494
00:30:12,000 --> 00:30:15,000
car nous avons déjà convaincu que le cas

495
00:30:15,000 --> 00:30:20,000
puis valeur2 et ainsi de suite, et je peux aussi avoir un interrupteur par défaut.

496
00:30:20,000 --> 00:30:24,000
Cela signifie que si elle ne répond à aucun des cas que j'ai eu

497
00:30:24,000 --> 00:30:29,000
que je vais faire quelque chose d'autre, mais c'est facultatif.

498
00:30:29,000 --> 00:30:36,000
C'est tout pour moi. Maintenant, nous allons Tommy.

499
00:30:36,000 --> 00:30:41,000
Bon, ça va être la semaine 3 à la rigueur.

500
00:30:41,000 --> 00:30:45,000
Ce sont quelques-uns des sujets que nous aborderons, crypto, de la portée, des tableaux, etc.

501
00:30:45,000 --> 00:30:49,000
Juste un petit mot sur la cryptographie. Nous n'allons pas à marteler cette maison.

502
00:30:49,000 --> 00:30:52,000
>> Nous l'avons fait dans le pset 2, mais pour le quiz assurez-vous que vous connaissez la différence

503
00:30:52,000 --> 00:30:54,000
entre le chiffre de César et le chiffrement de Vigenère,

504
00:30:54,000 --> 00:30:57,000
comment tant de ceux qui travaillent chiffres et ce que c'est que de crypter

505
00:30:57,000 --> 00:30:59,000
et le texte déchiffrer à l'aide de ces 2 chiffres.

506
00:30:59,000 --> 00:31:03,000
Rappelez-vous, le chiffrement de César tourne simplement chaque caractère du même montant,

507
00:31:03,000 --> 00:31:06,000
en vous assurant de mod par le nombre de lettres dans l'alphabet.

508
00:31:06,000 --> 00:31:09,000
Et le chiffrement de Vigenère, d'autre part, chaque caractère tourne

509
00:31:09,000 --> 00:31:12,000
d'un montant différent, donc plutôt que de dire

510
00:31:12,000 --> 00:31:15,000
tous les caractères rotation par 3 Vigenère tourne chaque caractère

511
00:31:15,000 --> 00:31:17,000
d'une quantité différente en fonction de certains mots clés

512
00:31:17,000 --> 00:31:20,000
où chaque lettre dans le mot-clé représente une certaine quantité différente

513
00:31:20,000 --> 00:31:26,000
pour faire pivoter le texte en clair par.

514
00:31:26,000 --> 00:31:28,000
Parlons d'abord à propos de la portée des variables.

515
00:31:28,000 --> 00:31:30,000
Il ya 2 types de variables.

516
00:31:30,000 --> 00:31:33,000
Nous avons des variables locales, et celles-ci vont être définis

517
00:31:33,000 --> 00:31:36,000
en dehors de main ou à l'extérieur de toute fonction ou de bloc,

518
00:31:36,000 --> 00:31:39,000
et ceux-ci seront accessibles n'importe où dans votre programme.

519
00:31:39,000 --> 00:31:41,000
Si vous avez une fonction et cette fonction est une boucle while

520
00:31:41,000 --> 00:31:44,000
la grande variable globale est accessible partout.

521
00:31:44,000 --> 00:31:48,000
Une variable locale, d'autre part, est portée à l'endroit où elle est définie.

522
00:31:48,000 --> 00:31:53,000
>> Si vous avez une fonction ici, par exemple, nous avons cette fonction g,

523
00:31:53,000 --> 00:31:56,000
et à l'intérieur de g y est une variable appelée ici y,

524
00:31:56,000 --> 00:31:58,000
ce qui signifie qu'il s'agit d'une variable locale.

525
00:31:58,000 --> 00:32:00,000
Même si cette variable est appelée y

526
00:32:00,000 --> 00:32:03,000
et cette variable est appelée Y Ces 2 fonctions

527
00:32:03,000 --> 00:32:06,000
n'ont aucune idée de ce que chacun des autres variables locales sont.

528
00:32:06,000 --> 00:32:10,000
D'autre part, ici nous disons int x = 5,

529
00:32:10,000 --> 00:32:12,000
et cela est en dehors de la portée de n'importe quelle fonction.

530
00:32:12,000 --> 00:32:16,000
Il est hors de la portée de main, c'est donc une variable globale.

531
00:32:16,000 --> 00:32:20,000
Cela signifie que l'intérieur de ces 2 fonctions quand je dis x - x ou + +

532
00:32:20,000 --> 00:32:26,000
Je accéder à la même x où y présente et ce y sont des variables différentes.

533
00:32:26,000 --> 00:32:30,000
C'est la différence entre une variable globale et une variable locale.

534
00:32:30,000 --> 00:32:33,000
En ce qui concerne la conception, parfois c'est probablement une meilleure idée

535
00:32:33,000 --> 00:32:37,000
de garder les variables locales chaque fois que vous le pouvez

536
00:32:37,000 --> 00:32:39,000
car avoir un tas de variables globales peut être vraiment déroutant.

537
00:32:39,000 --> 00:32:42,000
Si vous avez un tas de fonctions tout modifier la même chose

538
00:32:42,000 --> 00:32:45,000
vous pourriez oublier que si cette fonction modifie accidentellement ce monde,

539
00:32:45,000 --> 00:32:47,000
et cette autre fonction ne le savent pas,

540
00:32:47,000 --> 00:32:50,000
et il ne devenir assez déroutant, car vous aurez plus de code.

541
00:32:50,000 --> 00:32:53,000
Garder les variables locales chaque fois que vous le pouvez

542
00:32:53,000 --> 00:32:56,000
est la conception juste bon.

543
00:32:56,000 --> 00:33:00,000
Tableaux, rappelez-vous, sont tout simplement des listes d'éléments du même type.

544
00:33:00,000 --> 00:33:04,000
A l'intérieur de CI ne peut pas avoir une liste comme 1, 2.0, bonjour.

545
00:33:04,000 --> 00:33:06,000
Nous ne pouvons pas faire cela.

546
00:33:06,000 --> 00:33:11,000
>> Lorsque nous déclarons un tableau en C, tous les éléments doivent être du même type.

547
00:33:11,000 --> 00:33:14,000
Ici, j'ai un tableau de 3 entiers.

548
00:33:14,000 --> 00:33:18,000
Ici, j'ai la longueur du tableau, mais si je ne fais que le déclarant dans cette syntaxe

549
00:33:18,000 --> 00:33:21,000
où je préciser ce que tous les éléments sont je n'ai pas besoin de cette technique 3.

550
00:33:21,000 --> 00:33:25,000
Le compilateur est assez intelligent pour comprendre l'ampleur de la gamme devrait être.

551
00:33:25,000 --> 00:33:28,000
Maintenant, quand je veux obtenir ou définir la valeur d'un tableau

552
00:33:28,000 --> 00:33:30,000
c'est la syntaxe pour faire cela.

553
00:33:30,000 --> 00:33:33,000
Ce sera effectivement modifier le deuxième élément du tableau, car, rappelez-vous,

554
00:33:33,000 --> 00:33:36,000
numérotation commence à 0 et non à 1.

555
00:33:36,000 --> 00:33:42,000
Si je veux lire cette valeur que je peux dire quelque chose comme int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Ou si je veux mettre cette valeur, comme je le fais ici,

557
00:33:44,000 --> 00:33:47,000
Je peux dire array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Ce temps d'accéder aux éléments par leur index

559
00:33:50,000 --> 00:33:52,000
ou sa position ou où ils se trouvent dans le tableau,

560
00:33:52,000 --> 00:33:57,000
et que l'inscription commence à 0.

561
00:33:57,000 --> 00:34:00,000
Nous pouvons également avoir des tableaux de tableaux,

562
00:34:00,000 --> 00:34:03,000
et c'est ce qu'on appelle un tableau multi-dimensionnel.

563
00:34:03,000 --> 00:34:05,000
Lorsque nous avons un tableau multi-dimensionnel

564
00:34:05,000 --> 00:34:07,000
cela signifie que nous pouvons avoir quelque chose comme des rangées et des colonnes,

565
00:34:07,000 --> 00:34:11,000
et ce n'est qu'un moyen de visualiser telle ou penser.

566
00:34:11,000 --> 00:34:14,000
Quand j'ai un tableau multi-dimensionnel qui signifie que je vais commencer à avoir besoin

567
00:34:14,000 --> 00:34:17,000
plus de 1 index parce que si j'ai une grille

568
00:34:17,000 --> 00:34:19,000
juste dire ce que vous êtes en ligne ne nous donne pas un numéro.

569
00:34:19,000 --> 00:34:22,000
C'est vraiment juste nous donner une liste de numéros.

570
00:34:22,000 --> 00:34:25,000
Disons que j'ai ce tableau ici.

571
00:34:25,000 --> 00:34:30,000
J'ai un tableau appelé grille, et je dis que c'est 2 lignes et 3 colonnes,

572
00:34:30,000 --> 00:34:32,000
et donc c'est une façon de le visualiser.

573
00:34:32,000 --> 00:34:37,000
Quand je dis que je veux obtenir l'élément à [1] [2]

574
00:34:37,000 --> 00:34:41,000
cela veut dire que parce que ce sont des rangées d'abord, puis des colonnes

575
00:34:41,000 --> 00:34:44,000
Je vais passer à la ligne 1 depuis que j'ai dit 1.

576
00:34:44,000 --> 00:34:49,000
>> Ensuite, je vais venir ici à la colonne 2, et je vais obtenir la valeur 6.

577
00:34:49,000 --> 00:34:51,000
Donner un sens?

578
00:34:51,000 --> 00:34:55,000
Tableaux multi-dimensionnels, rappelez-vous, sont techniquement juste un tableau de tableaux.

579
00:34:55,000 --> 00:34:57,000
Nous pouvons avoir des tableaux de tableaux de tableaux.

580
00:34:57,000 --> 00:35:00,000
Nous pouvons continuer, mais vraiment une façon de penser

581
00:35:00,000 --> 00:35:03,000
comment cela est présenté et ce qui se passe est de le visualiser

582
00:35:03,000 --> 00:35:09,000
dans une grille comme ça.

583
00:35:09,000 --> 00:35:12,000
Quand nous passer des tableaux à des fonctions, ils vont se comporter

584
00:35:12,000 --> 00:35:16,000
un peu différemment que lorsque nous passer des variables à des fonctions régulières

585
00:35:16,000 --> 00:35:18,000
comme le passage d'un int ou un float.

586
00:35:18,000 --> 00:35:21,000
Quand nous passons dans un type int ou char ou l'autre de ces autres données

587
00:35:21,000 --> 00:35:24,000
nous avons juste pris un coup d'oeil si la fonction modifie

588
00:35:24,000 --> 00:35:28,000
la valeur de cette variable que le changement ne va pas se propager jusqu'à

589
00:35:28,000 --> 00:35:32,000
à la fonction appelante.

590
00:35:32,000 --> 00:35:35,000
Avec un tableau, d'un autre côté, cela se produira.

591
00:35:35,000 --> 00:35:39,000
Si je passe dans un tableau à une fonction et que cette fonction modifie certains éléments,

592
00:35:39,000 --> 00:35:43,000
quand je reviens à la fonction qui l'a appelé

593
00:35:43,000 --> 00:35:47,000
mon tableau est désormais va être différent, et le vocabulaire pour que

594
00:35:47,000 --> 00:35:50,000
est tableaux sont passés par référence, comme nous le verrons plus tard.

595
00:35:50,000 --> 00:35:53,000
Ceci est lié à la façon dont le travail des pointeurs, où ces types de données de base,

596
00:35:53,000 --> 00:35:55,000
d'autre part, sont passés par valeur.

597
00:35:55,000 --> 00:35:59,000
>> Nous pouvons penser que de faire une copie d'une variable, puis en passant à la copie.

598
00:35:59,000 --> 00:36:01,000
Il n'a pas d'importance ce que nous faisons avec cette variable.

599
00:36:01,000 --> 00:36:06,000
La fonction d'appel ne sera pas conscient qu'il a été modifié.

600
00:36:06,000 --> 00:36:10,000
Les tableaux sont un peu différent à cet égard.

601
00:36:10,000 --> 00:36:13,000
Par exemple, comme nous venons de le voir, le principal est simplement une fonction

602
00:36:13,000 --> 00:36:15,000
qui peut prendre de 2 arguments.

603
00:36:15,000 --> 00:36:20,000
Le premier argument de la fonction principale est argc, ou le nombre d'arguments,

604
00:36:20,000 --> 00:36:23,000
et le second argument est appelé argv,

605
00:36:23,000 --> 00:36:27,000
et ce sont les valeurs réelles de ces arguments.

606
00:36:27,000 --> 00:36:30,000
Disons que j'ai un programme appelé this.c,

607
00:36:30,000 --> 00:36:34,000
et je dis faire cela, et je vais exécuter ce à la ligne de commande.

608
00:36:34,000 --> 00:36:38,000
Maintenant, pour passer des arguments à mon programme appelé cela,

609
00:36:38,000 --> 00:36:42,000
Je pourrais dire quelque chose comme. / Cs c'est 50.

610
00:36:42,000 --> 00:36:45,000
C'est ce que nous imaginons David à faire chaque jour sur le terminal.

611
00:36:45,000 --> 00:36:48,000
Mais aujourd'hui, la principale fonction à l'intérieur de ce programme

612
00:36:48,000 --> 00:36:52,000
a ces valeurs, alors argc est de 4.

613
00:36:52,000 --> 00:36:56,000
Il serait peut-être un peu déroutant parce que vraiment nous sommes seulement de passage dans cs est 50.

614
00:36:56,000 --> 00:36:58,000
C'est seulement 3.

615
00:36:58,000 --> 00:37:02,000
Mais rappelez-vous que le premier élément de argv ou le premier argument

616
00:37:02,000 --> 00:37:05,000
est le nom de la fonction elle-même.

617
00:37:05,000 --> 00:37:07,190
Cela signifie donc que nous avons 4 choses ici,

618
00:37:07,190 --> 00:37:10,530
et le premier élément sera. / ce.

619
00:37:10,530 --> 00:37:12,970
Et ce sera représenté par une chaîne.

620
00:37:12,970 --> 00:37:18,590
Ensuite, les éléments restants sont ce que nous avons tapé dans la suite du nom du programme.

621
00:37:18,590 --> 00:37:22,720
Ainsi, tout comme en passant, que nous avons probablement vu dans pset 2,

622
00:37:22,720 --> 00:37:28,780
rappelez-vous que la chaîne 50 est ≠ du 50 entier.

623
00:37:28,780 --> 00:37:32,520
Donc, nous ne pouvons pas dire quelque chose comme, "int x = argv 3. '

624
00:37:32,520 --> 00:37:36,470
>> C'est tout simplement pas de sens, car il s'agit d'une chaîne de caractères, ce qui est un entier.

625
00:37:36,470 --> 00:37:38,510
Donc, si vous voulez convertir entre les 2, rappelez-vous, nous allons

626
00:37:38,510 --> 00:37:40,810
avoir cette fonction magique appelé atoi.

627
00:37:40,810 --> 00:37:46,270
Qui prend une chaîne et retourne l'entier représenté à l'intérieur de cette chaîne.

628
00:37:46,270 --> 00:37:48,360
Donc, c'est une erreur facile à faire sur le questionnaire,

629
00:37:48,360 --> 00:37:51,590
train de penser que ce sera automatiquement le type correct.

630
00:37:51,590 --> 00:37:53,860
Mais il suffit de savoir que ceux-ci seront toujours chaînes

631
00:37:53,860 --> 00:38:00,920
même si la chaîne contient uniquement un nombre entier ou un caractère ou un flotteur.

632
00:38:00,920 --> 00:38:03,380
Alors maintenant, nous allons parler de temps de fonctionnement.

633
00:38:03,380 --> 00:38:06,700
Lorsque nous aurons toutes ces algorithmes qui font toutes ces choses folles,

634
00:38:06,700 --> 00:38:11,580
il devient vraiment utile de se poser la question: «Combien de temps prennent-ils?"

635
00:38:11,580 --> 00:38:15,500
Nous représentons que par ce qu'on appelle la notation asymptotique.

636
00:38:15,500 --> 00:38:18,430
Donc, cela signifie que - eh bien, disons que nous donnons notre algorithme

637
00:38:18,430 --> 00:38:20,840
une entrée vraiment, vraiment, vraiment grand.

638
00:38:20,840 --> 00:38:23,840
Nous voulons poser la question: «Combien de temps ça va prendre?

639
00:38:23,840 --> 00:38:26,370
Combien d'étapes faut-il notre algorithme à exécuter

640
00:38:26,370 --> 00:38:29,980
en fonction de la taille de l'entrée? "

641
00:38:29,980 --> 00:38:33,080
Donc, la première façon, nous pouvons décrire moment de l'exécution est avec grand O.

642
00:38:33,080 --> 00:38:35,380
Et c'est notre temps marche le pire des cas.

643
00:38:35,380 --> 00:38:38,590
Donc, si on veut trier un tableau, et nous donnons notre algorithme un tableau

644
00:38:38,590 --> 00:38:41,000
c'est dans l'ordre décroissant alors qu'il devrait être dans l'ordre croissant,

645
00:38:41,000 --> 00:38:43,130
qui va être le pire des cas.

646
00:38:43,130 --> 00:38:49,800
C'est notre limite supérieure de la durée maximale du temps de notre algorithme va prendre.

647
00:38:49,800 --> 00:38:54,740
D'autre part, cette Ω va décrire le meilleur des cas le temps d'exécution.

648
00:38:54,740 --> 00:38:58,210
Donc, si nous donnons un tableau déjà triés à un algorithme de tri,

649
00:38:58,210 --> 00:39:00,940
combien de temps faut-il pour faire le tri?

650
00:39:00,940 --> 00:39:06,610
Et cela, alors, décrit une borne inférieure sur le temps d'exécution.

651
00:39:06,610 --> 00:39:10,980
Alors voici juste quelques mots qui décrivent moments les plus fréquents en cours d'exécution.

652
00:39:10,980 --> 00:39:13,120
Ce sont dans l'ordre croissant.

653
00:39:13,120 --> 00:39:16,060
Le temps le plus rapide en cours d'exécution que nous avons est appelé constante.

654
00:39:16,060 --> 00:39:19,800
>> Cela signifie que peu importe le nombre d'éléments que nous donnons notre algorithme,

655
00:39:19,800 --> 00:39:22,280
peu importe la taille de notre tableau est, le tri

656
00:39:22,280 --> 00:39:26,510
ou faire tout ce que nous faisons pour l'ensemble prendra toujours le même laps de temps.

657
00:39:26,510 --> 00:39:30,270
Donc, nous pouvons représenter que juste avec un 1, qui est une constante.

658
00:39:30,270 --> 00:39:32,410
Nous avons également examiné lors de l'exécution logarithmique.

659
00:39:32,410 --> 00:39:34,800
Donc, quelque chose comme la recherche binaire est logarithmique,

660
00:39:34,800 --> 00:39:37,140
où nous avons réduit de moitié le problème à chaque fois

661
00:39:37,140 --> 00:39:40,970
et puis les choses simplement obtenir plus à partir de là.

662
00:39:40,970 --> 00:39:43,580
Et si jamais vous êtes écrit un joint de n'importe quel algorithme factorielle,

663
00:39:43,580 --> 00:39:47,850
vous ne devriez pas considérer cela comme votre travail quotidien.

664
00:39:47,850 --> 00:39:53,910
Lorsque nous comparons les temps de fonctionnement, il est important de garder à l'esprit ces choses.

665
00:39:53,910 --> 00:39:57,760
Donc, si j'ai un algorithme qui est O (n), et quelqu'un d'autre

666
00:39:57,760 --> 00:40:03,590
a un algorithme en O (2n) ce sont en fait asymptotiquement équivalente.

667
00:40:03,590 --> 00:40:06,590
Donc, si nous imaginons que N soit un grand nombre comme undécante milliards d'euros:

668
00:40:06,590 --> 00:40:13,090
alors quand nous comparons undécante milliards à quelque chose comme undécante milliards + 3,

669
00:40:13,090 --> 00:40:17,640
tout à coup que 3 n'a pas vraiment faire une grosse différence plus.

670
00:40:17,640 --> 00:40:20,980
C'est pourquoi nous allons commencer à considérer ces choses comme équivalentes.

671
00:40:20,980 --> 00:40:24,220
Donc, des choses comme ces constantes ici, il ya 2 x ce, ou en ajoutant un 3,

672
00:40:24,220 --> 00:40:27,180
ce ne sont que des constantes, et ceux-ci vont tomber en place.

673
00:40:27,180 --> 00:40:32,480
Voilà pourquoi tous les 3 de ces durées de fonctionnement sont les mêmes que dire qu'ils sont en O (n).

674
00:40:32,480 --> 00:40:37,490
De même, si nous avons 2 temps d'exécution d'autres, disons O (n + 2n ³ ²), nous pouvons ajouter

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, puis nous avons un autre moment de l'exécution, c'est juste O (n ³).

676
00:40:42,070 --> 00:40:46,290
encore une fois, il s'agit de la même chose parce ceux-ci - ce ne sont pas les mêmes.

677
00:40:46,290 --> 00:40:49,840
Ce sont les mêmes choses, désolé. Ce sont donc les mêmes que

678
00:40:49,840 --> 00:40:53,090
ce n ³ va dominer cette 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Ce qui n'est pas la même chose est si nous avons manqué des moments comme O (n ³) et O (n ²)

680
00:40:59,130 --> 00:41:02,820
car ce n ³ est beaucoup plus grande que ce n ².

681
00:41:02,820 --> 00:41:05,470
Donc, si nous avons des exposants, tout à coup cela commence à la matière,

682
00:41:05,470 --> 00:41:08,280
mais quand nous ne faisons que traiter avec des facteurs tels que nous sommes ici,

683
00:41:08,280 --> 00:41:12,810
alors il ne va pas d'importance, car ils vont tout simplement à l'abandon.

684
00:41:12,810 --> 00:41:16,760
Jetons un coup d'oeil à quelques-uns des algorithmes que nous avons vu jusqu'à présent

685
00:41:16,760 --> 00:41:19,260
et parler de leur exécution.

686
00:41:19,260 --> 00:41:23,850
La première façon de chercher un numéro dans une liste, que nous avons vu, était la recherche linéaire.

687
00:41:23,850 --> 00:41:26,950
Et la mise en œuvre de la recherche linéaire est super simple.

688
00:41:26,950 --> 00:41:30,490
Nous venons d'avoir une liste, et nous allons nous pencher sur chaque élément de la liste

689
00:41:30,490 --> 00:41:34,260
jusqu'à ce qu'on trouve le nombre que nous recherchons.

690
00:41:34,260 --> 00:41:38,370
Cela signifie donc que dans le pire des cas, en O (n).

691
00:41:38,370 --> 00:41:40,860
Et le pire cas en l'espèce pourrait être si l'élément est

692
00:41:40,860 --> 00:41:45,710
le dernier élément, puis en utilisant la recherche linéaire, nous devons regarder chaque élément

693
00:41:45,710 --> 00:41:50,180
jusqu'à ce que nous arrivons à la dernière pour savoir que c'était en fait dans la liste.

694
00:41:50,180 --> 00:41:52,910
Nous ne pouvons pas abandonner à mi-chemin et dire: «Ce n'est probablement pas là-bas."

695
00:41:52,910 --> 00:41:55,980
Avec la recherche linéaire, nous devons regarder l'ensemble.

696
00:41:55,980 --> 00:41:59,090
Le temps de fonctionnement meilleur des cas, d'autre part, est constante

697
00:41:59,090 --> 00:42:04,200
parce que dans le meilleur des cas, l'élément que nous voulons, c'est juste le premier dans la liste.

698
00:42:04,200 --> 00:42:08,930
Donc, il va falloir nous exactement 1 étape, peu importe la taille de la liste est

699
00:42:08,930 --> 00:42:12,140
si nous cherchons le premier élément à chaque fois.

700
00:42:12,140 --> 00:42:15,390
>> Ainsi, lorsque vous effectuez une recherche, rappelez-vous, il n'est pas nécessaire que notre liste soit triée.

701
00:42:15,390 --> 00:42:19,430
Parce que nous allons simplement regarder par-dessus chaque élément, et il n'a pas vraiment d'importance

702
00:42:19,430 --> 00:42:23,560
quel ordre ces éléments sont po

703
00:42:23,560 --> 00:42:28,110
Un algorithme de recherche plus intelligente est quelque chose comme binaire de recherche.

704
00:42:28,110 --> 00:42:31,500
Rappelez-vous, la mise en œuvre de la recherche binaire, c'est quand vous allez

705
00:42:31,500 --> 00:42:34,320
continuer à chercher au milieu de la liste.

706
00:42:34,320 --> 00:42:38,000
Et parce que nous cherchons au milieu, nous exigeons que la liste est triée

707
00:42:38,000 --> 00:42:40,580
ou bien nous ne savons pas où est le milieu, et nous devons nous pencher sur

708
00:42:40,580 --> 00:42:44,480
toute la liste pour le trouver, puis à ce moment nous sommes en train de perdre du temps.

709
00:42:44,480 --> 00:42:48,480
Donc, si nous avons une liste triée et nous trouvons au milieu, nous allons comparer le milieu

710
00:42:48,480 --> 00:42:51,590
à l'élément que nous recherchons.

711
00:42:51,590 --> 00:42:54,640
Si elle est trop élevée, alors on peut oublier la moitié droite

712
00:42:54,640 --> 00:42:57,810
parce que nous savons que si notre élément est déjà trop élevé

713
00:42:57,810 --> 00:43:01,080
et tout à droite de cet élément est encore plus élevé,

714
00:43:01,080 --> 00:43:02,760
alors nous n'avons pas besoin de chercher plus là.

715
00:43:02,760 --> 00:43:05,430
Où d'autre part, si notre élément est trop faible,

716
00:43:05,430 --> 00:43:08,700
nous savons tout sur la gauche de cet élément est également trop faible,

717
00:43:08,700 --> 00:43:11,390
de sorte qu'il n'a pas vraiment de sens à chercher là non plus.

718
00:43:11,390 --> 00:43:15,760
De cette façon, à chaque pas et à chaque fois que nous regardons le milieu de la liste,

719
00:43:15,760 --> 00:43:19,060
nous allons réduire notre problème à moitié parce que tout d'un coup, nous savons

720
00:43:19,060 --> 00:43:23,040
tout un tas de chiffres qui ne peuvent pas être celui que nous cherchons.

721
00:43:23,040 --> 00:43:26,950
>> En pseudocode cela ressemble à quelque chose comme ça,

722
00:43:26,950 --> 00:43:30,990
et parce que nous réduisons la liste en deux à chaque fois,

723
00:43:30,990 --> 00:43:34,920
nos pires sauts temporels terme de linéaire à logarithmique.

724
00:43:34,920 --> 00:43:39,260
Alors tout d'un coup, nous avons log-in étapes afin de trouver un élément dans une liste.

725
00:43:39,260 --> 00:43:42,460
Le temps de fonctionnement meilleur des cas, cependant, est toujours constante

726
00:43:42,460 --> 00:43:45,180
parce que maintenant, disons simplement que l'élément que nous voulons, c'est

727
00:43:45,180 --> 00:43:48,380
toujours exactement au milieu de la liste originale.

728
00:43:48,380 --> 00:43:52,080
Ainsi, nous pouvons développer notre liste aussi grande que nous voulons, mais si l'élément que nous cherchons se trouve au milieu,

729
00:43:52,080 --> 00:43:54,910
puis il va seulement pour nous emmener étape 1.

730
00:43:54,910 --> 00:44:00,920
C'est pour cela que nous sommes en O (log n) et Ω (1) ou constant.

731
00:44:00,920 --> 00:44:04,510
Nous allons effectivement lancer la recherche binaire sur cette liste.

732
00:44:04,510 --> 00:44:08,020
Donc, disons que nous sommes à la recherche de l'élément 164.

733
00:44:08,020 --> 00:44:11,650
La première chose que nous allons faire est de trouver le point médian de cette liste.

734
00:44:11,650 --> 00:44:15,060
Il se trouve que le milieu va se situent entre ces 2 numéros,

735
00:44:15,060 --> 00:44:18,960
donc on va plutôt dire arbitrairement, chaque fois que le point médian se situe entre 2 numéros,

736
00:44:18,960 --> 00:44:21,150
disons simplement arrondir.

737
00:44:21,150 --> 00:44:24,330
Nous devons juste nous assurer que nous faisons cela chaque étape du chemin.

738
00:44:24,330 --> 00:44:29,040
Donc, nous allons arrondir, et nous allons dire que 161 est le milieu de notre liste.

739
00:44:29,040 --> 00:44:34,640
Si 161 <164, et chaque élément de la gauche de 161

740
00:44:34,640 --> 00:44:39,120
est aussi <164, alors nous savons que ça ne va pas nous aider à tous

741
00:44:39,120 --> 00:44:42,690
commencer à regarder par ici parce que l'élément que nous recherchons ne peut pas être là.

742
00:44:42,690 --> 00:44:47,060
Donc, ce que nous pouvons faire, c'est nous pouvons simplement oublier que la moitié de toute la gauche de la liste,

743
00:44:47,060 --> 00:44:51,700
et maintenant ne considère que le droit de compter des 161.

744
00:44:51,700 --> 00:44:54,050
>> Encore une fois, c'est le point central; disons simplement arrondir.

745
00:44:54,050 --> 00:44:56,260
175, est trop grand.

746
00:44:56,260 --> 00:44:59,180
Donc, nous savons qu'il ne va pas nous aider à regarder ici ou là,

747
00:44:59,180 --> 00:45:06,610
afin que nous puissions simplement jette ça et, finalement, nous allons frapper le 164.

748
00:45:06,610 --> 00:45:10,560
Toutes les questions sur la recherche binaire?

749
00:45:10,560 --> 00:45:14,180
Passons à autre chose de chercher dans une liste déjà triée

750
00:45:14,180 --> 00:45:17,660
à prendre effectivement une liste de numéros dans un ordre quelconque

751
00:45:17,660 --> 00:45:20,960
et de mettre cette liste dans l'ordre croissant.

752
00:45:20,960 --> 00:45:24,060
Le premier algorithme, nous avons examiné a été appelé tri à bulles.

753
00:45:24,060 --> 00:45:27,300
Et ce serait plus simple des algorithmes que nous avons vu.

754
00:45:27,300 --> 00:45:32,970
Tri à bulles dit que quand les 2 éléments à l'intérieur de la liste sont hors de place,

755
00:45:32,970 --> 00:45:36,500
signifiant qu'il ya un plus grand nombre vers la gauche d'un nombre inférieur,

756
00:45:36,500 --> 00:45:40,190
alors nous allons les changer, parce que cela signifie que la liste sera

757
00:45:40,190 --> 00:45:42,860
«Plus triés» qu'il ne l'était auparavant.

758
00:45:42,860 --> 00:45:45,180
Et nous allons tout simplement continuer ce processus encore et encore et encore

759
00:45:45,180 --> 00:45:52,100
jusqu'à ce que finalement le genre de bulle éléments à leur emplacement correct et nous avons une liste triée.

760
00:45:52,100 --> 00:45:57,230
>> Le moment de l'exécution de ce qui se passe à O (n ²). Pourquoi?

761
00:45:57,230 --> 00:46:00,370
Eh bien, parce que dans le pire des cas, nous allons prendre tous les éléments, et

762
00:46:00,370 --> 00:46:04,570
nous allons finir par le comparant à tout autre élément dans la liste.

763
00:46:04,570 --> 00:46:08,030
Mais dans le meilleur des cas, nous avons une liste déjà triée, bulle sorte de

764
00:46:08,030 --> 00:46:12,230
tout va passer par une fois, dire "Non. Je n'ai pas fait de swaps, donc je suis fait."

765
00:46:12,230 --> 00:46:17,410
Nous avons donc un temps meilleur des cas en cours d'exécution de Ω (n).

766
00:46:17,410 --> 00:46:20,680
Lançons tri à bulles sur une liste.

767
00:46:20,680 --> 00:46:23,560
Ou, disons simplement examiner certains pseudo-code très rapidement.

768
00:46:23,560 --> 00:46:28,160
Nous voulons dire que nous voulons suivre, à chaque itération de la boucle,

769
00:46:28,160 --> 00:46:32,190
de garder trace de si oui ou non nous avons changé tous les éléments.

770
00:46:32,190 --> 00:46:37,610
Donc, la raison en est, nous allons nous arrêter quand nous n'avons pas échangé les éléments.

771
00:46:37,610 --> 00:46:41,980
Ainsi, au début de notre boucle, nous n'avons pas échangé quoi que ce soit, donc nous allons dire que c'est faux.

772
00:46:41,980 --> 00:46:47,170
Maintenant, nous allons parcourir la liste et comparer l'élément i de l'élément i + 1

773
00:46:47,170 --> 00:46:50,310
et si c'est le cas, qu'il existe un plus grand nombre à la gauche d'un nombre plus petit,

774
00:46:50,310 --> 00:46:52,310
puis nous allons juste pour les échanger.

775
00:46:52,310 --> 00:46:54,490
>> Et puis nous allons vous rappeler que nous avons échangé un élément.

776
00:46:54,490 --> 00:46:58,900
Cela signifie que nous avons besoin de passer par la liste d'au moins 1 plus de temps

777
00:46:58,900 --> 00:47:02,160
parce que la condition dans laquelle il est arrêté lorsque la liste entière est déjà triées,

778
00:47:02,160 --> 00:47:04,890
ce qui signifie que nous n'avons pas fait de swaps.

779
00:47:04,890 --> 00:47:09,960
C'est pour cela que notre condition est ici en bas »tandis que certains éléments ont été échangés.

780
00:47:09,960 --> 00:47:13,720
Alors maintenant, nous allons simplement regarder cette course sur une liste.

781
00:47:13,720 --> 00:47:16,640
J'ai la liste 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Tri bulle va commencer tout le chemin à gauche, et il va de comparer

783
00:47:19,850 --> 00:47:24,700
les éléments de I, de manière à 0 i + 1, qui est l'élément 1.

784
00:47:24,700 --> 00:47:29,020
Il va dire, bien 5> 0, mais en ce moment 5 est vers la gauche,

785
00:47:29,020 --> 00:47:32,500
donc j'ai besoin d'échanger le 5 et le 0.

786
00:47:32,500 --> 00:47:35,470
Quand je les échanger, tout d'un coup je me procurer cette liste différente.

787
00:47:35,470 --> 00:47:38,260
Maintenant, 5> 1, donc nous allons les échanger.

788
00:47:38,260 --> 00:47:42,160
5 n'est pas> 6, donc nous n'avons pas besoin de faire quoi que ce soit ici.

789
00:47:42,160 --> 00:47:46,690
Mais 6> 4, donc nous avons besoin d'échanger.

790
00:47:46,690 --> 00:47:49,740
Encore une fois, nous avons besoin de parcourir toute la liste pour finalement découvrir

791
00:47:49,740 --> 00:47:52,330
que ceux-ci sont hors d'usage, nous les échanger,

792
00:47:52,330 --> 00:47:57,120
et en ce moment nous avons besoin de parcourir la liste 1 plus de temps

793
00:47:57,120 --> 00:48:05,390
pour s'assurer que tout est dans l'ordre, et à ce genre de point de bulle est terminée.

794
00:48:05,390 --> 00:48:10,720
Un autre algorithme pour la prise de certains éléments et en les triant est une sorte de sélection.

795
00:48:10,720 --> 00:48:15,740
L'idée derrière tri par sélection, c'est que nous allons mettre en place une partie de la liste triée

796
00:48:15,740 --> 00:48:18,150
1 élément à la fois.

797
00:48:18,150 --> 00:48:23,170
>> Et la façon dont nous allons faire est de construire le segment gauche de la liste.

798
00:48:23,170 --> 00:48:27,510
Et dans le fond, tous les - de chaque étape, nous allons prendre le plus petit élément que nous avons laissé

799
00:48:27,510 --> 00:48:32,310
qui n'a pas encore été triés, et nous allons le déplacer dans ce segment triés.

800
00:48:32,310 --> 00:48:35,850
Cela signifie que nous devons continuellement trouver l'élément minimum non triés

801
00:48:35,850 --> 00:48:40,720
et ensuite prendre cet élément minimum et l'échanger contre quelque

802
00:48:40,720 --> 00:48:45,090
laissé plus-élément qui n'est pas trié.

803
00:48:45,090 --> 00:48:50,890
Le moment de l'exécution de ce qui se passe à O (n ²), car dans le pire des cas

804
00:48:50,890 --> 00:48:55,070
nous avons besoin de comparer chaque élément à tous les autres éléments.

805
00:48:55,070 --> 00:48:59,250
Parce que nous disons que si nous commençons à la moitié gauche de la liste, nous avons besoin

806
00:48:59,250 --> 00:49:02,970
passer par l'ensemble du segment à droite pour trouver le plus petit élément.

807
00:49:02,970 --> 00:49:05,430
Et puis, encore une fois, nous avons besoin d'aller sur la totalité du segment droit et

808
00:49:05,430 --> 00:49:08,210
continuer sur cette maintes et maintes et maintes fois.

809
00:49:08,210 --> 00:49:11,350
Cela va être n ². Nous allons avoir besoin d'une boucle pour l'intérieur d'une autre boucle for

810
00:49:11,350 --> 00:49:13,350
ce qui suggère ² n.

811
00:49:13,350 --> 00:49:16,530
Dans le meilleur des cas, la pensée, disons que nous lui donnons une liste déjà triée;

812
00:49:16,530 --> 00:49:19,270
nous avons en fait ne font pas mieux que n ².

813
00:49:19,270 --> 00:49:21,730
Parce tri par sélection n'a aucun moyen de savoir que

814
00:49:21,730 --> 00:49:25,540
l'élément minimum est juste celui que je arriver à examiner.

815
00:49:25,540 --> 00:49:28,970
Il reste encore à faire en sorte que ce soit effectivement le minimum.

816
00:49:28,970 --> 00:49:31,670
>> Et la seule façon de s'assurer que c'est le minimum, en utilisant cet algorithme,

817
00:49:31,670 --> 00:49:34,640
consiste à examiner chaque élément nouveau.

818
00:49:34,640 --> 00:49:38,420
Alors, vraiment, si vous lui donnez - si vous donnez tri par sélection une liste déjà triée,

819
00:49:38,420 --> 00:49:42,720
il ne va pas faire mieux que de lui donner une liste qui n'est pas encore triées.

820
00:49:42,720 --> 00:49:46,320
Soit dit en passant, si elle arrive à être le cas que quelque chose est en O (quelque chose)

821
00:49:46,320 --> 00:49:50,640
et l'oméga de quelque chose, nous pouvons simplement dire plus succinctement qu'il est θ de quelque chose.

822
00:49:50,640 --> 00:49:52,760
Donc, si vous voyez que trouver n'importe où, c'est ce que cela veut dire tout simplement.

823
00:49:52,760 --> 00:49:57,580
>> Si quelque chose ne thêta de n ², il est à la fois de grande taille O (n ²) et Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Donc le meilleur des cas et le pire des cas, il ne fait pas de différence,

825
00:49:59,790 --> 00:50:04,400
l'algorithme va faire la même chose à chaque fois.

826
00:50:04,400 --> 00:50:06,610
Voilà donc ce que pseudocode pour le tri de sélection pourrait ressembler.

827
00:50:06,610 --> 00:50:10,630
Essentiellement, nous allons dire que je veux parcourir la liste

828
00:50:10,630 --> 00:50:15,180
de gauche à droite, et à chaque itération de la boucle, je vais passer

829
00:50:15,180 --> 00:50:19,780
l'élément minimum dans cette partie de la liste triée.

830
00:50:19,780 --> 00:50:23,260
Et une fois que je déplace quelque chose, je n'ai jamais besoin de regarder cet élément nouveau.

831
00:50:23,260 --> 00:50:28,600
Parce que dès que je remplace un élément dans le segment gauche de la liste, c'est réglé

832
00:50:28,600 --> 00:50:32,600
parce que nous faisons tout dans l'ordre croissant en utilisant des minimums.

833
00:50:32,600 --> 00:50:38,740
Alors nous avons dit, d'accord, nous sommes à i position, et nous avons besoin de regarder tous les éléments

834
00:50:38,740 --> 00:50:42,260
à droite de i pour trouver le minimum.

835
00:50:42,260 --> 00:50:46,150
Cela signifie donc que nous voulons examiner de i + 1 à la fin de la liste.

836
00:50:46,150 --> 00:50:51,610
Et maintenant, si l'élément que nous examinons actuellement est inférieure à notre minimum jusqu'à présent,

837
00:50:51,610 --> 00:50:54,190
qui, rappelez-vous, nous commençons l'arrêt minimum pour être juste

838
00:50:54,190 --> 00:50:57,020
quel que soit l'élément que nous sommes actuellement à; je suppose que c'est le minimum.

839
00:50:57,020 --> 00:51:00,270
Si je trouve un élément qui est plus petit que cela, alors je vais dire, d'accord,

840
00:51:00,270 --> 00:51:02,700
eh bien, j'ai trouvé un nouveau minimum.

841
00:51:02,700 --> 00:51:06,080
Je vais me rappeler où ce minimum était.

842
00:51:06,080 --> 00:51:09,560
>> Alors maintenant, une fois que je suis passé par ce segment de droite non triés,

843
00:51:09,560 --> 00:51:16,690
Je peux dire que je vais permuter l'élément minimal de l'élément qui se trouve dans la position i.

844
00:51:16,690 --> 00:51:21,100
Cela va constituer ma liste, mon triés partie de la liste de gauche à droite,

845
00:51:21,100 --> 00:51:25,190
et nous n'avons pas toujours besoin de regarder un élément nouveau une fois dans la partie.

846
00:51:25,190 --> 00:51:27,930
Une fois que nous avons échangé.

847
00:51:27,930 --> 00:51:30,260
Alors lançons tri par sélection sur cette liste.

848
00:51:30,260 --> 00:51:38,220
L'élément bleu ici va être le i, et l'élément rouge va être l'élément minimum.

849
00:51:38,220 --> 00:51:41,570
Donc, je commence tout le chemin à gauche de la liste, donc à 5.

850
00:51:41,570 --> 00:51:44,610
Maintenant, nous devons trouver l'élément minimum non triés.

851
00:51:44,610 --> 00:51:49,480
Donc, nous disons 0 <5, alors 0 est mon nouveau minimum.

852
00:51:49,480 --> 00:51:53,820
>> Mais je ne peux pas arrêter là, parce que même si nous pouvons reconnaître que 0 est le plus petit,

853
00:51:53,820 --> 00:51:59,390
nous avons besoin de parcourir tout autre élément de la liste pour vous en assurer.

854
00:51:59,390 --> 00:52:01,760
Donc 1 est plus grand, 6 est plus grand, 4 est plus grand.

855
00:52:01,760 --> 00:52:05,850
Cela signifie que, après avoir examiné l'ensemble de ces éléments, j'ai déterminé 0 est le plus petit.

856
00:52:05,850 --> 00:52:09,800
Donc, je vais échanger le 5 et le 0.

857
00:52:09,800 --> 00:52:15,480
Une fois que j'échange, je vais me faire une nouvelle liste, et je sais que je n'ai jamais besoin de regarder que 0 fois

858
00:52:15,480 --> 00:52:19,380
car une fois que je l'ai échangé, je l'ai triées et nous avons fini.

859
00:52:19,380 --> 00:52:22,730
Maintenant, il se trouve que l'élément bleu est de nouveau le 5,

860
00:52:22,730 --> 00:52:26,030
et nous avons besoin de regarder le 1, le 6 et le 4 pour déterminer que 1

861
00:52:26,030 --> 00:52:31,520
est l'élément le plus petit minimum, donc nous allons échanger le 1 et le 5.

862
00:52:31,520 --> 00:52:36,890
Encore une fois, nous avons besoin de regarder - comparer le 5 au 6 et le 4,

863
00:52:36,890 --> 00:52:39,830
et nous allons échanger le 4 et le 5, et enfin, de comparer

864
00:52:39,830 --> 00:52:45,740
ces 2 numéros et de les échanger jusqu'à ce que nous obtenions notre liste triée.

865
00:52:45,740 --> 00:52:49,730
Toute question concernant tri par sélection?

866
00:52:49,730 --> 00:52:56,420
D'accord. Passons au dernier sujet ici, et c'est la récursivité.

867
00:52:56,420 --> 00:52:59,810
>> Récursivité, rappelez-vous, cette chose méta vraiment où une fonction

868
00:52:59,810 --> 00:53:02,740
appelle à plusieurs reprises lui-même.

869
00:53:02,740 --> 00:53:05,620
Donc, à un moment donné, alors que notre fuction est sans cesse se demandant,

870
00:53:05,620 --> 00:53:10,100
il doit y avoir un moment où nous cessons de nous appeler.

871
00:53:10,100 --> 00:53:13,670
Parce que si nous ne faisons pas cela, alors nous allons juste continuer à faire ce pour toujours,

872
00:53:13,670 --> 00:53:16,660
et notre programme est tout simplement pas prêt à se terminer.

873
00:53:16,660 --> 00:53:19,200
Nous appelons cette condition, le scénario de base.

874
00:53:19,200 --> 00:53:22,570
Et le scénario de référence dit, plutôt que d'appeler une fonction encore une fois,

875
00:53:22,570 --> 00:53:25,330
Je vais retourner une valeur.

876
00:53:25,330 --> 00:53:28,080
Donc, une fois que nous avons retourné une valeur, nous avons cessé de nous appeler,

877
00:53:28,080 --> 00:53:32,550
et le reste des appels que nous avons faites jusqu'ici peuvent également retourner.

878
00:53:32,550 --> 00:53:36,050
Le contraire de l'hypothèse de base est le cas récursif.

879
00:53:36,050 --> 00:53:39,050
Et c'est à ce moment que nous voulons faire un autre appel à la fonction que nous sommes actuellement po

880
00:53:39,050 --> 00:53:44,690
Et nous avons probablement, mais pas toujours, à utiliser des arguments différents.

881
00:53:44,690 --> 00:53:48,940
>> Donc, si nous avons une fonction appelée f, et f vient de m'appeler prendre 1 argument,

882
00:53:48,940 --> 00:53:52,010
et nous venons de continuer à appeler f (1), f (1), f (1), et il se trouve que

883
00:53:52,010 --> 00:53:56,510
l'argument 1 tombe sous le cas récursif, nous sommes encore jamais cesser.

884
00:53:56,510 --> 00:54:01,620
Même si nous avons un cas de base, nous devons faire en sorte que finalement nous allons frapper ce cas de base.

885
00:54:01,620 --> 00:54:04,250
Nous n'avons pas simplement continuer en restant dans ce cas récursif.

886
00:54:04,250 --> 00:54:09,870
En général, lorsque nous nous appelons, nous allons probablement avoir un argument différent à chaque fois.

887
00:54:09,870 --> 00:54:12,700
Voici une fonction récursive très simple.

888
00:54:12,700 --> 00:54:15,090
Donc, ce sera de calculer la factorielle d'un nombre.

889
00:54:15,090 --> 00:54:17,790
Jusqu'à haut nous avons ici notre scénario de base.

890
00:54:17,790 --> 00:54:22,330
Dans le cas où n ≤ 1, nous n'allons pas faire appel à nouveau factorielle.

891
00:54:22,330 --> 00:54:26,490
Nous allons nous arrêter, nous allons juste retourner une valeur.

892
00:54:26,490 --> 00:54:30,170
Si ce n'est pas le cas, alors nous allons frapper notre cas récursif.

893
00:54:30,170 --> 00:54:33,550
Notez ici que nous ne sommes pas seulement appel factorielle (n), parce que ce ne serait pas très utile.

894
00:54:33,550 --> 00:54:36,810
Nous allons appeler factorielle de quelque chose d'autre.

895
00:54:36,810 --> 00:54:40,850
>> Et si vous pouvez le voir, par la suite si nous adoptons une chose factorielle (5) ou,

896
00:54:40,850 --> 00:54:45,900
nous allons faire appel factorielle (4) et ainsi de suite, et finalement nous allons frapper ce cas de base.

897
00:54:45,900 --> 00:54:51,730
Donc, ça a l'air bon. Voyons voir ce qui se passe quand on fait exécuter ce.

898
00:54:51,730 --> 00:54:57,840
Il s'agit de la pile, et disons que principal va appeler cette fonction avec un argument (4).

899
00:54:57,840 --> 00:55:02,200
Donc, une fois factorielle voit et = 4, factorielle sera s'appeler elle-même.

900
00:55:02,200 --> 00:55:05,010
Maintenant, tout à coup, nous avons factorielle (3).

901
00:55:05,010 --> 00:55:10,780
Ainsi, ces fonctions vont continuer de croître jusqu'à ce que finalement nous avons atteint notre scénario de base.

902
00:55:10,780 --> 00:55:17,830
À ce stade, la valeur de retour de ceci est le retour (nx la valeur de retour de cette intervention),

903
00:55:17,830 --> 00:55:21,290
la valeur de retour de cette nx est la valeur de retour de cette.

904
00:55:21,290 --> 00:55:23,290
Finalement, nous avons besoin de frapper un certain nombre.

905
00:55:23,290 --> 00:55:26,560
En haut ici, nous disons retour 1.

906
00:55:26,560 --> 00:55:30,650
Cela signifie qu'une fois que nous revenons ce nombre, on peut sauter ce de la pile.

907
00:55:30,650 --> 00:55:36,570
Donc, ce factorielle (1) est fait.

908
00:55:36,570 --> 00:55:41,190
Lorsque retourne 1, ce factoriels (1) revient, ce retour à 1.

909
00:55:41,190 --> 00:55:46,910
La valeur de retour de cela, rappelez-vous, était nx la valeur de retour de cette.

910
00:55:46,910 --> 00:55:50,720
Alors tout d'un coup, ce gars sait ce que je veux revenir 2.

911
00:55:50,720 --> 00:55:55,910
>> Donc n'oubliez pas, la valeur de retour de cette nx est juste la valeur de retour ici.

912
00:55:55,910 --> 00:56:01,160
Alors maintenant, nous pouvons dire 3 x 2, et enfin, ici, nous pouvons dire

913
00:56:01,160 --> 00:56:04,010
cela va juste être 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
Et une fois que ces retours, nous nous attelons à l'intérieur d'un seul entier de main.

915
00:56:09,570 --> 00:56:15,460
Toute question relative à la récursivité?

916
00:56:15,460 --> 00:56:17,090
Très bien. Il n'y a donc plus de temps pour les questions à la fin,

917
00:56:17,090 --> 00:56:23,360
mais maintenant Joseph portera sur les sujets restants.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Très bien. Alors, maintenant que nous avons parlé de récurrences,

919
00:56:25,590 --> 00:56:27,840
parlons un peu de ce que le tri par fusion est.

920
00:56:27,840 --> 00:56:31,740
Le tri par fusion est essentiellement une autre façon de trier une liste de nombres.

921
00:56:31,740 --> 00:56:36,430
Et comment cela fonctionne-dire, avec une sorte de fusion, vous avez une liste, et ce que nous faisons est

922
00:56:36,430 --> 00:56:39,120
nous disons, nous allons diviser ce en 2 moitiés.

923
00:56:39,120 --> 00:56:42,750
Nous allons d'abord exécuter le tri par fusion à nouveau sur la moitié gauche,

924
00:56:42,750 --> 00:56:45,040
alors nous courrons le tri par fusion sur la moitié droite,

925
00:56:45,040 --> 00:56:50,240
et cela nous donne maintenant 2 moitiés qui sont triées, et maintenant nous allons combiner les deux moitiés ensemble.

926
00:56:50,240 --> 00:56:55,010
C'est un peu difficile de voir sans exemple, nous allons donc passer par les mouvements et voir ce qui se passe.

927
00:56:55,010 --> 00:56:59,590
Donc, vous commencez avec cette liste, nous l'avons divisé en 2 moitiés.

928
00:56:59,590 --> 00:57:02,300
Nous courons le tri par fusion sur la moitié gauche d'abord.

929
00:57:02,300 --> 00:57:06,660
Donc, c'est la moitié gauche, et maintenant nous les faire fonctionner grâce à cette liste encore

930
00:57:06,660 --> 00:57:09,800
ce qui se passe dans le tri par fusion, puis nous attendons, encore une fois,

931
00:57:09,800 --> 00:57:13,270
sur le côté gauche de cette liste et nous courons le tri par fusion sur elle.

932
00:57:13,270 --> 00:57:15,880
Maintenant, nous nous attelons à une liste de 2 nombres,

933
00:57:15,880 --> 00:57:19,010
et maintenant la moitié gauche est à seulement 1 élément de long, et nous ne pouvons

934
00:57:19,010 --> 00:57:23,380
diviser une liste qui est seulement 1 élément dans la moitié, donc nous avons juste dire, une fois que nous avons 50,

935
00:57:23,380 --> 00:57:26,400
qui est à seulement 1 élément, il est déjà triée.

936
00:57:26,400 --> 00:57:29,860
>> Une fois que nous aurons fini avec ça, nous pouvons voir ce que nous pouvons

937
00:57:29,860 --> 00:57:32,230
passer à la moitié droite de cette liste,

938
00:57:32,230 --> 00:57:36,480
et 3 est également triée, et maintenant que les deux moitiés de cette liste sont triés

939
00:57:36,480 --> 00:57:39,080
nous pouvons joindre à ces numéros de retour ensemble.

940
00:57:39,080 --> 00:57:45,320
Nous cherchons donc à 50 et 3, 3 est plus petit que 50, donc il va en premier et ensuite 50 entre en jeu.

941
00:57:45,320 --> 00:57:49,340
Maintenant, c'est fait, nous remontons à cette liste et trier c'est la moitié droite.

942
00:57:49,340 --> 00:57:52,440
42 est son propre numéro, il est donc déjà triés.

943
00:57:52,440 --> 00:57:57,850
Alors maintenant, nous comparons ces 2 et 3 est plus petit que 42, de sorte que se mettre en premier,

944
00:57:57,850 --> 00:58:02,340
maintenant 42 se mettre, et 50 se mettre po

945
00:58:02,340 --> 00:58:07,220
Maintenant, ce n'est trié, nous allons tous le chemin du retour vers le haut, 1337 et 15.

946
00:58:07,220 --> 00:58:14,560
Eh bien, nous regardons à présent la moitié gauche de cette liste; 1337 est par elle-même si elle est triée et même 15.

947
00:58:14,560 --> 00:58:19,020
Alors maintenant, nous combinons ces 2 numéros pour trier cette liste initiale, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
il en va en premier, puis 1337 va po

949
00:58:23,060 --> 00:58:26,640
Et maintenant, nous avons trié les deux moitiés de la liste originale en haut.

950
00:58:26,640 --> 00:58:30,440
Et tout ce que nous devons faire est de combiner celles-ci.

951
00:58:30,440 --> 00:58:36,890
Nous regardons les 2 premiers numéros de la liste, 3 <15, donc ça va dans le tableau Tri.

952
00:58:36,890 --> 00:58:44,460
15 <42, alors il va po Maintenant, 42 <1337, qui va po

953
00:58:44,460 --> 00:58:51,010
50 <1337, donc il va po Et remarquez que nous avons juste pris 2 numéros hors de cette liste.

954
00:58:51,010 --> 00:58:53,640
Donc, nous ne sommes pas seulement une alternance entre les 2 listes.

955
00:58:53,640 --> 00:58:56,050
Nous cherchons simplement au début, et nous prenons l'élément

956
00:58:56,050 --> 00:59:00,270
qui est plus petit, puis le mettre dans notre tableau.

957
00:59:00,270 --> 00:59:04,080
Maintenant, nous avons fusionné tous les deux et nous avons fini.

958
00:59:04,080 --> 00:59:07,780
>> Une question sur le tri par fusion? Oui?

959
00:59:07,780 --> 00:59:14,190
[Étudiants] Si c'est diviser en différents groupes, pourquoi ne pas simplement le diviser une fois

960
00:59:14,190 --> 00:59:19,970
et vous avez 3 et 2 dans un groupe? [Reste de l'inintelligible question]

961
00:59:19,970 --> 00:59:24,940
La raison pour laquelle - si la question est, pourquoi ne peut-on pas simplement de les fusionner à cette première étape après nous les avoir?

962
00:59:24,940 --> 00:59:29,530
La raison pour laquelle nous pouvons faire cela, commencez par les éléments les plus à gauche des deux côtés,

963
00:59:29,530 --> 00:59:33,040
puis prendre le plus petit et le mettre dans, c'est que nous savons que ces

964
00:59:33,040 --> 00:59:35,290
différentes listes sont triées dans les ordres.

965
00:59:35,290 --> 00:59:37,290
Donc, si je regarde les éléments plus à gauche des deux moitiés,

966
00:59:37,290 --> 00:59:40,490
Je sais qu'ils vont être les plus petits éléments de ces listes.

967
00:59:40,490 --> 00:59:43,930
Donc, je peux les mettre dans les endroits les plus petits éléments de cette liste exhaustive.

968
00:59:43,930 --> 00:59:47,810
D'autre part, si je regarde ces 2 listes au second niveau, là-bas,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 et 15, ceux-ci sont non trié.

970
00:59:51,640 --> 00:59:55,770
Donc, si je regarde 50 et 1337, je vais mettre 50 dans ma première liste.

971
00:59:55,770 --> 01:00:00,130
Mais cela n'a pas vraiment de sens, car 3 est le plus petit élément de l'ensemble de ceux-ci.

972
01:00:00,130 --> 01:00:04,390
Donc, la seule raison pour laquelle nous pouvons faire cette étape de combinaison est parce que nos listes sont déjà triés.

973
01:00:04,390 --> 01:00:07,010
C'est pourquoi nous devons nous mettre tout le chemin vers le bas

974
01:00:07,010 --> 01:00:09,800
parce que quand nous avons un nombre unique, vous savez qu'un seul numéro

975
01:00:09,800 --> 01:00:14,120
en soi est déjà une liste triée.

976
01:00:14,120 --> 01:00:19,360
>> Des questions? Non?

977
01:00:19,360 --> 01:00:24,260
Complexité? Eh bien, vous pouvez voir qu'à chaque étape il ya un nombre finaux,

978
01:00:24,260 --> 01:00:27,590
et nous pouvons diviser une liste dans le journal de moitié n fois,

979
01:00:27,590 --> 01:00:31,700
et c'est là que nous obtenons ce log n x n la complexité.

980
01:00:31,700 --> 01:00:34,940
Et vous verrez le meilleur des cas pour le tri fusion est n log n, et il se trouve

981
01:00:34,940 --> 01:00:39,340
que le pire des cas, ou le Ω là-bas, est aussi n log n.

982
01:00:39,340 --> 01:00:42,480
Quelque chose à garder à l'esprit.

983
01:00:42,480 --> 01:00:45,750
Sur la route, nous allons passer à un fichier super basique I / O.

984
01:00:45,750 --> 01:00:48,830
Si vous avez regardé Scramble, vous remarquerez que nous avions une sorte de système

985
01:00:48,830 --> 01:00:51,270
où l'on pouvait écrire dans un fichier journal si vous lisez le code.

986
01:00:51,270 --> 01:00:53,730
Voyons comment vous pourriez le faire.

987
01:00:53,730 --> 01:00:57,450
Eh bien, nous avons fprintf, que vous pouvez considérer comme juste printf,

988
01:00:57,450 --> 01:01:01,720
mais juste l'impression d'un fichier au lieu, et par conséquent le f au début.

989
01:01:01,720 --> 01:01:07,570
Cette sorte de code ici, ce qu'il fait est, comme vous avez pu voir dans la lutte confuse,

990
01:01:07,570 --> 01:01:12,310
il passe par votre impression de tableau à 2 dimensions rangée par rangée quels sont les chiffres.

991
01:01:12,310 --> 01:01:17,850
Dans ce cas, imprime printf sur votre terminal ou ce que nous appelons la sortie standard de la section.

992
01:01:17,850 --> 01:01:22,170
>> Et maintenant, dans ce cas, tout ce que nous avons à faire est de remplacer printf avec fprintf,

993
01:01:22,170 --> 01:01:26,770
lui dire ce fichier que vous souhaitez imprimer, et dans ce cas il imprime juste sur ce fichier

994
01:01:26,770 --> 01:01:32,230
au lieu de l'afficher sur votre terminal.

995
01:01:32,230 --> 01:01:36,500
Eh bien, cela soulève la question: Où peut-on obtenir ce genre de fichier, pas vrai?

996
01:01:36,500 --> 01:01:39,840
Nous avons passé connecter à ce fuction fprintf, mais nous n'avions aucune idée d'où il vient.

997
01:01:39,840 --> 01:01:43,980
Eh bien, au début du code, ce que nous avions était ce bout de code ici,

998
01:01:43,980 --> 01:01:48,340
qui dit essentiellement que le fichier ouvert appelle log.txt.

999
01:01:48,340 --> 01:01:53,220
Que faisons-nous après cela est que nous devons faire en sorte que le fichier est ouvert avec succès.

1000
01:01:53,220 --> 01:01:57,070
Ainsi, il peut échouer pour de multiples raisons, vous n'avez pas assez d'espace sur votre ordinateur, par exemple.

1001
01:01:57,070 --> 01:01:59,790
Donc, il est toujours important avant de faire des opérations avec le fichier

1002
01:01:59,790 --> 01:02:03,300
que nous vérifions si ce fichier a été ouvert avec succès.

1003
01:02:03,300 --> 01:02:09,330
Alors qu'est-ce qu'un, c'est un argument de fopen, eh bien, nous pouvons ouvrir un fichier de plusieurs façons.

1004
01:02:09,330 --> 01:02:13,510
Ce que nous pouvons faire, c'est, nous pouvons lui passer w, ce qui signifie remplacer le fichier s'il existe déjà,

1005
01:02:13,510 --> 01:02:18,070
Nous pouvons passer un un, dont ils ajouter à la fin du fichier au lieu de l'écraser,

1006
01:02:18,070 --> 01:02:22,730
ou nous pouvons spécifier r, ce qui signifie, nous allons ouvrir le fichier en lecture seule.

1007
01:02:22,730 --> 01:02:24,890
Donc, si le programme tente d'apporter des modifications au fichier,

1008
01:02:24,890 --> 01:02:30,140
crier après eux et ne pas les laisser faire.

1009
01:02:30,140 --> 01:02:33,320
Enfin, une fois que nous en avons terminé avec le fichier, fini de faire des opérations sur elle,

1010
01:02:33,320 --> 01:02:35,860
nous devons nous assurer que nous fermez le fichier.

1011
01:02:35,860 --> 01:02:38,830
Et si à la fin de votre programme, vous allez les passer à nouveau

1012
01:02:38,830 --> 01:02:42,120
ce fichier que vous avez ouvert, et il suffit de fermer.

1013
01:02:42,120 --> 01:02:44,650
Donc, c'est quelque chose d'important que vous devez vous assurer que vous faites.

1014
01:02:44,650 --> 01:02:47,180
Alors, n'oubliez pas que vous pouvez ouvrir un fichier, vous pouvez écrire dans le fichier,

1015
01:02:47,180 --> 01:02:51,270
effectuer des opérations dans le fichier, mais alors vous devez fermer le fichier à la fin.

1016
01:02:51,270 --> 01:02:53,270
>> Toute question concernant le fichier de base d'E / S? Oui?

1017
01:02:53,270 --> 01:02:58,050
[Question étudiants, inintelligible]

1018
01:02:58,050 --> 01:03:02,480
Juste ici. La question est, d'où vient ce fichier log.txt apparaissent-elles?

1019
01:03:02,480 --> 01:03:07,890
Eh bien, si vous venez de lui donner log.txt, il le crée dans le même répertoire que l'exécutable.

1020
01:03:07,890 --> 01:03:10,500
Donc, si Tu es - >> [question étudiants, inintelligible]

1021
01:03:10,500 --> 01:03:18,830
Oui. Dans le même dossier, ou dans le même répertoire, comme vous l'appelez.

1022
01:03:18,830 --> 01:03:21,400
Maintenant, mémoire, pile et tas.

1023
01:03:21,400 --> 01:03:23,400
Alors, comment la mémoire est énoncé dans l'ordinateur?

1024
01:03:23,400 --> 01:03:26,270
Eh bien, vous pouvez imaginer la mémoire comme type de ce bloc ici.

1025
01:03:26,270 --> 01:03:30,260
Et dans la mémoire que nous avons ce qu'on appelle le tas coincé là-bas, et la pile qui est là-bas.

1026
01:03:30,260 --> 01:03:34,480
Et le tas pousse vers le bas et vers le haut de la pile grandit.

1027
01:03:34,480 --> 01:03:38,620
Alors que Tommy a mentionné - oh, bien, et nous avons ces 4 autres segments que je vais obtenir dans un instant -

1028
01:03:38,620 --> 01:03:42,890
Comme Tommy dit plus tôt, vous savez combien ses fonctions s'appellent eux-mêmes et d'appeler les uns les autres?

1029
01:03:42,890 --> 01:03:44,930
Ils construisent ce genre de cadre de pile.

1030
01:03:44,930 --> 01:03:47,360
Eh bien, si les appels principaux foo, foo se mettre sur la pile.

1031
01:03:47,360 --> 01:03:52,430
Foo appelle, bar get mettre sur la pile, et que se mettre sur la pile après.

1032
01:03:52,430 --> 01:03:57,040
Et à leur retour, ils reçoivent chacun enlevé la pile.

1033
01:03:57,040 --> 01:04:00,140
Qu'est-ce que chacun de ces lieux de mémoire et maintenez?

1034
01:04:00,140 --> 01:04:03,110
Eh bien, en haut, qui est le segment de texte, contient le programme lui-même.

1035
01:04:03,110 --> 01:04:06,390
Ainsi, le code machine, qui est là, une fois que vous compilez votre programme.

1036
01:04:06,390 --> 01:04:08,520
Ensuite, toute initialisation des variables globales.

1037
01:04:08,520 --> 01:04:12,660
>> Vous avez donc des variables globales dans votre programme, et vous dire que j'aime, a = 5,

1038
01:04:12,660 --> 01:04:15,260
que se mettre dans ce segment, et le droit en vertu de ce,

1039
01:04:15,260 --> 01:04:18,990
vous avez des données non initialisées mondiaux, ce qui est tout simplement un int,

1040
01:04:18,990 --> 01:04:20,990
mais vous ne dites pas que c'est égal à quoi que ce soit.

1041
01:04:20,990 --> 01:04:23,870
Réalisez ce sont des variables globales, de sorte qu'ils sont à l'extérieur du principal.

1042
01:04:23,870 --> 01:04:28,560
Donc, cela signifie que toutes les variables globales sont déclarées mais ne sont pas initialisés.

1043
01:04:28,560 --> 01:04:32,310
Alors, quelle est dans le tas? La mémoire allouée avec malloc, qui nous y reviendrons dans un peu.

1044
01:04:32,310 --> 01:04:35,990
Et enfin, avec la pile vous avez des variables locales

1045
01:04:35,990 --> 01:04:39,950
et toutes les fonctions que vous pourriez appeler dans n'importe lequel de leurs paramètres.

1046
01:04:39,950 --> 01:04:43,720
La dernière chose, vous n'avez pas vraiment besoin de savoir quelles sont les variables d'environnement font,

1047
01:04:43,720 --> 01:04:46,700
mais chaque fois que vous lancez le programme, il ya quelque chose associée, comme

1048
01:04:46,700 --> 01:04:49,550
il s'agit du nom de la personne qui dirigeait le programme.

1049
01:04:49,550 --> 01:04:51,550
Et cela va être une sorte de vers le bas.

1050
01:04:51,550 --> 01:04:54,540
En termes d'adresses de mémoire, qui sont des valeurs hexadécimales,

1051
01:04:54,540 --> 01:04:58,170
les valeurs qui sont au top start à 0, et ils vont tout le chemin vers le bas.

1052
01:04:58,170 --> 01:05:00,440
Dans ce cas, si vous êtes sur le système 32-bit,

1053
01:05:00,440 --> 01:05:05,390
l'adresse indiquée au bas va être 0x, suivie d'af, parce que c'est 32 bits,

1054
01:05:05,390 --> 01:05:10,890
qui est de 8 octets, et dans ce cas, correspond à 8 octets 8 chiffres hexadécimaux.

1055
01:05:10,890 --> 01:05:20,110
Donc ici vous allez avoir, comme, 0xffffff, et là-haut, vous allez avoir 0.

1056
01:05:20,110 --> 01:05:23,660
Alors, quels sont les pointeurs? Certains d'entre vous peuvent ne pas avoir parlé dans la section précédente.

1057
01:05:23,660 --> 01:05:26,660
mais nous sommes allés au-dessus de conférence, ainsi qu'un pointeur est juste un type de données

1058
01:05:26,660 --> 01:05:34,030
les magasins qui, au lieu d'une sorte de valeur comme 50, il stocke l'adresse d'un emplacement mémoire.

1059
01:05:34,030 --> 01:05:36,020
Comme ce mémoire [inintelligible].

1060
01:05:36,020 --> 01:05:41,120
Donc dans ce cas, ce que nous avons dit, nous avons un pointeur vers un entier ou un int *,

1061
01:05:41,120 --> 01:05:46,210
et il contient cette adresse hexadécimale de 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Donc, ce que nous avons, c'est que maintenant, ce pointeur à un endroit dans la mémoire,

1063
01:05:50,880 --> 01:05:56,020
et que c'est juste une, la valeur 50 est à cet emplacement mémoire.

1064
01:05:56,020 --> 01:06:01,810
Sur certains systèmes 32-bit, sur tous les systèmes 32-bits, les pointeurs prendre jusqu'à 32 bits ou 4 octets.

1065
01:06:01,810 --> 01:06:06,020
Mais, par exemple, sur un système 64-bit, les pointeurs sont 64 bits.

1066
01:06:06,020 --> 01:06:08,040
Donc, c'est quelque chose que vous aurez envie de garder à l'esprit.

1067
01:06:08,040 --> 01:06:12,310
Ainsi, sur un système d'extrémité bits, un pointeur est embouts longtemps.

1068
01:06:12,310 --> 01:06:17,320
Les pointeurs sont un peu difficile à digérer sans choses supplémentaires,

1069
01:06:17,320 --> 01:06:20,300
nous allons donc passer par un exemple d'allocation dynamique de mémoire.

1070
01:06:20,300 --> 01:06:25,130
Quelle allocation dynamique de mémoire fait pour vous, ou ce que nous appelons malloc,

1071
01:06:25,130 --> 01:06:29,280
il vous permet d'allouer une sorte de données à l'extérieur de l'appareil.

1072
01:06:29,280 --> 01:06:31,830
Ainsi, ces données est en quelque sorte plus permanente pendant toute la durée du programme.

1073
01:06:31,830 --> 01:06:36,430
Parce que, comme vous le savez, si vous déclarez x à l'intérieur d'une fonction, et que les retours de fonction,

1074
01:06:36,430 --> 01:06:40,910
vous n'avez plus accès aux données qui ont été stockées dans x.

1075
01:06:40,910 --> 01:06:44,420
Qu'est-ce pointeurs laissez-nous faire, c'est qu'ils nous stocker des valeurs de mémoire ou un magasin

1076
01:06:44,420 --> 01:06:46,840
dans un autre segment de mémoire, à savoir le tas.

1077
01:06:46,840 --> 01:06:49,340
Maintenant, une fois nous revenons sur la fonction, aussi longtemps que nous avons un pointeur

1078
01:06:49,340 --> 01:06:54,960
à cet emplacement dans la mémoire, ce que nous pouvons faire, c'est nous pouvons simplement regarder les valeurs de ce pays.

1079
01:06:54,960 --> 01:06:58,020
Voyons un exemple: Il s'agit de notre organisation de la mémoire à nouveau.

1080
01:06:58,020 --> 01:07:00,050
Et nous avons cette fonction, principal.

1081
01:07:00,050 --> 01:07:06,870
Ce qu'il fait est - d'accord, si simple, droite - int x = 5, c'est juste une variable sur la pile en principal.

1082
01:07:06,870 --> 01:07:12,450
>> D'un autre côté, maintenant, nous déclarons un pointeur qui appelle les giveMeThreeInts fonction.

1083
01:07:12,450 --> 01:07:16,800
Et maintenant nous allons dans cette fonction et nous créons un nouveau frame de pile pour elle.

1084
01:07:16,800 --> 01:07:20,440
Cependant, dans ce cadre de pile, nous déclarons int * temp,

1085
01:07:20,440 --> 01:07:23,210
qui mallocs 3 entiers pour nous.

1086
01:07:23,210 --> 01:07:25,880
Donc taille de int nous donnera le nombre d'octets de cette int est,

1087
01:07:25,880 --> 01:07:29,620
et malloc nous donne ce nombre d'octets d'espace sur le tas.

1088
01:07:29,620 --> 01:07:32,890
Donc dans ce cas, nous avons créé un espace suffisant pour 3 entiers,

1089
01:07:32,890 --> 01:07:36,830
et le tas est là-haut, c'est pourquoi je l'ai dessiné plus haut.

1090
01:07:36,830 --> 01:07:42,900
Une fois que nous aurons terminé, nous reviendrons ici, il vous suffit besoin de 3 ints de retour,

1091
01:07:42,900 --> 01:07:47,000
et il renvoie l'adresse, dans ce cas, plus que la mémoire où est.

1092
01:07:47,000 --> 01:07:51,250
Et nous avons mis pointeur = interrupteur, et là-haut, nous avons juste un autre pointeur.

1093
01:07:51,250 --> 01:07:54,550
Mais qu'est-ce que renvoie la fonction sont empilées et disparaît.

1094
01:07:54,550 --> 01:07:59,250
Donc température disparaît, mais nous maintenons l'adresse de l'endroit où

1095
01:07:59,250 --> 01:08:01,850
ces 3 entiers sont à l'intérieur du secteur.

1096
01:08:01,850 --> 01:08:06,180
Donc, dans cet ensemble, les pointeurs ont une portée limitée localement pour le cadre empilés,

1097
01:08:06,180 --> 01:08:09,860
mais la mémoire à laquelle ils se réfèrent est dans le tas.

1098
01:08:09,860 --> 01:08:12,190
>> Est-ce logique?

1099
01:08:12,190 --> 01:08:14,960
[Étudiants] Pourriez-vous répéter? >> [Joseph] Oui.

1100
01:08:14,960 --> 01:08:20,270
Donc, si je reviens un peu, vous verrez que temporaire alloué

1101
01:08:20,270 --> 01:08:23,500
de la mémoire sur le tas là-haut.

1102
01:08:23,500 --> 01:08:28,680
Alors, quand cette fonction, giveMeThreeInts retours, cette pile ici va disparaître.

1103
01:08:28,680 --> 01:08:35,819
Et avec elle l'une des variables, dans ce cas, ce pointeur qui a été alloué dans le châssis empilés.

1104
01:08:35,819 --> 01:08:39,649
Qui va disparaître, mais depuis notre retour temporaire

1105
01:08:39,649 --> 01:08:46,330
et nous avons mis pointeur = temp, le pointeur va maintenant pointer le même mémoire de lieu d'installation temporaire a été.

1106
01:08:46,330 --> 01:08:50,370
Alors maintenant, même si nous perdons temporaire, ce pointeur local,

1107
01:08:50,370 --> 01:08:59,109
nous avons toujours conserver l'adresse mémoire de ce qu'il était orienté vers l'intérieur de ce pointeur variable.

1108
01:08:59,109 --> 01:09:03,740
Des questions? Cela peut être un peu déroutant si un sujet vous n'êtes pas allé au-dessus de la section.

1109
01:09:03,740 --> 01:09:09,240
Nous pouvons, votre carte de TF va certainement aller au-dessus et bien sûr, nous pouvons répondre à des questions

1110
01:09:09,240 --> 01:09:11,500
à la fin de la session d'examen pour cela.

1111
01:09:11,500 --> 01:09:14,220
Mais c'est en quelque sorte d'un sujet complexe, et je n'ai plus d'exemples qui vont se présenter

1112
01:09:14,220 --> 01:09:18,790
qui aidera à clarifier ce que sont en réalité des pointeurs.

1113
01:09:18,790 --> 01:09:22,500
>> Dans ce cas, les pointeurs sont équivalentes aux tableaux,

1114
01:09:22,500 --> 01:09:25,229
si je peux utiliser ce pointeur comme la même chose comme un tableau int.

1115
01:09:25,229 --> 01:09:29,840
Donc, je suis d'indexation en 0, et en changeant le premier entier à 1,

1116
01:09:29,840 --> 01:09:39,689
changer le nombre entier de 2 secondes, et le troisième nombre entier de 3.

1117
01:09:39,689 --> 01:09:44,210
Donc plus sur les pointeurs. Eh bien, rappelez-Binky.

1118
01:09:44,210 --> 01:09:48,319
Dans ce cas, nous avons prévu un pointeur, ou nous avons déclaré un pointeur,

1119
01:09:48,319 --> 01:09:52,760
mais au début, quand je vient de déclarer un pointeur, ce n'est pas pointer vers n'importe quelle destination dans la mémoire.

1120
01:09:52,760 --> 01:09:54,930
C'est seulement à l'intérieur des valeurs parasites de celui-ci.

1121
01:09:54,930 --> 01:09:56,470
Donc, je n'ai aucune idée où ce pointeur pointe.

1122
01:09:56,470 --> 01:10:01,630
Il possède une adresse qui est juste remplie avec des 0 et des 1, où il a été initialement déclarée.

1123
01:10:01,630 --> 01:10:04,810
Je ne peux pas faire n'importe quoi avec ce que j'appelle malloc sur elle

1124
01:10:04,810 --> 01:10:08,390
et puis il me donne un peu d'espace sur le tas où je peux mettre des valeurs à l'intérieur.

1125
01:10:08,390 --> 01:10:11,980
Là encore, je ne sais pas ce qu'il ya dedans de cette mémoire.

1126
01:10:11,980 --> 01:10:16,780
Donc la première chose que j'ai à faire est de vérifier si le système avait assez de mémoire

1127
01:10:16,780 --> 01:10:20,850
de me rendre entier 1, en premier lieu, et c'est pourquoi je fais ce contrôle.

1128
01:10:20,850 --> 01:10:25,020
Si le pointeur est nul, ce qui signifie qu'il n'a pas assez d'espace ou qu'une autre erreur s'est produite,

1129
01:10:25,020 --> 01:10:26,320
donc je devrais quitter mon programme d'études.

1130
01:10:26,320 --> 01:10:29,400
 Mais si c'était le cas réussir, maintenant je peux utiliser ce pointeur

1131
01:10:29,400 --> 01:10:35,020
et ce pointeur * fait est qu'il suit, où l'adresse est

1132
01:10:35,020 --> 01:10:38,480
à l'endroit où cette valeur est, et il définit le égal à 1.

1133
01:10:38,480 --> 01:10:41,850
Donc, ici, nous vérifions si la mémoire existé.

1134
01:10:41,850 --> 01:10:45,380
>> Une fois que vous savez qu'il existe, vous pouvez mettre dans l'

1135
01:10:45,380 --> 01:10:50,460
la valeur que vous voulez mettre dedans, dans ce cas 1.

1136
01:10:50,460 --> 01:10:53,060
Une fois que nous aurons fini avec elle, vous avez besoin de libérer ce pointeur

1137
01:10:53,060 --> 01:10:57,160
car nous avons besoin de revenir au système que la mémoire que vous avez demandé en premier lieu.

1138
01:10:57,160 --> 01:10:59,690
Parce que l'ordinateur ne sais pas quand nous aurons fini avec elle.

1139
01:10:59,690 --> 01:11:02,510
Dans ce cas, nous sommes explicitement dit, d'accord, nous en avons fini avec cette mémoire.

1140
01:11:02,510 --> 01:11:10,780
Si un autre processus dont il a besoin, un autre programme dont il a besoin, n'hésitez pas à aller de l'avant et de le prendre.

1141
01:11:10,780 --> 01:11:15,110
Ce que nous pouvons faire, c'est aussi nous pouvons simplement obtenir l'adresse des variables locales sur le plateau.

1142
01:11:15,110 --> 01:11:19,080
Donc x int est à l'intérieur du cadre empilés de main.

1143
01:11:19,080 --> 01:11:23,060
Et quand on utilise cette esperluette, ce et l'opérateur, ce qu'il fait est

1144
01:11:23,060 --> 01:11:27,310
il prend x, et x est à seulement quelques données en mémoire, mais il a une adresse.

1145
01:11:27,310 --> 01:11:33,790
Il est situé quelque part. Donc, en appelant & x, ce que cela fait est qu'il nous donne l'adresse de x.

1146
01:11:33,790 --> 01:11:38,430
En faisant cela, nous faisons le point pointeur à l'endroit où x est dans la mémoire.

1147
01:11:38,430 --> 01:11:41,710
Maintenant, nous n'avons tout simplement quelque chose comme * x, nous allons obtenir 5 arrière.

1148
01:11:41,710 --> 01:11:43,820
L'étoile est appelée, elle déréférencement.

1149
01:11:43,820 --> 01:11:46,640
Vous suivez l'adresse et vous obtenez la valeur de celui-ci qui y sont stockées.

1150
01:11:51,000 --> 01:11:53,310
>> Des questions? Oui?

1151
01:11:53,310 --> 01:11:56,500
[Étudiants] Si vous ne faites pas la chose la 3-pointu, at-il encore compiler?

1152
01:11:56,500 --> 01:11:59,490
Oui. Si vous ne faites pas la chose la 3-pointeur, il va continuer à compiler,

1153
01:11:59,490 --> 01:12:02,720
mais je vais vous montrer ce qui se passe en une seconde, et sans cela,

1154
01:12:02,720 --> 01:12:04,860
c'est ce que nous appelons une fuite de mémoire. Vous ne donnez pas le système

1155
01:12:04,860 --> 01:12:07,850
sauvegarder sa mémoire, donc après un certain temps le programme va s'accumuler

1156
01:12:07,850 --> 01:12:10,940
mémoire que ce n'est pas l'aide, et rien d'autre ne peut l'utiliser.

1157
01:12:10,940 --> 01:12:15,750
Si vous avez jamais vu Firefox avec 1,5 millions de kilo-octets sur votre ordinateur,

1158
01:12:15,750 --> 01:12:17,840
dans le gestionnaire de tâches, c'est ce qui se passe.

1159
01:12:17,840 --> 01:12:20,760
Vous avez une fuite de mémoire dans le programme qu'ils ne sont pas de la manipulation.

1160
01:12:23,080 --> 01:12:26,240
Alors, comment pointeur arithmétique travail?

1161
01:12:26,240 --> 01:12:29,480
Eh bien, l'arithmétique des pointeurs est une sorte d'indexation comme dans un tableau.

1162
01:12:29,480 --> 01:12:36,370
Dans ce cas, j'ai un pointeur, et ce que je fais, c'est que faire pointer pointeur vers le premier élément

1163
01:12:36,370 --> 01:12:42,100
de ce tableau de 3 entiers que j'ai attribués.

1164
01:12:42,100 --> 01:12:46,670
Alors maintenant, ce que je fais, star-pointeur change juste le premier élément de la liste.

1165
01:12:46,670 --> 01:12:49,140
Star Pointer +1 points plus ici.

1166
01:12:49,140 --> 01:12:53,140
Donc pointeur est ici, pointeur +1 est ici, pointeur +2 est ici.

1167
01:12:53,140 --> 01:12:56,610
>> Il suffit donc d'ajouter 1 est la même chose que se déplacer le long de cette baie.

1168
01:12:56,610 --> 01:12:59,880
Ce que nous faisons est, quand nous faisons une pointeur vous obtenez l'adresse par ici,

1169
01:12:59,880 --> 01:13:04,180
et afin d'obtenir la valeur ici, vous avez mis une étoile à partir de l'expression entière

1170
01:13:04,180 --> 01:13:05,990
pour le déréférencez.

1171
01:13:05,990 --> 01:13:09,940
Donc, dans ce cas, je vais régler le premier emplacement dans ce tableau à 1,

1172
01:13:09,940 --> 01:13:13,970
second emplacement à 2, et 3 de troisième emplacement.

1173
01:13:13,970 --> 01:13:18,180
Alors qu'est-ce que je fais ici, c'est que je l'impression de notre pointeur +1,

1174
01:13:18,180 --> 01:13:19,970
ce qui me donne juste 2.

1175
01:13:19,970 --> 01:13:23,650
Maintenant, je suis d'incrémentation du pointeur, afin pointeur est égale pointeur +1,

1176
01:13:23,650 --> 01:13:26,780
qui se déplace vers l'avant.

1177
01:13:26,780 --> 01:13:30,810
Et maintenant si je imprimer pointeur +1, +1 est maintenant pointeur 3,

1178
01:13:30,810 --> 01:13:33,990
qui dans ce cas imprime 3.

1179
01:13:33,990 --> 01:13:36,560
Et pour quelque chose de gratuit, le pointeur que je lui donne

1180
01:13:36,560 --> 01:13:40,540
doit être pointée vers le début du tableau que je viens de rentrer d'malloc.

1181
01:13:40,540 --> 01:13:43,430
Donc, dans ce cas, si je devais appeler 3 ici, ce ne serait pas juste,

1182
01:13:43,430 --> 01:13:45,070
parce que c'est dans le milieu du tableau.

1183
01:13:45,070 --> 01:13:48,820
Je dois soustraire pour se rendre à l'emplacement d'origine

1184
01:13:48,820 --> 01:13:50,420
place initiale du prénom avant que je puisse le libérer.

1185
01:13:56,300 --> 01:13:58,450
Donc, voici un exemple plus complet.

1186
01:13:58,450 --> 01:14:03,360
Dans ce cas, nous allouons 7 caractères dans un tableau de caractères.

1187
01:14:03,360 --> 01:14:06,480
>> Et dans ce cas, ce que nous faisons, c'est que nous bouclant sur les 6 premiers d'entre eux,

1188
01:14:06,480 --> 01:14:09,900
et nous leur mise à Z.

1189
01:14:09,900 --> 01:14:13,350
Ainsi, par int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Donc, je vais pointeur + vient de nous donner, dans ce cas,

1191
01:14:16,220 --> 01:14:20,860
pointeur, le pointeur +1, pointeur +2, le pointeur +3, et ainsi de suite, et ainsi de suite dans la boucle.

1192
01:14:20,860 --> 01:14:24,040
Qu'est-ce que ça va faire, c'est se que l'adresse, il déréférence pour obtenir la valeur,

1193
01:14:24,040 --> 01:14:27,440
et les changements que la valeur d'un Z.

1194
01:14:27,440 --> 01:14:30,350
Puis, à la fin n'oubliez pas que c'est une chaîne, pas vrai?

1195
01:14:30,350 --> 01:14:33,560
Toutes les chaînes doivent se terminer par le caractère nul final.

1196
01:14:33,560 --> 01:14:38,620
Donc, ce que je fais est en pointeur 6 Je mis le caractère nul de terminaison po

1197
01:14:38,620 --> 01:14:43,980
Et maintenant que je suis fondamentalement faire ici est la mise en œuvre d'une chaîne de printf, non?

1198
01:14:43,980 --> 01:14:46,190
>> Alors, quand est-ce printf maintenant quand il est arrivé à la fin d'une chaîne?

1199
01:14:46,190 --> 01:14:48,230
Quand il frappe le caractère nul final.

1200
01:14:48,230 --> 01:14:52,030
Donc, dans ce cas, mes pointeur d'origine au début de ce tableau.

1201
01:14:52,030 --> 01:14:56,410
Je imprimer sur le premier caractère. Je le déplacer plus d'un.

1202
01:14:56,410 --> 01:14:58,420
Je imprimer ce caractère sur. Je le déplacez sur.

1203
01:14:58,420 --> 01:15:02,180
Et je continue ainsi jusqu'à ce que j'arrive à la fin.

1204
01:15:02,180 --> 01:15:07,750
Et maintenant le pointeur de fin * va déréférencer cela et le caractère nul final retour.

1205
01:15:07,750 --> 01:15:11,780
Et donc ma boucle while s'exécute uniquement lorsque cette valeur n'est pas le caractère nul final.

1206
01:15:11,780 --> 01:15:13,770
Donc, maintenant je sors de sortir de cette boucle.

1207
01:15:18,780 --> 01:15:21,180
Et si je soustrais 6 de ce pointeur,

1208
01:15:21,180 --> 01:15:22,860
Je retourne tout le chemin vers le début.

1209
01:15:22,860 --> 01:15:27,880
Rappelez-vous, je fais cela parce que je dois aller au début afin de le libérer.

1210
01:15:27,880 --> 01:15:30,270
>> Donc, je sais que c'était beaucoup. Y at-il des questions?

1211
01:15:30,270 --> 01:15:31,870
S'il vous plaît, oui?

1212
01:15:31,870 --> 01:15:36,610
[Inintelligible question des étudiants]

1213
01:15:36,610 --> 01:15:38,190
Pouvez-vous dire que plus fort? Désolé.

1214
01:15:38,190 --> 01:15:44,140
[Étudiants] Sur la dernière diapositive juste avant de libérer le pointeur,

1215
01:15:44,140 --> 01:15:47,300
Où étiez-vous réellement changer la valeur du pointeur?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Donc, ici. >> [Étudiants] Oh, d'accord.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Donc, j'ai un pointeur de moins en moins, à droite,

1218
01:15:51,890 --> 01:15:54,140
qui déplace l'arrière d'une chose, et puis je l'ai libérer,

1219
01:15:54,140 --> 01:15:57,000
parce que ce pointeur est à signaler le début de la matrice.

1220
01:15:57,000 --> 01:16:00,420
[Étudiants] Mais ce ne serait pas nécessaire si vous aviez cessé après cette ligne.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Donc, si je m'étais arrêté après cela, ce serait considéré comme une fuite de mémoire,

1222
01:16:03,130 --> 01:16:04,810
parce que je n'ai pas couru la liberté.

1223
01:16:04,810 --> 01:16:11,290
[Étudiants] je [inintelligible], après les trois premières lignes où vous avez eu pointeur +1 [inintelligible].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-huh. Alors, quelle est la question là-bas?

1225
01:16:13,140 --> 01:16:14,780
Désolé. Non, non. Allez, allez, s'il vous plaît.

1226
01:16:14,780 --> 01:16:16,870
[Étudiants] Donc, vous ne changez pas la valeur de pointeurs.

1227
01:16:16,870 --> 01:16:19,130
Vous n'auriez pas dû faire pointeur minus.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Oui, exactement.

1229
01:16:19,730 --> 01:16:21,890
Donc, quand je fais pointeur pointeur +1 et +2,

1230
01:16:21,890 --> 01:16:24,410
Je ne fais pointeur est égale pointeur +1.

1231
01:16:24,410 --> 01:16:27,260
Ainsi, le pointeur reste simplement faire remarquer au début du tableau.

1232
01:16:27,260 --> 01:16:31,460
C'est seulement quand je fais plus plus qu'il définit la valeur à l'intérieur du pointeur,

1233
01:16:31,460 --> 01:16:33,550
qu'il se déplace le long de cette réalité.

1234
01:16:36,860 --> 01:16:37,780
Très bien.

1235
01:16:40,550 --> 01:16:42,030
Plus de questions?

1236
01:16:44,680 --> 01:16:47,790
>> Encore une fois, si cela est une sorte de majorité, ce sera couvert en session.

1237
01:16:47,790 --> 01:16:50,710
Demandez à votre adjoint à l'enseignement à ce sujet, et nous pouvons répondre à des questions à la fin.

1238
01:16:53,510 --> 01:16:56,600
Et généralement, nous n'aimons pas faire cette chose moins.

1239
01:16:56,600 --> 01:16:59,760
Cela doit exiger de moi garder une trace de tout ce que j'ai décalé dans le tableau.

1240
01:16:59,760 --> 01:17:04,520
Donc, en général, c'est juste pour vous expliquer comment fonctionne l'arithmétique des pointeurs.

1241
01:17:04,520 --> 01:17:07,970
Mais ce que nous avons l'habitude j'aime faire, c'est que nous aimons pour créer une copie du pointeur,

1242
01:17:07,970 --> 01:17:11,640
puis nous allons utiliser cette copie lorsque nous déplacer dans la chaîne.

1243
01:17:11,640 --> 01:17:14,660
Donc, dans ces cas, vous utilisez la copie d'imprimer la totalité de la chaîne,

1244
01:17:14,660 --> 01:17:19,040
mais nous n'avons pas à faire comme pointeur moins 6 ou de garder une trace de combien nous avons emménagé dans ce domaine,

1245
01:17:19,040 --> 01:17:22,700
juste parce que nous savons que notre point de départ est toujours indiqué au début de la liste

1246
01:17:22,700 --> 01:17:25,340
et tout ce que nous avons modifié cette copie.

1247
01:17:25,340 --> 01:17:28,250
Donc, en général, modifier des copies de votre pointeur original.

1248
01:17:28,250 --> 01:17:32,350
N'essayez pas de régler de même - ne modifie exemplaires originaux.

1249
01:17:32,350 --> 01:17:35,290
Tenter de modifier seules les copies de l'original.

1250
01:17:41,540 --> 01:17:44,870
Donc, vous remarquez quand on passe la corde dans printf

1251
01:17:44,870 --> 01:17:48,990
vous n'avez pas besoin de mettre une étoile en face d'elle, comme nous l'avons fait avec tous les autres déréférence, non?

1252
01:17:48,990 --> 01:17:54,180
Donc, si vous imprimez la totalité de la chaîne s% s'attend à une adresse,

1253
01:17:54,180 --> 01:17:57,610
et dans ce cas un pointeur ou dans ce cas comme un tableau de caractères.

1254
01:17:57,610 --> 01:18:00,330
>> Caractères, char * s, et les tableaux sont la même chose.

1255
01:18:00,330 --> 01:18:03,690
Pointer est de personnages, et des tableaux de caractères sont la même chose.

1256
01:18:03,690 --> 01:18:05,720
Et donc, tout ce que nous avons à faire est de passer le pointeur.

1257
01:18:05,720 --> 01:18:08,150
Nous n'avons pas à passer de la même pointeur * ou quelque chose comme ça.

1258
01:18:13,110 --> 01:18:14,930
Ainsi, les tableaux et les pointeurs sont la même chose.

1259
01:18:14,930 --> 01:18:19,160
Quand vous faites quelque chose comme x [y] par ici pour un tableau,

1260
01:18:19,160 --> 01:18:21,960
ce qu'il fait sous le capot, c'est que c'est dit, d'accord, c'est un tableau de caractères,

1261
01:18:21,960 --> 01:18:23,690
c'est donc un pointeur.

1262
01:18:23,690 --> 01:18:26,510
Et si x est la même chose,

1263
01:18:26,510 --> 01:18:28,650
et si ce qu'il fait est qu'il ajoute y à x,

1264
01:18:28,650 --> 01:18:31,820
qui est la même chose que d'avancer dans la mémoire tant que ça.

1265
01:18:31,820 --> 01:18:34,930
Et maintenant, x + y nous donne une sorte d'adresse,

1266
01:18:34,930 --> 01:18:37,570
et nous déréférencez l'adresse ou suivez la flèche

1267
01:18:37,570 --> 01:18:41,640
à l'endroit où cet emplacement en mémoire est et nous obtenons la valeur de cet emplacement dans la mémoire.

1268
01:18:41,640 --> 01:18:43,720
Donc, si ces deux sont exactement la même chose.

1269
01:18:43,720 --> 01:18:45,840
C'est juste un sucre syntaxique.

1270
01:18:45,840 --> 01:18:48,090
Ils font la même chose. Ils sont juste différents syntactics un pour l'autre.

1271
01:18:51,500 --> 01:18:57,590
>> Alors, qu'est-ce qui peut mal tourner avec des pointeurs? Comme, beaucoup. D'accord. Ainsi, les mauvaises choses.

1272
01:18:57,590 --> 01:19:02,410
Certaines mauvaises choses que vous pouvez faire ne sont pas de vérifier si votre appel malloc retourne null, non?

1273
01:19:02,410 --> 01:19:06,560
Dans ce cas, je demande au système de me donner - ce qui est ce numéro?

1274
01:19:06,560 --> 01:19:11,200
Comme 2 milliards de fois 4, parce que la taille d'un entier de 4 octets.

1275
01:19:11,200 --> 01:19:13,810
Je suis en train de demander comme 8 milliards d'octets.

1276
01:19:13,810 --> 01:19:17,270
Bien sûr, mon ordinateur ne va pas être en mesure de me donner ce retour de mémoire.

1277
01:19:17,270 --> 01:19:20,960
Et nous n'avons pas vérifié si cela est nul, donc quand nous essayons de le déréférencer là-bas -

1278
01:19:20,960 --> 01:19:24,270
suivez la flèche à l'endroit où il va - nous n'avons pas cette mémoire.

1279
01:19:24,270 --> 01:19:27,150
C'est ce que nous appelons le déréférencement d'un pointeur NULL.

1280
01:19:27,150 --> 01:19:29,710
Et cela provoque une erreur de segmentation essentiellement vous.

1281
01:19:29,710 --> 01:19:31,790
C'est l'une des façons dont vous pouvez segfault.

1282
01:19:34,090 --> 01:19:38,090
D'autres mauvaises choses que vous pouvez faire - mais bon.

1283
01:19:38,090 --> 01:19:40,650
Qui a été déréférencement d'un pointeur NULL. D'accord.

1284
01:19:40,650 --> 01:19:45,160
D'autres mauvaises choses - ainsi, pour résoudre ce problème que vous venez de mettre un frein à y

1285
01:19:45,160 --> 01:19:46,980
qui vérifie si le pointeur est nul

1286
01:19:46,980 --> 01:19:51,000
et quitter le programme si il arrive que malloc retourne un pointeur nul.

1287
01:19:55,110 --> 01:19:59,850
C'est la bande dessinée xkcd. Les gens le comprends maintenant. En quelque sorte.

1288
01:20:06,120 --> 01:20:09,350
>> Ainsi, la mémoire. Et je suis allé à ce sujet.

1289
01:20:09,350 --> 01:20:12,000
Nous lançons un appel malloc dans une boucle, mais à chaque fois que nous appelons malloc

1290
01:20:12,000 --> 01:20:14,370
nous perdons la trace de où ce pointeur pointe vers,

1291
01:20:14,370 --> 01:20:15,750
parce que nous le démolir.

1292
01:20:15,750 --> 01:20:18,410
Ainsi, le premier appel à malloc me donne la mémoire ici.

1293
01:20:18,410 --> 01:20:19,990
Mes pointeurs de pointeurs à cela.

1294
01:20:19,990 --> 01:20:23,020
Maintenant, je n'ai pas le libérer, alors maintenant je appeler malloc nouveau.

1295
01:20:23,020 --> 01:20:26,070
Maintenant, il fait ici. Maintenant, ma mémoire est orienté par ici.

1296
01:20:26,070 --> 01:20:27,640
Pointant ici. Pointant ici.

1297
01:20:27,640 --> 01:20:31,820
Mais j'ai perdu la trace des adresses de toute la mémoire par ici que je allouée.

1298
01:20:31,820 --> 01:20:35,100
Et maintenant, je n'ai pas de référence à plus d'eux.

1299
01:20:35,100 --> 01:20:37,230
Donc, je ne peux pas les libérer en dehors de cette boucle.

1300
01:20:37,230 --> 01:20:39,390
Et donc, afin de réparer quelque chose comme ça,

1301
01:20:39,390 --> 01:20:42,250
si vous oubliez de libérer de la mémoire et vous obtenez cette fuite de mémoire,

1302
01:20:42,250 --> 01:20:45,810
Vous devez libérer de la mémoire à l'intérieur de cette boucle une fois que vous avez terminé avec lui.

1303
01:20:45,810 --> 01:20:51,400
Eh bien, c'est ce qui arrive. Je sais que beaucoup d'entre vous déteste ça.

1304
01:20:51,400 --> 01:20:55,270
Mais maintenant - yay! Vous obtenez comme 44.000 kilo-octets.

1305
01:20:55,270 --> 01:20:57,110
Donc, vous le libérer à la fin de la boucle,

1306
01:20:57,110 --> 01:20:59,770
et qui va tout simplement libérer la mémoire à chaque fois.

1307
01:20:59,770 --> 01:21:03,620
Essentiellement, le programme n'a pas de fuite de mémoire plus.

1308
01:21:03,620 --> 01:21:08,150
>> Et maintenant, quelque chose que vous pouvez faire est de libérer de la mémoire que vous avez demandé à deux reprises.

1309
01:21:08,150 --> 01:21:11,060
Dans ce cas, quelque chose malloc, vous changez sa valeur.

1310
01:21:11,060 --> 01:21:13,140
Vous le libérer une fois parce que vous avez dit que vous aviez fini avec elle.

1311
01:21:13,140 --> 01:21:14,940
Mais ensuite on libère à nouveau.

1312
01:21:14,940 --> 01:21:16,730
C'est quelque chose qui est assez mauvais.

1313
01:21:16,730 --> 01:21:18,820
Il ne va pas d'abord une erreur de segmentation,

1314
01:21:18,820 --> 01:21:23,350
mais après un moment ce que ce ne soit à double libération de ce corrompt la structure de votre tas,

1315
01:21:23,350 --> 01:21:27,200
et vous en apprendrez un peu plus à ce sujet si vous choisissez de prendre une classe comme CS61.

1316
01:21:27,200 --> 01:21:30,000
Mais, essentiellement, après un certain temps que votre ordinateur va se confondre

1317
01:21:30,000 --> 01:21:33,010
sur ce que sont les emplacements mémoire où et où il est stocké -

1318
01:21:33,010 --> 01:21:34,800
où les données sont stockées dans la mémoire.

1319
01:21:34,800 --> 01:21:38,080
Et ainsi de libérer un pointeur est deux fois une mauvaise chose que vous ne voulez pas faire.

1320
01:21:38,080 --> 01:21:41,600
>> D'autres choses qui peuvent mal se passer n'est pas en utilisant sizeof.

1321
01:21:41,600 --> 01:21:44,460
Donc, dans ce cas vous malloc 8 octets,

1322
01:21:44,460 --> 01:21:46,700
et c'est la même chose que deux entiers, non?

1323
01:21:46,700 --> 01:21:49,580
Donc, c'est tout à fait sûr, mais est-il?

1324
01:21:49,580 --> 01:21:52,160
Eh bien, comme Lucas a parlé sur différentes architectures,

1325
01:21:52,160 --> 01:21:54,220
les entiers sont de longueurs différentes.

1326
01:21:54,220 --> 01:21:57,970
Ainsi, sur l'appareil que vous utilisez, les entiers sont sur 4 octets,

1327
01:21:57,970 --> 01:22:02,370
mais sur un autre système, ils pourraient être de 8 octets ou ils pourraient être de 16 octets.

1328
01:22:02,370 --> 01:22:05,680
Donc, si je viens d'utiliser ce nombre ici,

1329
01:22:05,680 --> 01:22:07,310
ce programme pourrait fonctionner sur l'appareil,

1330
01:22:07,310 --> 01:22:10,360
mais il ne va pas allouer suffisamment de mémoire sur un autre système.

1331
01:22:10,360 --> 01:22:14,020
Dans ce cas, c'est ce que l'opérateur sizeof est utilisé pour.

1332
01:22:14,020 --> 01:22:16,880
Lorsque nous appelons sizeof (int), ce que ne fait

1333
01:22:16,880 --> 01:22:21,910
 il nous donne la taille d'un entier sur le système que le programme est en cours d'exécution.

1334
01:22:21,910 --> 01:22:25,490
Donc, dans ce cas, sizeof (int) retourne quelque chose comme 4 sur l'appareil,

1335
01:22:25,490 --> 01:22:29,980
et maintenant cette volonté 4 * 2, qui est de 8,

1336
01:22:29,980 --> 01:22:32,330
qui est juste la quantité d'espace nécessaire pour deux entiers.

1337
01:22:32,330 --> 01:22:36,710
Sur un autre système, si un int est comme 16 octets ou 8 octets,

1338
01:22:36,710 --> 01:22:39,380
il va tout simplement de revenir suffisamment d'octets pour stocker ce montant.

1339
01:22:41,830 --> 01:22:45,310
>> Et enfin, les structures.

1340
01:22:45,310 --> 01:22:48,340
Donc, si vous voulez stocker un conseil sudoku en mémoire, comment pourrions-nous le faire?

1341
01:22:48,340 --> 01:22:51,570
Vous pourriez penser comme une variable pour la première chose,

1342
01:22:51,570 --> 01:22:53,820
une variable pour la deuxième chose, une variable pour la troisième chose,

1343
01:22:53,820 --> 01:22:56,420
une variable pour le quatrième chose - mal, non?

1344
01:22:56,420 --> 01:23:00,750
Ainsi, une amélioration que vous pouvez faire sur le dessus de cela est de faire un 9 x 9.

1345
01:23:00,750 --> 01:23:04,480
C'est très bien, mais que faire si vous voulez associer d'autres choses avec le conseil sudoku

1346
01:23:04,480 --> 01:23:06,490
comme ce que la difficulté du conseil d'administration est,

1347
01:23:06,490 --> 01:23:11,740
ou, par exemple, ce que votre score est, ou combien de temps il vous a fallu pour résoudre ce forum?

1348
01:23:11,740 --> 01:23:14,970
Eh bien, qu'est-ce que vous pouvez faire est que vous pouvez créer une structure.

1349
01:23:14,970 --> 01:23:18,910
Ce que je veux dire, c'est fondamentalement je définir cette structure par ici,

1350
01:23:18,910 --> 01:23:23,230
et je définir un conseil sudoku qui consiste en une planche qui est de 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> Et ce qu'il a il a des pointeurs vers le nom du niveau.

1352
01:23:26,650 --> 01:23:30,730
Il a aussi x et y, qui sont les coordonnées de l'endroit où je suis maintenant.

1353
01:23:30,730 --> 01:23:35,980
Il a également passé du temps [inintelligible], et il a le nombre total de mouvements que j'ai entrés jusqu'ici.

1354
01:23:35,980 --> 01:23:40,010
Et dans ce cas, je peux regrouper tout un tas de données dans une seule structure

1355
01:23:40,010 --> 01:23:42,790
au lieu de l'avoir comme voler autour de la même différentes variables

1356
01:23:42,790 --> 01:23:44,540
que je ne peux pas vraiment suivre.

1357
01:23:44,540 --> 01:23:49,720
Et cela nous permet d'avoir juste la syntaxe agréable pour le référencement sorte de choses différentes à l'intérieur de cette structure.

1358
01:23:49,720 --> 01:23:53,430
Je peux juste faire board.board, et je reçois le conseil sudoku en arrière.

1359
01:23:53,430 --> 01:23:56,320
Board.level, je reçois combien il est difficile.

1360
01:23:56,320 --> 01:24:00,540
Board.x et board.y me donner les coordonnées de l'endroit où je pourrais être dans le conseil d'administration.

1361
01:24:00,540 --> 01:24:04,730
Et je suis donc accéder à ce que nous appelons les champs de la struct.

1362
01:24:04,730 --> 01:24:08,840
Ceci définit sudokuBoard, qui est un type que j'ai.

1363
01:24:08,840 --> 01:24:14,800
Et maintenant nous sommes ici. J'ai une variable appelée «conseil» de sudokuBoard type.

1364
01:24:14,800 --> 01:24:18,820
Et alors maintenant je peux accéder à tous les champs qui composent cette structure par ici.

1365
01:24:20,830 --> 01:24:22,450
>> Une question sur votre structs? Oui?

1366
01:24:22,450 --> 01:24:25,890
[Étudiants] Pour int x, y, vous avez déclaré à la fois sur une seule ligne? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Étudiants] Alors, pourriez-vous faire avec chacun d'eux?

1368
01:24:27,400 --> 01:24:31,200
Comme dans x, y virgule fois que le total?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Oui, vous pouvez certainement le faire, mais la raison pour laquelle j'ai mis x et y sur la même ligne -

1370
01:24:34,460 --> 01:24:36,330
et la question est pourquoi pouvons-nous simplement faire sur la même ligne?

1371
01:24:36,330 --> 01:24:38,600
Pourquoi ne pas simplement mettre tous ces sur la même ligne est

1372
01:24:38,600 --> 01:24:42,090
x et y sont liées les unes aux autres,

1373
01:24:42,090 --> 01:24:44,780
et ce n'est qu'un style plus correct, en un sens,

1374
01:24:44,780 --> 01:24:46,600
car il regroupe à deux choses sur la même ligne

1375
01:24:46,600 --> 01:24:49,340
ce genre comme de se rapporter à la même chose.

1376
01:24:49,340 --> 01:24:51,440
Et je viens de diviser celles-ci en dehors. C'est juste une chose style.

1377
01:24:51,440 --> 01:24:53,720
Il est fonctionnellement aucune différence.

1378
01:24:58,150 --> 01:24:59,270
D'autres questions sur structs?

1379
01:25:03,030 --> 01:25:06,620
Vous pouvez définir un Pokédex avec une struct.

1380
01:25:06,620 --> 01:25:11,720
Un Pokémon possède un numéro et il a une lettre, un propriétaire, un type.

1381
01:25:11,720 --> 01:25:16,990
Et puis, si vous avez un tableau de Pokémon, vous pouvez faire un Pokédex, non?

1382
01:25:16,990 --> 01:25:20,810
Ok, cool. Ainsi, les questions relatives structures. Ceux sont liés aux structures.

1383
01:25:20,810 --> 01:25:25,270
>> Enfin, GDB. Qu'est-ce que GDB vous laisser faire? Il vous permet de déboguer votre programme.

1384
01:25:25,270 --> 01:25:27,650
Et si vous n'avez pas utilisé GDB, je recommande à regarder le court

1385
01:25:27,650 --> 01:25:31,250
et aller juste au-dessus de ce que GDB est de savoir comment vous travaillez avec lui, comment vous pourriez l'utiliser,

1386
01:25:31,250 --> 01:25:32,900
et le tester sur un programme.

1387
01:25:32,900 --> 01:25:37,400
Et donc ce qui vous permet de faire GDB est-il permet de mettre en pause la [inaudible] de votre programme

1388
01:25:37,400 --> 01:25:38,920
et une ligne de pratique.

1389
01:25:38,920 --> 01:25:42,600
Par exemple, je veux suspendre l'exécution à la ligne 3 comme de mon programme,

1390
01:25:42,600 --> 01:25:46,010
et pendant que je suis à la ligne 3 je peux imprimer toutes les valeurs qui sont là-bas.

1391
01:25:46,010 --> 01:25:49,710
Et si ce que nous appelons comme une pause dans une ligne

1392
01:25:49,710 --> 01:25:52,350
est nous appelons cela de mettre un point d'arrêt sur cette ligne

1393
01:25:52,350 --> 01:25:55,920
et alors nous pouvons imprimer les variables à l'état du programme à ce moment-là.

1394
01:25:55,920 --> 01:25:58,990
>> Nous pouvons alors à partir de là passer en revue le programme ligne par ligne.

1395
01:25:58,990 --> 01:26:03,200
Et puis nous pouvons regarder l'état de la pile à l'heure.

1396
01:26:03,200 --> 01:26:08,600
Et donc pour pouvoir utiliser GDB, ce que nous faisons est que nous appelons bruit sur le fichier C,

1397
01:26:08,600 --> 01:26:11,290
mais nous devons lui passer le drapeau ggdb-.

1398
01:26:11,290 --> 01:26:15,850
Et une fois que nous aurons terminé avec ce que nous venons de lancer gdb sur le fichier de sortie qui en résulte.

1399
01:26:15,850 --> 01:26:18,810
Et si vous avez un peu de masse comme du texte comme celui-ci,

1400
01:26:18,810 --> 01:26:21,990
mais vraiment tout ce que vous avez à faire est de taper des commandes au début.

1401
01:26:21,990 --> 01:26:24,250
Pause principale met un point d'arrêt à principal.

1402
01:26:24,250 --> 01:26:28,470
Liste des 400 énumère les lignes de code autour de la ligne 400.

1403
01:26:28,470 --> 01:26:31,410
Et dans ce cas il vous suffit de regarder autour et dire, oh,

1404
01:26:31,410 --> 01:26:34,360
Je veux mettre un point d'arrêt à la ligne 397, qui est de cette ligne,

1405
01:26:34,360 --> 01:26:37,170
puis votre programme s'exécute dans cette étape et il va se casser.

1406
01:26:37,170 --> 01:26:41,120
Ça va faire une pause là, et vous pouvez imprimer, par exemple, la valeur de basse ou haute.

1407
01:26:41,120 --> 01:26:46,410
Et donc il ya un tas de commandes que vous devez savoir,

1408
01:26:46,410 --> 01:26:48,660
et ce diaporama montera sur le site,

1409
01:26:48,660 --> 01:26:54,000
donc si vous voulez juste faire référence à celles-ci ou comme les mettre sur vos feuilles de triche, n'hésitez pas.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. C'était Jeu Revue 0, et nous allons rester dans les parages si vous avez des questions.

1411
01:27:00,650 --> 01:27:03,850
Très bien.

1412
01:27:03,850 --> 01:27:09,030
>>  [Applaudissements]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]