1
00:00:00,000 --> 00:00:02,395
>> [Jouer de la musique]

2
00:00:02,395 --> 00:00:05,750

3
00:00:05,750 --> 00:00:06,506
>> DOUG LLOYD: OK.

4
00:00:06,506 --> 00:00:08,880
Nous avons travaillé avec des nombres entiers,
nous avons travaillé avec des personnages,

5
00:00:08,880 --> 00:00:11,930
nous avons travaillé flotteurs,
doubles, les chaînes et bools.

6
00:00:11,930 --> 00:00:14,870
Nous avons épuisé à peu près tout
des [inaudible] types qui

7
00:00:14,870 --> 00:00:17,100
ont été mis à notre disposition tout le long.

8
00:00:17,100 --> 00:00:19,430
Mais maintenant, nous voulons faire quelque chose de plus.

9
00:00:19,430 --> 00:00:20,210
Comment fait-on cela?

10
00:00:20,210 --> 00:00:22,560
Comment pouvons-nous créer différents types de données?

11
00:00:22,560 --> 00:00:26,130
Nous pouvons le faire en utilisant des structures.

12
00:00:26,130 --> 00:00:30,180
Donc structures nous permettent d'unifier
des variables de différents types

13
00:00:30,180 --> 00:00:34,810
en un seul, le nouveau type de variable,
que nous pouvons attribuer son propre nom de type.

14
00:00:34,810 --> 00:00:37,570
Ceci est une très forte
chose pour être en mesure de le faire,

15
00:00:37,570 --> 00:00:40,900
parce que nous pouvons désormais groupe
des éléments de différents types de données

16
00:00:40,900 --> 00:00:43,910
ainsi que disposer d'une connexion logique.

17
00:00:43,910 --> 00:00:46,440
Nous avons été en mesure de le faire
avec des tableaux de genre, non?

18
00:00:46,440 --> 00:00:49,540
Nous pouvons variables de groupe
du même type de données

19
00:00:49,540 --> 00:00:53,410
ensemble dans une grande unité
de mémoire, un tableau.

20
00:00:53,410 --> 00:00:56,660
>> Mais nous avons pas été en mesure de mélanger
place différents types de données ensemble.

21
00:00:56,660 --> 00:01:02,610
Nous ne pouvons pas, par exemple, associer un nombre entier,
et un caractère, et un double tous

22
00:01:02,610 --> 00:01:05,330
dans la même chose et
appeler cela une seule unité.

23
00:01:05,330 --> 00:01:08,830
Mais avec des structures, ou
souvent dénommée structs,

24
00:01:08,830 --> 00:01:09,585
Nous pouvons en fait.

25
00:01:09,585 --> 00:01:12,370
Donc, une structure est en quelque sorte
des comme une variable de super.

26
00:01:12,370 --> 00:01:16,530
Il est une variable qui contient
d'autres variables à l'intérieur.

27
00:01:16,530 --> 00:01:19,650
Alors, voici un exemple de
une structure très simple.

28
00:01:19,650 --> 00:01:23,380
Ceci est ce que la syntaxe ressemblerait
souhaite créer une structure pour une voiture.

29
00:01:23,380 --> 00:01:25,250
Maintenant, nous allons passer par la syntaxe ici.

30
00:01:25,250 --> 00:01:27,400
Struct, qui est la
mot-clé qui indique

31
00:01:27,400 --> 00:01:30,270
que je suis la création d'un nouveau type de données ici.

32
00:01:30,270 --> 00:01:33,860
En particulier, le nom du type de données est
va être struct voiture, comme nous le verrons.

33
00:01:33,860 --> 00:01:36,640
Mais ceci est le genre de pointe
OFF pour le compilateur que cette

34
00:01:36,640 --> 00:01:42,440
en tant que groupe de variables qui se passe
être considéré comme faisant partie du même type

35
00:01:42,440 --> 00:01:44,010
dans une minute.

36
00:01:44,010 --> 00:01:46,340
>> Voitures, juste le nom de la structure.

37
00:01:46,340 --> 00:01:50,590
Encore une fois, le type de données va ici
être struct voiture, et pas seulement la voiture.

38
00:01:50,590 --> 00:01:53,060
Mais si vous avez different--
Si vous créez plusieurs structs

39
00:01:53,060 --> 00:01:56,950
dans le même programme, vous devez
la distinction entre structure et struct.

40
00:01:56,950 --> 00:02:00,140
Donc struct voiture, je pourrais aussi avoir
struct étudiant, par exemple,

41
00:02:00,140 --> 00:02:01,790
dans le même programme.

42
00:02:01,790 --> 00:02:05,980
A l'intérieur des accolades sont
tous les champs dits,

43
00:02:05,980 --> 00:02:07,954
ou les membres de la structure.

44
00:02:07,954 --> 00:02:10,370
Alors, quelles sont certaines des choses
qui sont inhérents à une voiture?

45
00:02:10,370 --> 00:02:15,270
Eh bien, il a généralement un an, a
un nom de modèle, et une plaque d'immatriculation,

46
00:02:15,270 --> 00:02:18,000
un odomètre qui a habituellement
un certain nombre de miles sur elle,

47
00:02:18,000 --> 00:02:19,225
et peut-être une taille de moteur.

48
00:02:19,225 --> 00:02:23,570
Et comme vous pouvez le voir, je vais mélanger
entiers et des personnages et doubles.

49
00:02:23,570 --> 00:02:26,420
Ils vont tous être
partie de ce nouveau type de données.

50
00:02:26,420 --> 00:02:29,750
>> Enfin, la dernière chose que je dois faire,
ne pas oublier ce petit point-virgule

51
00:02:29,750 --> 00:02:30,290
à la fin.

52
00:02:30,290 --> 00:02:34,380
Après avoir fini de définir la structure,
nous devons mettre un point-virgule à la fin.

53
00:02:34,380 --> 00:02:37,325
Il est un très commun syntaxique
erreur, parce que d'une fonction,

54
00:02:37,325 --> 00:02:40,200
par exemple, vous avez juste
accolade ouverte, accolade à proximité.

55
00:02:40,200 --> 00:02:42,950
Vous ne mettez pas une virgule à la
fin d'une définition de fonction.

56
00:02:42,950 --> 00:02:46,430
Cela ressemble à une fonction
définition, mais il est pas,

57
00:02:46,430 --> 00:02:49,653
et ainsi le point-virgule, il
est juste un rappel que vous

58
00:02:49,653 --> 00:02:52,440
besoin de le mettre là, parce
Le compilateur pas autrement

59
00:02:52,440 --> 00:02:53,510
savoir quoi faire avec elle.

60
00:02:53,510 --> 00:02:56,160
Il est une erreur très commune
à faire accidentellement

61
00:02:56,160 --> 00:02:58,570
quand vous êtes le premier à définir des structures.

62
00:02:58,570 --> 00:02:59,500
>> D'ACCORD.

63
00:02:59,500 --> 00:03:02,824
Donc, nous définissons habituellement nos structures
au sommet de nos programmes

64
00:03:02,824 --> 00:03:05,490
parce qu'ils vont probablement
pour être utilisé par de multiples fonctions.

65
00:03:05,490 --> 00:03:08,850
Nous ne voulons pas de définir une
struct à l'intérieur d'une fonction,

66
00:03:08,850 --> 00:03:12,110
car alors nous pouvons le terre que:
champ d'application de la structure vraiment

67
00:03:12,110 --> 00:03:13,790
existe seulement à l'intérieur de cette fonction.

68
00:03:13,790 --> 00:03:17,450
Nous aurions probablement voulons définir une structure
afin que nous puissions l'utiliser dans de multiples fonctions,

69
00:03:17,450 --> 00:03:20,670
ou peut-être dans de multiples
les fichiers qui sont attachés ensemble

70
00:03:20,670 --> 00:03:22,920
pour créer notre programme unique.

71
00:03:22,920 --> 00:03:24,920
Parfois aussi la place
de définition de la structure

72
00:03:24,920 --> 00:03:27,961
au sommet où vous mettez votre
livre comprend et votre livre définit,

73
00:03:27,961 --> 00:03:32,080
Par exemple, vous pourriez les mettre en
fichiers dot h séparés, que vous alors

74
00:03:32,080 --> 00:03:35,020
livre vous inclure.

75
00:03:35,020 --> 00:03:37,620
>> Donc, nous avons des structures, mais maintenant
nous avons besoin de pénétrer à l'intérieur d'eux.

76
00:03:37,620 --> 00:03:39,800
Comment pouvons-nous obtenir de l'intérieur
une structure d'accès

77
00:03:39,800 --> 00:03:43,530
ces sous-variables, ces variables
qui existent à l'intérieur de la structure?

78
00:03:43,530 --> 00:03:46,810
Eh bien, nous avons quelque chose appelé
l'opérateur point, ce qui nous permet

79
00:03:46,810 --> 00:03:50,990
pour accéder aux champs de la structure.

80
00:03:50,990 --> 00:03:55,490
Ainsi, par exemple, disons que je ai déclaré
mes données de type de structure, quelque part

81
00:03:55,490 --> 00:03:59,020
au sommet de mon programme, ou peut-être en
un fichier dot h que je l'ai livre inclus.

82
00:03:59,020 --> 00:04:03,360
Si je veux ensuite pour créer un nouveau
variable de ce type de données, je peux dire,

83
00:04:03,360 --> 00:04:06,260
voiture de struct, ma voiture, point-virgule.

84
00:04:06,260 --> 00:04:11,580
Tout comme je pourrais dire int
x, ou le nom de la chaîne virgule.

85
00:04:11,580 --> 00:04:18,100
>> Le type de données ici est la voiture de struct,
le nom de la variable est ma voiture,

86
00:04:18,100 --> 00:04:23,770
et puis je peux utiliser l'opérateur point pour
accéder aux différents domaines de ma voiture.

87
00:04:23,770 --> 00:04:27,494
Donc, je peux dire que ma voiture
dot année est égal à 2,011.

88
00:04:27,494 --> 00:04:28,410
Voilà parfaitement bien.

89
00:04:28,410 --> 00:04:34,210
Année, si vous vous souvenez, a été définie comme une
integer champ intérieur de cette voiture de struct

90
00:04:34,210 --> 00:04:35,200
Type de données.

91
00:04:35,200 --> 00:04:39,966
Donc, toutes les variables de données de la voiture struct
type, comme ma voiture, je peux dire que ma voiture

92
00:04:39,966 --> 00:04:44,030
année dot égaux et ensuite affecter
il quelque valeur entière, 2011.

93
00:04:44,030 --> 00:04:47,290
Mon assiette voiture de points est égal CS50.

94
00:04:47,290 --> 00:04:51,180
Ma carte de point kilométrique
est égal à 50505 point-virgule.

95
00:04:51,180 --> 00:04:53,270
Tous ceux qui sont
parfaitement bien et que ce

96
00:04:53,270 --> 00:04:57,802
la façon dont nous accédons à la
champs de la structure.

97
00:04:57,802 --> 00:05:00,260
Ouvrages d'art, cependant, ne doivent pas
à créer sur la pile.

98
00:05:00,260 --> 00:05:02,950
Tout comme toute autre variable, nous
peut dynamiquement les attribuer.

99
00:05:02,950 --> 00:05:06,309
Si nous avons un programme qui pourrait
être générer de nombreuses structures,

100
00:05:06,309 --> 00:05:08,100
nous ne savons pas combien de
nous allons avoir besoin,

101
00:05:08,100 --> 00:05:10,800
alors nous devons dynamiquement
répartir ces structures

102
00:05:10,800 --> 00:05:12,960
que notre programme est en cours d'exécution.

103
00:05:12,960 --> 00:05:16,600
Et donc si nous allons accéder à la
les champs d'une structure dans ce contexte,

104
00:05:16,600 --> 00:05:20,660
Rappelons que nous avons d'abord besoin de déréférencer
le pointeur vers la structure,

105
00:05:20,660 --> 00:05:24,810
puis une fois que nous l'déréférencer
pointeur, alors nous pouvons accéder aux champs.

106
00:05:24,810 --> 00:05:26,830
Si nous avons seulement un
pointeur vers la structure,

107
00:05:26,830 --> 00:05:32,120
nous ne pouvons pas simplement dire champ pointeur de la dot
Nom et obtenons ce que nous recherchons.

108
00:05:32,120 --> 00:05:34,259
Il ya l'étape supplémentaire de déréférencement.

109
00:05:34,259 --> 00:05:36,050
Donc disons que
au lieu de la previous--

110
00:05:36,050 --> 00:05:38,770
tout comme l'exemple précédent,
au lieu de le déclarer

111
00:05:38,770 --> 00:05:43,680
sur la pile, voiture struct, mon
voiture, point-virgule, je dis voiture de struct,

112
00:05:43,680 --> 00:05:48,020
étoiles, un pointeur vers une
voiture de struct appelé ma voiture,

113
00:05:48,020 --> 00:05:51,250
est égal à la taille de la voiture de malloc struct.

114
00:05:51,250 --> 00:05:54,950
Taille de nous va déterminer combien de
octets votre nouveau type de données prend.

115
00:05:54,950 --> 00:05:58,570
Nécessairement que vous ne devez utiliser
taille de largeur, int ou char, ou tout

116
00:05:58,570 --> 00:05:59,715
des types de données intégrés.

117
00:05:59,715 --> 00:06:02,090
Le compilateur est assez intelligent
de comprendre comment de nombreux octets

118
00:06:02,090 --> 00:06:04,170
sont requis par votre nouvelle structure.

119
00:06:04,170 --> 00:06:09,610
Alors je me suis malloc une unité de mémoire
assez grand pour contenir une voiture de struct,

120
00:06:09,610 --> 00:06:12,410
et je reçois un pointeur de retour
à ce bloc de mémoire,

121
00:06:12,410 --> 00:06:16,090
et ce pointeur est assigné à ma voiture.

122
00:06:16,090 --> 00:06:18,050
>> Maintenant, si je veux un accès
les domaines de ma voiture,

123
00:06:18,050 --> 00:06:22,615
Je premier déréférencer ma voiture à l'aide
l'opérateur de déréférencement, étoile

124
00:06:22,615 --> 00:06:26,620
que nous avons vu des pointeurs
vidéos, et puis après je déréférencer,

125
00:06:26,620 --> 00:06:32,200
alors je peux utiliser l'opérateur point pour
accéder aux différents domaines de ma voiture.

126
00:06:32,200 --> 00:06:35,490
Étoile ma voiture dot année est égal à 2,011.

127
00:06:35,490 --> 00:06:38,480
Cela aurait l'effet
nous voulons dans ce cas,

128
00:06:38,480 --> 00:06:41,960
Parce que nous avons dynamiquement
alloué ma voiture.

129
00:06:41,960 --> 00:06:43,610
>> Voilà assez ennuyeux, bien, non?

130
00:06:43,610 --> 00:06:44,818
Il ya un processus en 2 étapes maintenant.

131
00:06:44,818 --> 00:06:47,460
Maintenant, nous devons dereference--
nous avons un opérateur étoiles,

132
00:06:47,460 --> 00:06:48,910
et nous avons un opérateur point.

133
00:06:48,910 --> 00:06:51,660
Et comme on pouvait s'y attendre, parce
C programmeurs aiment façons plus courtes

134
00:06:51,660 --> 00:06:53,740
de faire les choses, il ya une
chemin plus court pour ce faire.

135
00:06:53,740 --> 00:06:57,790
Il ya un autre opérateur appelé flèche,
ce qui rend ce processus beaucoup plus facile.

136
00:06:57,790 --> 00:07:00,750
La façon dont fonctionne flèche est
il premiers déréférences

137
00:07:00,750 --> 00:07:03,560
le pointeur sur la gauche
côté de l'opérateur,

138
00:07:03,560 --> 00:07:06,620
puis, après avoir déréférencé
le pointeur sur la gauche,

139
00:07:06,620 --> 00:07:09,620
il accède au champ sur la droite.

140
00:07:09,620 --> 00:07:14,170
Et si auparavant nous avions ce genre
de Star ma voiture dot tous ces trucs,

141
00:07:14,170 --> 00:07:15,880
comme il y avait beaucoup de choses là-bas.

142
00:07:15,880 --> 00:07:22,040
Mais ce que nous pouvons faire est de la place this--
ma voiture flèche année équivaut à 2,011.

143
00:07:22,040 --> 00:07:23,580
>> Encore une fois, ce qui se passe ici?

144
00:07:23,580 --> 00:07:25,720
Premièrement, je suis déréférencement ma voiture.

145
00:07:25,720 --> 00:07:27,810
Qui encore une fois, est un pointeur ici.

146
00:07:27,810 --> 00:07:31,270
Puis, après avoir
déréférencé ma voiture, je

147
00:07:31,270 --> 00:07:35,130
peut alors accéder aux champs
année, plaque, et le compteur kilométrique

148
00:07:35,130 --> 00:07:40,020
tout comme je pouvais avant d'avoir d'abord
étoiles occasion de déréférencer ma voiture,

149
00:07:40,020 --> 00:07:42,020
et parsemer pour accéder au champ.

150
00:07:42,020 --> 00:07:45,290
Ainsi, vous pouvez avoir des structures, vous
peut avoir des pointeurs vers des structures,

151
00:07:45,290 --> 00:07:48,360
et vous avez les moyens d'accès
les champs de ces structures,

152
00:07:48,360 --> 00:07:52,600
si vous avez des pointeurs vers
ou les variables elles-mêmes.

153
00:07:52,600 --> 00:07:57,640
Dot ou une flèche, selon
comment la variable a été déclarée.

154
00:07:57,640 --> 00:08:00,510
Je suis Doug Lloyd, cela est CS50.

155
00:08:00,510 --> 00:08:01,975