2
00:00:00,000 --> 00:00:02,760
>> INTERLOCUTEUR 1: Écrivons un programme qui
demande à l'utilisateur les noms et

3
00:00:02,760 --> 00:00:04,700
maisons de trois étudiants.

4
00:00:04,700 --> 00:00:08,840
Maintenant, pour stocker les noms et les maisons
nous pourrions utiliser, ce qui, six variables.

5
00:00:08,840 --> 00:00:12,260
Trois chaînes pour les noms, et une autre
trois chaînes pour les maisons,

6
00:00:12,260 --> 00:00:16,560
mais nous savons déjà que nous pouvons nettoyer
ce code en utilisant des tableaux à la place,

7
00:00:16,560 --> 00:00:20,220
par exemple un tableau de taille 3, pour la
trois noms, et un autre tableau de

8
00:00:20,220 --> 00:00:22,110
taille 3 pour les maisons.

9
00:00:22,110 --> 00:00:25,870
Mais il s'avère que nous pouvons nettoyer cette place
plus loin encore, et fait garder les

10
00:00:25,870 --> 00:00:30,520
Les noms et les maisons ensemble, de sorte qu'une
le nom de l'étudiant et sa maison

11
00:00:30,520 --> 00:00:34,940
sont en quelque sorte encapsulé, ainsi
prendre la parole, dans la même variable.

12
00:00:34,940 --> 00:00:39,095
>> Pour ce faire, cependant, nous devons déclarer
notre propre type de données, notre propre type en C,

13
00:00:39,095 --> 00:00:42,660
que les auteurs de C n'ont pas nécessairement
penser il ya quelques années.

14
00:00:42,660 --> 00:00:45,630
Pour ce faire, nous pouvons utiliser le mot-clé
typedef, avec le

15
00:00:45,630 --> 00:00:47,200
autre mot clé struct.

16
00:00:47,200 --> 00:00:48,160
Jetons un coup d'oeil.

17
00:00:48,160 --> 00:00:50,650
A l'intérieur de structs.h, j'ai déjà
obtenu commencé par

18
00:00:50,650 --> 00:00:52,560
y compris la bibliothèque de CS50.

19
00:00:52,560 --> 00:00:57,640
Je prochaine va taper typedef struct,
puis une accolade.

20
00:00:57,640 --> 00:01:01,370
A l'intérieur de la structure, je vais
préciser qu'un étudiant doit avoir une

21
00:01:01,370 --> 00:01:04,960
chaîne appelée nom, et un autre
chaîne appelée maison.

22
00:01:04,960 --> 00:01:08,430
Je vais fermer alors mes accolades,
et spécifier que le nom de

23
00:01:08,430 --> 00:01:11,420
ce nouveau type de données doit être étudiant.

24
00:01:11,420 --> 00:01:15,550
En d'autres termes, par l'intermédiaire de cette syntaxe ai-je
déclaré un nouveau type de mon propre des données

25
00:01:15,550 --> 00:01:19,910
qui n'existaient pas il ya un moment, et
à l'intérieur de ce type de données sont deux données

26
00:01:19,910 --> 00:01:24,270
champs ou des membres de données, l'un appelé nom,
une maison dite, les deux

27
00:01:24,270 --> 00:01:25,630
sont de type chaîne.

28
00:01:25,630 --> 00:01:27,690
>> Prenons maintenant ce type
dans un programme réel.

29
00:01:27,690 --> 00:01:30,210

30
00:01:30,210 --> 00:01:34,090
En structs0.c, j'ai obtenu de la même
moi a commencé déjà avec une certaine

31
00:01:34,090 --> 00:01:36,999
code réutilisable, et je suis maintenant
va utiliser ces données

32
00:01:36,999 --> 00:01:39,100
saisir étudiant, comme suit.

33
00:01:39,100 --> 00:01:42,450
Je vais d'abord déclarer une
tableau de type étudiant, je vais

34
00:01:42,450 --> 00:01:43,920
appeler les élèves de tableau -

35
00:01:43,920 --> 00:01:44,630
pluriel -

36
00:01:44,630 --> 00:01:49,360
et je précise que sa taille sera
trois, qui, avis, est la valeur de

37
00:01:49,360 --> 00:01:50,880
les ÉTUDIANTS constants -

38
00:01:50,880 --> 00:01:51,890
dans toutes les capitales -

39
00:01:51,890 --> 00:01:54,930
que j'ai déclaré ici,
plus tôt dans le fichier.

40
00:01:54,930 --> 00:01:58,280
Voyons maintenant itérer sur ces trois
étudiants, et demander à l'utilisateur

41
00:01:58,280 --> 00:02:00,050
leurs noms et leurs maisons.

42
00:02:00,050 --> 00:02:05,422
>> pour int j'obtiens 0, i est inférieur
que constante, i + +.

43
00:02:05,422 --> 00:02:08,600
Et maintenant à l'intérieur du corps de ceux-ci d'
boucle, je vais imprimer quelque chose

44
00:02:08,600 --> 00:02:11,470
comme le nom de l'étudiant.

45
00:02:11,470 --> 00:02:14,890
Je puis aller à réellement obtenir que
le nom de l'étudiant en spécifiant

46
00:02:14,890 --> 00:02:17,290
étudiants encadrent i.

47
00:02:17,290 --> 00:02:21,550
En d'autres termes, je veux l'étudiant i-ème
dans le tableau appelé les étudiants, mais maintenant

48
00:02:21,550 --> 00:02:25,340
Je veux obtenir à ce i-e étudiant de
nom, et pour ce faire, je vais utiliser

49
00:02:25,340 --> 00:02:30,160
l'. opérateur, afin d'obtenir à un
l'intérieur du champ spécifique de la structure.

50
00:02:30,160 --> 00:02:37,100
Alors je précise étudiants encadrent i. Nom
obtient la valeur de retour de GetString ().

51
00:02:37,100 --> 00:02:40,310
En attendant, je vais imprimer
quelque chose de semblable, disant étudiant de

52
00:02:40,310 --> 00:02:45,410
maison, et maintenant je vais préciser
que le champ étudiants maison i-ème

53
00:02:45,410 --> 00:02:49,480
doit obtenir la valeur de retour de
un autre appel à GetString ().

54
00:02:49,480 --> 00:02:52,350
>> Maintenant, nous allons faire quelque chose avec ces trois
Les noms et les maisons des étudiants,

55
00:02:52,350 --> 00:02:56,230
quelque chose de simple comme l'impression
chaque dans une phrase.

56
00:02:56,230 --> 00:03:07,580
pour int i me 0, nouveau i est inférieur à
étudiants, i + +, printf "% s est dans% s.

57
00:03:07,580 --> 00:03:12,600
barre oblique inverse n ", et maintenant laissez-moi branche dans
les valeurs de ces deux champs,

58
00:03:12,600 --> 00:03:19,055
étudiants encadrent i. nom, une virgule,
étudiants encadrent i. maison, près

59
00:03:19,055 --> 00:03:21,290
parenthèse, point-virgule.

60
00:03:21,290 --> 00:03:23,020
>> Et maintenant, je dois faire autre chose.

61
00:03:23,020 --> 00:03:26,600
Au bas de ce fichier, je dois
libérer la mémoire allouée

62
00:03:26,600 --> 00:03:30,290
dans les coulisses par GetSring (), qui
invite bien sûr malloc, afin de

63
00:03:30,290 --> 00:03:32,500
allouer de la mémoire pour les chaînes
les types d'utilisateurs.

64
00:03:32,500 --> 00:03:35,720
Mais cela est simple.

65
00:03:35,720 --> 00:03:42,610
pour int j'obtiens 0, i est inférieur à
les étudiants, i + +, et à l'intérieur du corps de

66
00:03:42,610 --> 00:03:48,670
cette boucle, je vais tout simplement
fournir gratuitement les étudiants support i. nom,

67
00:03:48,670 --> 00:03:52,300
et les étudiants libres encadrent i. maison.

68
00:03:52,300 --> 00:03:55,620
>> Maintenant, nous avons clairement utilisé trois pour les boucles
dans ce programme, quand vraiment je

69
00:03:55,620 --> 00:03:58,800
aurait simplement utilisé un, mais ce n'est
juste pour l'amour de la démonstration, de sorte que

70
00:03:58,800 --> 00:04:02,850
nous pouvons spécifier dans trois groupes distincts
étapes Qu'est-ce exactement que nous faisons.

71
00:04:02,850 --> 00:04:06,120
Nous d'abord obtenir un nom et une maison
pour chacun des élèves, nous sommes alors

72
00:04:06,120 --> 00:04:08,900
imprimer le nom et la maison pour
chacun des trois étudiants, et

73
00:04:08,900 --> 00:04:11,910
alors nous allons libérer la mémoire
utilisée par chacun des étudiants.

74
00:04:11,910 --> 00:04:15,310
Mais sûrement, nous aurions pu combiner cette
dans un plus grand pour la boucle.

75
00:04:15,310 --> 00:04:18,650
>> Voyons maintenant enregistrer, compiler,
et exécuter ce programme.

76
00:04:18,650 --> 00:04:26,850
faire struct 0. / struct 0, étudiant de
nom, nous allons fournir David, il vivra

77
00:04:26,850 --> 00:04:31,580
à Mather House, le nom de l'étudiant, nous allons
dire Lauren, elle va vivre dans Leverett

78
00:04:31,580 --> 00:04:36,590
Maison, le nom de l'élève, Rob, il va
vivre dans Kirkland House.

79
00:04:36,590 --> 00:04:39,440
Et en effet, David est à Mather,
Lauren est dans Leverett,

80
00:04:39,440 --> 00:04:40,810
et Rob est situé à Kirkland.

81
00:04:40,810 --> 00:04:43,425