2
00:00:00,000 --> 00:00:02,760
>> ALTAVEU 1: Anem a escriure un programa que
sol · licita a l'usuari els noms i

3
00:00:02,760 --> 00:00:04,700
cases de tres estudiants.

4
00:00:04,700 --> 00:00:08,840
Ara, per emmagatzemar els noms i cases
podríem utilitzar, què, sis variables.

5
00:00:08,840 --> 00:00:12,260
Tres cadenes per als noms, i un altre
tres cadenes per a les cases,

6
00:00:12,260 --> 00:00:16,560
però ja sabem que podem netejar
que el codi mitjançant l'ús de matrius lloc,

7
00:00:16,560 --> 00:00:20,220
per exemple, una matriu de mida 3 per al
tres noms, i una altra sèrie de

8
00:00:20,220 --> 00:00:22,110
mida 3 per a les cases.

9
00:00:22,110 --> 00:00:25,870
Però resulta que podem netejar això
encara més lluny, i en realitat mantenir els

10
00:00:25,870 --> 00:00:30,520
noms i cases juntes, de manera que una
el nom de l'estudiant i de casa

11
00:00:30,520 --> 00:00:34,940
són d'alguna manera encapsulada, per així
parlar, en la mateixa variable.

12
00:00:34,940 --> 00:00:39,095
>> Per a això, però, hem de declarar
nostre propi tipus de dades, el nostre propi tipus en C,

13
00:00:39,095 --> 00:00:42,660
que els autors de C no necessàriament
pensar en fa anys.

14
00:00:42,660 --> 00:00:45,630
Per a això podem utilitzar la paraula clau
typedef, juntament amb la

15
00:00:45,630 --> 00:00:47,200
altra estructura de paraules clau.

16
00:00:47,200 --> 00:00:48,160
Anem a fer una ullada.

17
00:00:48,160 --> 00:00:50,650
Dins structs.h, ja he
fet més que començar per

18
00:00:50,650 --> 00:00:52,560
incloent la biblioteca CS50.

19
00:00:52,560 --> 00:00:57,640
Estic al costat va a escriure typedef struct,
i després una clau.

20
00:00:57,640 --> 00:01:01,370
A l'interior de l'estructura, que vaig a
especificar que un estudiant ha de tenir un

21
00:01:01,370 --> 00:01:04,960
cadena anomenat nom, i una altra
string anomenat casa.

22
00:01:04,960 --> 00:01:08,430
Vaig a continuació, tanca les meves claus,
i especificar que el nom de

23
00:01:08,430 --> 00:01:11,420
aquest nou tipus de dades ha de ser estudiant.

24
00:01:11,420 --> 00:01:15,550
En altres paraules, a través d'aquesta sintaxi he
declarat un nou tipus de dades de la meva pròpia

25
00:01:15,550 --> 00:01:19,910
que no existien fa un moment, i
dins d'aquest tipus de dades són dues dades

26
00:01:19,910 --> 00:01:24,270
camps o membres de dades, un anomenat nom,
un anomenat casa, dos dels quals

27
00:01:24,270 --> 00:01:25,630
són de tipus cadena.

28
00:01:25,630 --> 00:01:27,690
>> Ara utilitzarem aquest tipus
en un programa real.

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

30
00:01:30,210 --> 00:01:34,090
En structs0.c, m'he ficat de manera similar
jo ja va començar amb alguns

31
00:01:34,090 --> 00:01:36,999
codi repetitiu, i estic ara
utilitzarem aquestes dades

32
00:01:36,999 --> 00:01:39,100
escrigui estudiant, de la següent manera.

33
00:01:39,100 --> 00:01:42,450
Estic primer va a declarar una
matriu de tipus estudiant, vaig a

34
00:01:42,450 --> 00:01:43,920
trucar als estudiants de la matriu -

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

36
00:01:44,630 --> 00:01:49,360
i vaig a especificar que la seva mida serà
3, que, avís, és el valor de

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

38
00:01:50,880 --> 00:01:51,890
en totes les capitals -

39
00:01:51,890 --> 00:01:54,930
que jo he declarat aquí,
anteriorment a l'arxiu.

40
00:01:54,930 --> 00:01:58,280
Ara anem a iterar sobre els tres
estudiants, i sol · licitar a l'usuari

41
00:01:58,280 --> 00:02:00,050
els seus noms i cases.

42
00:02:00,050 --> 00:02:05,422
>> per int i obtenir 0, i és menor
que la constant, i + +.

43
00:02:05,422 --> 00:02:08,600
I ara a l'interior del cos d'aquesta per
llaç, vaig a imprimir alguna cosa

44
00:02:08,600 --> 00:02:11,470
com el nom de l'estudiant.

45
00:02:11,470 --> 00:02:14,890
Llavors vaig a aconseguir realment que
nom de l'estudiant especificant

46
00:02:14,890 --> 00:02:17,290
estudiants mènsula.

47
00:02:17,290 --> 00:02:21,550
En altres paraules, vull que l'estudiant i-èsim
en la matriu anomenada estudiants, però ara

48
00:02:21,550 --> 00:02:25,340
Vull arribar a aquest nombre i estudiantil
nom, i per fer això, utilitzaré

49
00:02:25,340 --> 00:02:30,160
el. operador, per tal d'arribar a un
dins del camp específic de l'estructura.

50
00:02:30,160 --> 00:02:37,100
Així que jo indiqui estudiants mènsula. Nom
s'obté el valor de retorn de GetString ().

51
00:02:37,100 --> 00:02:40,310
Mentrestant, vaig a imprimir
alguna cosa similar, dient que els estudiants de

52
00:02:40,310 --> 00:02:45,410
casa, i ara em vaig a especificar
que el camp dels estudiants la casa nombre i

53
00:02:45,410 --> 00:02:49,480
haurà d'obtenir el valor de retorn de
altra crida a GetString ().

54
00:02:49,480 --> 00:02:52,350
>> Ara farem alguna cosa amb aquests tres
noms i les cases dels estudiants,

55
00:02:52,350 --> 00:02:56,230
una cosa tan simple com la impressió
cadascun en una frase.

56
00:02:56,230 --> 00:03:07,580
per int i get 0, de nou i és menor que
estudiants, i + +, printf "% s està a% s.

57
00:03:07,580 --> 00:03:12,600
barra invertida n ", i ara m'ho dius endollar
els valors d'aquests dos camps,

58
00:03:12,600 --> 00:03:19,055
estudiants mènsula. nom, coma,
estudiants mènsula. casa, prop

59
00:03:19,055 --> 00:03:21,290
parin, punt i coma.

60
00:03:21,290 --> 00:03:23,020
>> I ara he de fer una cosa més.

61
00:03:23,020 --> 00:03:26,600
En el fons d'aquest arxiu, necessito
alliberar la memòria que es va assignar

62
00:03:26,600 --> 00:03:30,290
darrere de les escenes de GetSring (), que
demana, per descomptat, malloc, per tal de

63
00:03:30,290 --> 00:03:32,500
assignar memòria per a les cadenes
els tipus d'usuaris.

64
00:03:32,500 --> 00:03:35,720
Però això és simple.

65
00:03:35,720 --> 00:03:42,610
per int i obtenir 0, i és menor que
estudiants, i + +, i l'interior del cos de

66
00:03:42,610 --> 00:03:48,670
aquest bucle, estic simplement va a
proporcionar als estudiants sense suport de i. nom,

67
00:03:48,670 --> 00:03:52,300
i els estudiants lliures mènsula. casa.

68
00:03:52,300 --> 00:03:55,620
>> Ara, hem utilitzat clarament tres bucles for
en aquest programa, quan realment

69
00:03:55,620 --> 00:03:58,800
podria haver utilitzat només un, però això és
simplement per l'amor de la demostració, per la qual cosa

70
00:03:58,800 --> 00:04:02,850
podem especificar en tres canals diferents
Passos què és exactament el que estem fent.

71
00:04:02,850 --> 00:04:06,120
Estem obtenint primer un nom i una casa
per a cada un dels estudiants, estem llavors

72
00:04:06,120 --> 00:04:08,900
imprimir el nom i la casa de
cadascun dels tres estudiants, i

73
00:04:08,900 --> 00:04:11,910
a continuació, anem a alliberar la memòria
utilitzat per cada un dels estudiants.

74
00:04:11,910 --> 00:04:15,310
Però segur que podríem haver combinar aquest
en un més gran per bucle.

75
00:04:15,310 --> 00:04:18,650
>> Ara anem a guardar, compilar,
i executar aquest programa.

76
00:04:18,650 --> 00:04:26,850
fer estructures 0. 0 / estructures, estudiant de
nom, anem a proporcionar David, viurà

77
00:04:26,850 --> 00:04:31,580
en Mather House, el nom de l'estudiant, anem a
dir Lauren, ella viu en Leverett

78
00:04:31,580 --> 00:04:36,590
Casa, nom de l'estudiant, Rob, ell
viure en Kirkland House.

79
00:04:36,590 --> 00:04:39,440
I, de fet, David està en Mather,
Lauren està en Leverett,

80
00:04:39,440 --> 00:04:40,810
i Rob es troba a Kirkland.

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