1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] Parlons un peu de tableaux.

2
00:00:09,360 --> 00:00:12,780
Alors, pourquoi aurions-nous jamais eu envie d'utiliser des tableaux?

3
00:00:12,780 --> 00:00:17,210
Eh bien, disons que vous avez un programme qui a besoin de stocker 5 cartes d'étudiant.

4
00:00:17,210 --> 00:00:21,270
Il pourrait sembler raisonnable d'avoir 5 variables séparées.

5
00:00:21,270 --> 00:00:24,240
Pour des raisons que nous verrons dans un instant, nous allons commencer à compter à partir de 0.

6
00:00:24,240 --> 00:00:30,700
Les variables que nous aurons sera id0 int, int id1, et ainsi de suite.

7
00:00:30,700 --> 00:00:34,870
Toute la logique que nous voulons réaliser sur une carte d'étudiant devront être copiées et collées

8
00:00:34,870 --> 00:00:36,870
pour chacune de ces cartes d'étudiant.

9
00:00:36,870 --> 00:00:39,710
Si nous voulons vérifier que les élèves se trouvent dans CS50,

10
00:00:39,710 --> 00:00:43,910
nous devons d'abord vérifier si id0 représente l'étudiant dans le cours.

11
00:00:43,910 --> 00:00:48,070
Puis faire la même chose pour l'élève suivant, nous aurons besoin de copier et coller le code id0

12
00:00:48,070 --> 00:00:54,430
et remplacer toutes les occurrences de id0 avec id1 et id2 ainsi de suite pour, 3 et 4.

13
00:00:54,430 --> 00:00:57,560
>> Dès que vous entendez ce que nous avons besoin de copier-coller,

14
00:00:57,560 --> 00:01:00,440
vous devriez commencer à penser qu'il ya une meilleure solution.

15
00:01:00,440 --> 00:01:05,360
Maintenant, si vous vous rendez compte que vous n'avez pas besoin de 5 cartes d'étudiant, mais plutôt 7?

16
00:01:05,360 --> 00:01:09,570
Vous devez retourner dans votre code source et d'ajouter dans un id5, un id6,

17
00:01:09,570 --> 00:01:14,260
et copier et coller la logique de vérifier si les identifiants appartiennent à la classe pour ces 2 nouveaux identifiants.

18
00:01:14,260 --> 00:01:19,600
Il n'y a rien qui relie tous ces identifiants ensemble, et il n'y a donc aucun moyen de demander

19
00:01:19,600 --> 00:01:22,040
le programme de le faire pour les ID 0 à 6.

20
00:01:22,040 --> 00:01:26,120
Eh bien maintenant vous vous rendez compte que vous avez 100 cartes d'étudiant.

21
00:01:26,120 --> 00:01:30,770
Ça commence à paraître moins qu'idéal à déclarer séparément besoin de chacun de ces identifiants,

22
00:01:30,770 --> 00:01:33,760
et copier et coller toute logique pour les nouvelles cartes d'identité.

23
00:01:33,760 --> 00:01:38,380
Mais peut-être que nous sommes déterminés, et nous le faisons pour tous les 100 élèves.

24
00:01:38,380 --> 00:01:42,240
Mais que faire si vous ne savez pas combien d'étudiants il ya effectivement?

25
00:01:42,240 --> 00:01:47,320
Il ya juste quelques élèves n et votre programme doit demander à l'utilisateur ce qui n est.

26
00:01:47,320 --> 00:01:50,250
Uh oh. Cela ne va pas très bien fonctionner.

27
00:01:50,250 --> 00:01:53,820
Votre programme ne fonctionne que pour un certain nombre constant d'étudiants.

28
00:01:53,820 --> 00:01:57,520
>> Résoudre tous ces problèmes, c'est la beauté des tableaux.

29
00:01:57,520 --> 00:01:59,930
Alors qu'est-ce qu'un tableau?

30
00:01:59,930 --> 00:02:04,480
Dans certains langages de programmation de type tableau peut être capable de faire un peu plus,

31
00:02:04,480 --> 00:02:09,960
mais ici nous allons nous concentrer sur la baie de la structure de données de base comme vous le verrez dans C.

32
00:02:09,960 --> 00:02:14,030
Un tableau est juste un gros bloc de mémoire. C'est tout.

33
00:02:14,030 --> 00:02:17,770
Quand nous disons que nous avons un tableau de 10 entiers, cela signifie simplement que nous avons un certain bloc

34
00:02:17,770 --> 00:02:20,740
de mémoire qui est assez grand pour contenir 10 entiers distincts.

35
00:02:29,930 --> 00:02:33,410
En supposant qu'un nombre entier de 4 octets, ce qui signifie que un tableau de 10 entiers

36
00:02:33,410 --> 00:02:37,180
est un bloc continu de 40 octets dans la mémoire.

37
00:02:42,660 --> 00:02:46,280
Même lorsque vous utilisez les tableaux multidimensionnels, qui nous n'aborderons pas ici, pour

38
00:02:46,280 --> 00:02:49,200
elle est encore juste un gros bloc de mémoire.

39
00:02:49,200 --> 00:02:51,840
La notation multidimensionnel est juste une commodité.

40
00:02:51,840 --> 00:02:55,640
Si vous avez un 3 par 3 tableau multidimensionnel des nombres entiers,

41
00:02:55,640 --> 00:03:00,650
alors votre programme sera vraiment juste traiter cela comme un gros bloc de 36 octets.

42
00:03:00,650 --> 00:03:05,460
Le nombre total de nombres entiers est 3 fois 3, et chaque entier prend 4 octets.

43
00:03:05,460 --> 00:03:07,750
>> Jetons un coup d'oeil à un exemple de base.

44
00:03:07,750 --> 00:03:10,660
Nous pouvons voir ici 2 façons différentes de tableaux déclarant.

45
00:03:15,660 --> 00:03:18,580
Nous allons devoir faire des commentaires 1 d'entre eux pour le programme à compiler

46
00:03:18,580 --> 00:03:20,900
puisque nous déclarons deux fois sur x.

47
00:03:20,900 --> 00:03:25,140
Nous allons jeter un oeil à quelques-unes des différences entre ces 2 types de déclarations en un peu.

48
00:03:25,140 --> 00:03:28,560
Ces deux lignes de déclarer un tableau de taille N,

49
00:03:28,560 --> 00:03:30,740
où nous avons # define N par 10.

50
00:03:30,740 --> 00:03:34,460
Nous pourrions tout aussi bien pu demander à l'utilisateur un nombre entier positif

51
00:03:34,460 --> 00:03:37,250
et utilisé que comme un nombre entier nombre d'éléments dans la matrice.

52
00:03:37,250 --> 00:03:41,960
Comme notre exemple d'étudiant avant, c'est un peu comme déclarer 10 complètement séparée

53
00:03:41,960 --> 00:03:49,000
les variables imaginaires; x0, x1, x2, et ainsi de suite jusqu'à xN-1.

54
00:03:57,270 --> 00:04:00,840
Ignorant les lignes où nous déclarer le tableau, notez les crochets intacte

55
00:04:00,840 --> 00:04:02,090
à l'intérieur de la boucle pour.

56
00:04:02,090 --> 00:04:09,660
Quand nous écrire quelque chose comme x [3], que je vais lire comme support x 3,

57
00:04:09,660 --> 00:04:13,090
vous pouvez penser que c'est comme demander l'imaginaire x3.

58
00:04:13,090 --> 00:04:17,519
Notez qu'avec un tableau de taille N, cela signifie que le nombre à l'intérieur des parenthèses,

59
00:04:17,519 --> 00:04:22,630
que nous appellerons l'indice, peut être n'importe quoi allant de 0 à N-1,

60
00:04:22,630 --> 00:04:25,660
soit un total de N indices.

61
00:04:25,660 --> 00:04:28,260
>> Pour réfléchir à la façon dont cela fonctionne réellement

62
00:04:28,260 --> 00:04:31,260
rappelez-vous que le tableau est un gros bloc de mémoire.

63
00:04:31,260 --> 00:04:37,460
En supposant qu'un nombre entier de 4 octets, le tableau entier x est un bloc de 40 octets de mémoire.

64
00:04:37,460 --> 00:04:41,360
Alors x0 désigne les 4 premiers octets du bloc.

65
00:04:45,810 --> 00:04:49,230
X [1] désigne les 4 octets suivants et ainsi de suite.

66
00:04:49,230 --> 00:04:53,760
Cela signifie que le début de x est d'autant programme jamais besoin de garder la trace.

67
00:04:55,660 --> 00:04:59,840
Si vous souhaitez utiliser x [400], le programme sait que c'est équivalent

68
00:04:59,840 --> 00:05:03,460
à seulement 1.600 octets après le début de x.

69
00:05:03,460 --> 00:05:08,780
Où as on obtient à partir de 1600 octets? Il est à seulement 400 fois 4 octets par entier.

70
00:05:08,780 --> 00:05:13,170
>> Avant de poursuivre, il est très important de réaliser que dans C

71
00:05:13,170 --> 00:05:17,080
il n'y a pas l'application de l'indice que nous utilisons dans le tableau.

72
00:05:17,080 --> 00:05:23,180
Notre gros bloc est à seulement 10 entiers long, mais rien ne nous crier dessus si nous écrivons x [20]

73
00:05:23,180 --> 00:05:26,060
ou encore x [-5].

74
00:05:26,060 --> 00:05:28,240
L'indice n'a même pas besoin d'être un numéro.

75
00:05:28,240 --> 00:05:30,630
Il peut être n'importe quelle expression.

76
00:05:30,630 --> 00:05:34,800
Dans le programme, nous utilisons la variable i de la boucle for à l'index dans le tableau.

77
00:05:34,800 --> 00:05:40,340
Il s'agit d'un modèle très courant, en boucle de i = 0 à la longueur du tableau,

78
00:05:40,340 --> 00:05:43,350
et puis je utiliser comme index de la matrice.

79
00:05:43,350 --> 00:05:46,160
De cette façon, vous avez effectivement une boucle sur l'ensemble du réseau,

80
00:05:46,160 --> 00:05:50,600
et vous pouvez soit assigner à chaque point dans le tableau ou l'utiliser pour des calculs.

81
00:05:50,600 --> 00:05:53,920
>> Dans la première boucle for, i commence à 0,

82
00:05:53,920 --> 00:05:58,680
et il se verra attribuer le 0 dans le tableau, la valeur 0 fois 2.

83
00:05:58,680 --> 00:06:04,370
Alors je incréments, et nous attribuons la première place dans le tableau de la valeur 1 fois 2.

84
00:06:04,370 --> 00:06:10,170
Alors je incréments de nouveau et ainsi de suite jusqu'à ce que nous attribuons à la position N-1 dans le tableau

85
00:06:10,170 --> 00:06:13,370
la valeur N-1 fois 2.

86
00:06:13,370 --> 00:06:17,810
Nous avons donc créé un tableau avec les 10 premiers nombres pairs.

87
00:06:17,810 --> 00:06:21,970
Unifie Peut-être aurait été un peu mieux le nom de la variable que x,

88
00:06:21,970 --> 00:06:24,760
mais qui aurait donné les choses.

89
00:06:24,760 --> 00:06:30,210
La deuxième boucle for, affiche seulement les valeurs que nous avons déjà stockés à l'intérieur de la matrice.

90
00:06:30,210 --> 00:06:33,600
>> Essayons d'exécuter le programme avec les deux types de déclarations de tableau

91
00:06:33,600 --> 00:06:36,330
et jeter un oeil à la sortie du programme.

92
00:06:51,450 --> 00:06:57,020
Autant que nous pouvons le constater, le programme se comporte de la même façon pour les deux types de déclarations.

93
00:06:57,020 --> 00:07:02,230
Nous allons également jeter un oeil à ce qui se passe si nous changeons la première boucle de ne pas s'arrêter à N

94
00:07:02,230 --> 00:07:05,040
mais plutôt dire 10.000.

95
00:07:05,040 --> 00:07:07,430
Bien au-delà de la fin du tableau.

96
00:07:14,700 --> 00:07:17,210
Oops. Peut-être que vous avez vu cela auparavant.

97
00:07:17,210 --> 00:07:20,440
Une erreur de segmentation signifie que votre programme a planté.

98
00:07:20,440 --> 00:07:24,430
Vous commencez à voir lorsque vous touchez ces zones de mémoire vous ne devriez pas être touchant.

99
00:07:24,430 --> 00:07:27,870
Ici, nous touchons 10.000 places au-delà du début de x,

100
00:07:27,870 --> 00:07:31,920
ce qui est évidemment une place dans la mémoire il ne faut pas se toucher.

101
00:07:31,920 --> 00:07:37,690
Ainsi, la plupart d'entre nous ne serait probablement pas accidentellement mettre 10.000 au lieu de N,

102
00:07:37,690 --> 00:07:42,930
mais que faire si nous faisons quelque chose de plus subtil comme, disons, écriture inférieur ou égal à N

103
00:07:42,930 --> 00:07:46,830
dans la condition de boucle pour, par opposition à moins de N.

104
00:07:46,830 --> 00:07:50,100
Rappeler que un tableau des indices seulement de 0 à N-1,

105
00:07:50,100 --> 00:07:54,510
ce qui signifie que l'indice N est au-delà de l'extrémité de la rangée.

106
00:07:54,510 --> 00:07:58,050
Le programme pourrait ne pas s'écraser dans ce cas, mais c'est toujours une erreur.

107
00:07:58,050 --> 00:08:01,950
En fait, cette erreur est si commun qu'il a son propre nom,

108
00:08:01,950 --> 00:08:03,970
un arrêt de 1 erreur.

109
00:08:03,970 --> 00:08:05,970
>> C'est tout pour les bases.

110
00:08:05,970 --> 00:08:09,960
Alors, quelles sont les principales différences entre les 2 types de déclarations de tableau?

111
00:08:09,960 --> 00:08:13,960
Une différence est où le grand bloc de mémoire va.

112
00:08:13,960 --> 00:08:17,660
Dans la première déclaration, que je vais appeler le type d'étrier tableau,

113
00:08:17,660 --> 00:08:20,300
si ce n'est en aucun cas un nom conventionnel,

114
00:08:20,300 --> 00:08:22,480
il ira sur la pile.

115
00:08:22,480 --> 00:08:27,450
Alors que dans le second, que je vais appeler le type de pointeur de tableau, il ira sur le tas.

116
00:08:27,450 --> 00:08:32,480
Cela signifie que lorsque la fonction retourne, le réseau de support sera automatiquement libérée,

117
00:08:32,480 --> 00:08:36,419
alors que vous devez appeler explicitement en libre sur le tableau de pointeurs

118
00:08:36,419 --> 00:08:38,010
ou bien vous avez une fuite de mémoire.

119
00:08:38,010 --> 00:08:42,750
En outre, le réseau de support n'est pas réellement une variable.

120
00:08:42,750 --> 00:08:45,490
Ceci est important. C'est juste un symbole.

121
00:08:45,490 --> 00:08:49,160
Vous pouvez penser que c'est une constante que le compilateur choisit pour vous.

122
00:08:49,160 --> 00:08:52,970
Cela signifie que nous ne pouvons pas faire quelque chose comme x + + avec le type de support,

123
00:08:52,970 --> 00:08:56,240
si cela est parfaitement valide avec le type de pointeur.

124
00:08:56,240 --> 00:08:58,270
>> Le type de pointeur est une variable.

125
00:08:58,270 --> 00:09:01,510
Pour le type de pointeur, nous avons 2 blocs distincts de mémoire.

126
00:09:01,510 --> 00:09:06,060
La variable x est elle-même stockée dans la pile et est juste un seul pointeur,

127
00:09:06,060 --> 00:09:08,620
mais le grand bloc de mémoire est stocké sur le tas.

128
00:09:08,620 --> 00:09:11,010
La variable x sur la pile stocke simplement l'adresse

129
00:09:11,010 --> 00:09:14,010
du grand bloc de mémoire sur le tas.

130
00:09:14,010 --> 00:09:17,370
Une des conséquences de cela est de la taille de l'opérateur.

131
00:09:17,370 --> 00:09:22,480
Si vous demandez la taille de la matrice de support, il vous donnera la taille du gros bloc de mémoire,

132
00:09:22,480 --> 00:09:24,620
quelque chose comme 40 octets,

133
00:09:24,620 --> 00:09:26,920
mais si vous demandez à la taille du type pointeur de tableau,

134
00:09:26,920 --> 00:09:32,740
il vous donnera la taille de la variable x elle-même, l'appareil est susceptible seulement 4 octets.

135
00:09:32,740 --> 00:09:36,530
En utilisant le type de pointeur de tableau, il est impossible de demander directement

136
00:09:36,530 --> 00:09:38,530
la taille de la mémoire de bloc de grande taille.

137
00:09:38,530 --> 00:09:42,530
Ce n'est généralement pas beaucoup d'une restriction puisque nous voulons que très rarement la taille

138
00:09:42,530 --> 00:09:46,980
du grand bloc de mémoire, et on peut généralement le calculer si nous en avons besoin.

139
00:09:46,980 --> 00:09:51,490
>> Enfin, le tableau support qui arrive à nous fournir un raccourci pour initialiser un tableau.

140
00:09:51,490 --> 00:09:56,130
Voyons comment nous pourrions écrire les 10 premiers entiers pairs en utilisant le raccourci initilization.

141
00:10:11,220 --> 00:10:14,470
Avec le tableau de pointeurs, il n'y a pas moyen de faire un raccourci de ce genre.

142
00:10:14,470 --> 00:10:18,120
Ceci est juste une introduction à ce que vous pouvez faire avec les tableaux.

143
00:10:18,120 --> 00:10:20,990
Ils apparaissent dans presque tous les programmes que vous écrivez.

144
00:10:20,990 --> 00:10:24,390
J'espère que vous pouvez maintenant voir une meilleure façon de faire l'exemple des étudiants ID

145
00:10:24,390 --> 00:10:26,710
dès le début de la vidéo.

146
00:10:26,710 --> 00:10:29,960
>> Mon nom est Rob Bowden, et c'est CS50.