1
00:00:00,000 --> 00:00:02,395
>> [RIPRODUZIONE DI BRANI MUSICALI]

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
Abbiamo lavorato con gli interi,
abbiamo lavorato con personaggi,

5
00:00:08,880 --> 00:00:11,930
abbiamo lavorato galleggianti,
doppie, stringhe e bool.

6
00:00:11,930 --> 00:00:14,870
Abbiamo esaurito praticamente tutto
dei [incomprensibile] tipi che

7
00:00:14,870 --> 00:00:17,100
sono stati a disposizione di tutti noi lungo.

8
00:00:17,100 --> 00:00:19,430
Ma ora vogliamo fare qualcosa di più.

9
00:00:19,430 --> 00:00:20,210
Come lo facciamo?

10
00:00:20,210 --> 00:00:22,560
Come si fa a creare diversi tipi di dati?

11
00:00:22,560 --> 00:00:26,130
Possiamo farlo utilizzando strutture.

12
00:00:26,130 --> 00:00:30,180
Così strutture permettono di unificare
variabili di tipi diversi

13
00:00:30,180 --> 00:00:34,810
in un unico, nuovo tipo di variabile,
che possiamo assegnare un proprio nome tipo.

14
00:00:34,810 --> 00:00:37,570
Questo è un molto forte
cosa da essere in grado di fare,

15
00:00:37,570 --> 00:00:40,900
perché possiamo ora gruppo
elementi di diversi tipi di dati

16
00:00:40,900 --> 00:00:43,910
insieme che hanno un collegamento logico.

17
00:00:43,910 --> 00:00:46,440
Siamo stati in grado di fare questo
con array di tipo, giusto?

18
00:00:46,440 --> 00:00:49,540
Siamo in grado di variabili di gruppo
dello stesso tipo di dati

19
00:00:49,540 --> 00:00:53,410
insieme in una grande unità
della memoria, un array.

20
00:00:53,410 --> 00:00:56,660
>> Ma non siamo stati in grado di mescolare
up diversi tipi di dati insieme.

21
00:00:56,660 --> 00:01:02,610
Non possiamo, dire, abbinare un numero intero,
e un carattere, e un doppio tutto

22
00:01:02,610 --> 00:01:05,330
nella stessa cosa e
chiamare che una singola unità.

23
00:01:05,330 --> 00:01:08,830
Ma con le strutture, o
spesso indicato come le strutture,

24
00:01:08,830 --> 00:01:09,585
abbiamo effettivamente possibile.

25
00:01:09,585 --> 00:01:12,370
Quindi una struttura è sorta
di come una variabile eccellente.

26
00:01:12,370 --> 00:01:16,530
E 'una variabile che contiene
altre variabili all'interno di esso.

27
00:01:16,530 --> 00:01:19,650
Quindi, ecco un esempio di
una struttura molto semplice.

28
00:01:19,650 --> 00:01:23,380
Questo è ciò che la sintassi sarà
vuole creare una struttura di una macchina.

29
00:01:23,380 --> 00:01:25,250
Ora, andiamo attraverso la sintassi qui.

30
00:01:25,250 --> 00:01:27,400
Struct, che è il
parola chiave che indica

31
00:01:27,400 --> 00:01:30,270
che sto creando un nuovo tipo di dati qui.

32
00:01:30,270 --> 00:01:33,860
In particolare, il nome del tipo di dati è
sta per essere auto struct, come vedremo.

33
00:01:33,860 --> 00:01:36,640
Ma questo è il tipo di punta
off al compilatore che questo

34
00:01:36,640 --> 00:01:42,440
come un gruppo di variabili che sta
da considerarsi parte dello stesso tipo

35
00:01:42,440 --> 00:01:44,010
in un minuto.

36
00:01:44,010 --> 00:01:46,340
>> Automobili, solo il nome della struttura.

37
00:01:46,340 --> 00:01:50,590
Anche in questo caso, il tipo di dati qui sta
di essere auto struct, non solo auto.

38
00:01:50,590 --> 00:01:53,060
Ma se avete different--
se si creano più le strutture

39
00:01:53,060 --> 00:01:56,950
nello stesso programma, è necessario
distinguere tra struct e struct.

40
00:01:56,950 --> 00:02:00,140
Macchina così struct, potrei anche avere
studente struct, per esempio,

41
00:02:00,140 --> 00:02:01,790
nello stesso programma.

42
00:02:01,790 --> 00:02:05,980
All'interno delle parentesi graffe sono
tutti i cosiddetti campi,

43
00:02:05,980 --> 00:02:07,954
o membri della struttura.

44
00:02:07,954 --> 00:02:10,370
Ma quali sono alcune delle cose
che sono inerenti in una macchina?

45
00:02:10,370 --> 00:02:15,270
Ebbene, ha solitamente un anno, ha
un nome del modello, e una targa,

46
00:02:15,270 --> 00:02:18,000
un contachilometri che di solito ha
un determinato numero di miglia su di esso,

47
00:02:18,000 --> 00:02:19,225
e forse una dimensione del motore.

48
00:02:19,225 --> 00:02:23,570
E come potete vedere, sto mescolando
interi e caratteri e doppie.

49
00:02:23,570 --> 00:02:26,420
Sono tutti andando essere
parte di questo nuovo tipo di dati.

50
00:02:26,420 --> 00:02:29,750
>> Infine, l'ultima cosa ho bisogno di fare,
non dimenticare questo piccolo punto e virgola

51
00:02:29,750 --> 00:02:30,290
alla fine.

52
00:02:30,290 --> 00:02:34,380
Dopo avremo finito di definire la struttura,
abbiamo bisogno di mettere un punto e virgola alla fine.

53
00:02:34,380 --> 00:02:37,325
Si tratta di una sintattica molto comune
errore, perché con una funzione,

54
00:02:37,325 --> 00:02:40,200
per esempio, si sarebbe semplicemente
parentesi graffa aprire, chiudere parentesi graffa.

55
00:02:40,200 --> 00:02:42,950
Non mettere un punto e virgola
Dopo una definizione di funzione.

56
00:02:42,950 --> 00:02:46,430
Questo appare come una funzione
definizione, ma non è,

57
00:02:46,430 --> 00:02:49,653
e così il punto e virgola là
è solo un ricordo che si

58
00:02:49,653 --> 00:02:52,440
bisogno di mettere lì, perché
altrimenti il ​​compilatore non

59
00:02:52,440 --> 00:02:53,510
sapere cosa fare con esso.

60
00:02:53,510 --> 00:02:56,160
E 'un errore molto comune
per fare accidentalmente

61
00:02:56,160 --> 00:02:58,570
quando sei prima definizione delle strutture.

62
00:02:58,570 --> 00:02:59,500
>> OK.

63
00:02:59,500 --> 00:03:02,824
Così siamo soliti definire le nostre strutture
al vertice dei nostri programmi

64
00:03:02,824 --> 00:03:05,490
perché sono probabilmente andando
per essere utilizzati da molteplici funzioni.

65
00:03:05,490 --> 00:03:08,850
Non vogliamo definire un
struct all'interno di una funzione,

66
00:03:08,850 --> 00:03:12,110
perché allora possiamo only-- il
perimetro della struttura veramente

67
00:03:12,110 --> 00:03:13,790
esiste solo all'interno di tale funzione.

68
00:03:13,790 --> 00:03:17,450
Probabilmente ci piacerebbe definire una struttura
in modo che possiamo utilizzare in molteplici funzioni,

69
00:03:17,450 --> 00:03:20,670
o forse in più
i file che sono legate insieme

70
00:03:20,670 --> 00:03:22,920
per creare il nostro programma unico.

71
00:03:22,920 --> 00:03:24,920
A volte anche invece
della definizione della struttura

72
00:03:24,920 --> 00:03:27,961
in cima dove si mette il
libbra include e la vostra libbra definisce,

73
00:03:27,961 --> 00:03:32,080
per esempio, si potrebbe metterli in
separati i file dot h, che poi

74
00:03:32,080 --> 00:03:35,020
libbra includere se stessi.

75
00:03:35,020 --> 00:03:37,620
>> Così abbiamo strutture, ma ora
abbiamo bisogno di ottenere dentro di loro.

76
00:03:37,620 --> 00:03:39,800
Come si arriva all'interno di
una struttura di accesso

77
00:03:39,800 --> 00:03:43,530
i sub-variabili, tali variabili
che esistono all'interno della struttura?

78
00:03:43,530 --> 00:03:46,810
Bene, abbiamo qualcosa che si chiama
l'operatore punto, che ci permette

79
00:03:46,810 --> 00:03:50,990
per accedere ai campi della struttura.

80
00:03:50,990 --> 00:03:55,490
Così, per esempio, diciamo che ho dichiarato
tipo da qualche parte i miei dati della struttura

81
00:03:55,490 --> 00:03:59,020
nella parte superiore del mio programma, o forse in
un file puntino h che ho libbra inclusa.

82
00:03:59,020 --> 00:04:03,360
Se poi voglio creare un nuovo
variabili di quel tipo di dati, posso dire,

83
00:04:03,360 --> 00:04:06,260
auto struct, la mia macchina, punto e virgola.

84
00:04:06,260 --> 00:04:11,580
Proprio come potrei dire int
x, o il nome della stringa e virgola.

85
00:04:11,580 --> 00:04:18,100
>> Il tipo di dati: ecco auto struct,
il nome della variabile è la mia macchina,

86
00:04:18,100 --> 00:04:23,770
e poi posso usare l'operatore punto per
accedere ai vari campi della mia macchina.

87
00:04:23,770 --> 00:04:27,494
Quindi posso dire la mia auto
dot anno è uguale a 2011.

88
00:04:27,494 --> 00:04:28,410
Questo è perfettamente bene.

89
00:04:28,410 --> 00:04:34,210
Anno, se vi ricordate, è stata definita come un
campo intero all'interno di questa vettura struct

90
00:04:34,210 --> 00:04:35,200
tipo di dati.

91
00:04:35,200 --> 00:04:39,966
Quindi, qualsiasi variabile dei dati macchina struct
tipo, come la mia macchina, posso dire la mia auto

92
00:04:39,966 --> 00:04:44,030
anno dot uguale e quindi assegnare
ancora un po valore intero 2011.

93
00:04:44,030 --> 00:04:47,290
Il mio piatto auto puntino uguale CS50.

94
00:04:47,290 --> 00:04:51,180
La mia carta dot contachilometri
è uguale a 50505 e virgola.

95
00:04:51,180 --> 00:04:53,270
Tutti questi sono
perfettamente bene e che è

96
00:04:53,270 --> 00:04:57,802
come si accede alla
campi della struttura.

97
00:04:57,802 --> 00:05:00,260
Strutture, però, non hanno bisogno di
da creare in pila.

98
00:05:00,260 --> 00:05:02,950
Proprio come qualsiasi altra variabile, abbiamo
li può allocare dinamicamente.

99
00:05:02,950 --> 00:05:06,309
Se abbiamo un programma che potrebbe
essere generando molte strutture,

100
00:05:06,309 --> 00:05:08,100
non sappiamo quanti
stiamo andando ad avere bisogno,

101
00:05:08,100 --> 00:05:10,800
allora dobbiamo dinamicamente
destinare quelle strutture

102
00:05:10,800 --> 00:05:12,960
come il nostro programma è in esecuzione.

103
00:05:12,960 --> 00:05:16,600
E così, se abbiamo intenzione di accedere al
campi di una struttura in tale contesto,

104
00:05:16,600 --> 00:05:20,660
richiamo che abbiamo prima bisogno di dereference
il puntatore alla struttura,

105
00:05:20,660 --> 00:05:24,810
e poi una volta che il dereference
puntatore, allora si può accedere ai campi.

106
00:05:24,810 --> 00:05:26,830
Se abbiamo solo un
puntatore alla struttura,

107
00:05:26,830 --> 00:05:32,120
non possiamo dire campo puntatore puntino
NOME e ottenere ciò che stiamo cercando.

108
00:05:32,120 --> 00:05:34,259
C'è il passaggio aggiuntivo di dereferencing.

109
00:05:34,259 --> 00:05:36,050
Quindi diciamo che
invece del previous--

110
00:05:36,050 --> 00:05:38,770
Come nell'esempio precedente,
invece di dichiararlo

111
00:05:38,770 --> 00:05:43,680
sullo stack, auto struct, il mio
auto, punto e virgola, dico auto struct,

112
00:05:43,680 --> 00:05:48,020
stella, un puntatore a una
auto struct chiamato la mia macchina,

113
00:05:48,020 --> 00:05:51,250
uguale formato malloc di auto struct.

114
00:05:51,250 --> 00:05:54,950
Dimensioni della faremo capire quanti
byte il nuovo tipo di dati occupa.

115
00:05:54,950 --> 00:05:58,570
Non è necessariamente sufficiente utilizzare
dimensioni, larghezza, int o char, o qualsiasi

116
00:05:58,570 --> 00:05:59,715
dei tipi di dati incorporati.

117
00:05:59,715 --> 00:06:02,090
Il compilatore è abbastanza intelligente
per capire quanti byte

118
00:06:02,090 --> 00:06:04,170
sono richieste, la vostra nuova struttura.

119
00:06:04,170 --> 00:06:09,610
Così ho malloc me una unità della memoria
abbastanza grande da contenere una macchina struct,

120
00:06:09,610 --> 00:06:12,410
e ottengo un puntatore indietro
a tale blocco di memoria,

121
00:06:12,410 --> 00:06:16,090
e tale puntatore viene assegnato alla mia macchina.

122
00:06:16,090 --> 00:06:18,050
>> Ora, se voglio accedere
i campi della mia macchina,

123
00:06:18,050 --> 00:06:22,615
Io prima dereference mia automobile utilizzando
l'operatore dereference, stella

124
00:06:22,615 --> 00:06:26,620
che abbiamo visto dai puntatori
video, e poi dopo aver dereference,

125
00:06:26,620 --> 00:06:32,200
quindi posso usare l'operatore punto per
accedere ai vari campi della mia macchina.

126
00:06:32,200 --> 00:06:35,490
Stella mia macchina puntino anno è pari a 2.011.

127
00:06:35,490 --> 00:06:38,480
Ciò avrebbe l'effetto
vogliamo in questo caso,

128
00:06:38,480 --> 00:06:41,960
perché abbiamo dinamicamente
assegnata la mia macchina.

129
00:06:41,960 --> 00:06:43,610
>> Questo è il genere di fastidioso, però, giusto?

130
00:06:43,610 --> 00:06:44,818
C'è un processo in 2 fasi ora.

131
00:06:44,818 --> 00:06:47,460
Ora dobbiamo dereference--
abbiamo un operatore di stella,

132
00:06:47,460 --> 00:06:48,910
e abbiamo un operatore punto.

133
00:06:48,910 --> 00:06:51,660
E come ci si potrebbe aspettare, perché
I programmatori C amano modi più brevi

134
00:06:51,660 --> 00:06:53,740
fare cose, vi è un
via più breve per fare questo.

135
00:06:53,740 --> 00:06:57,790
C'è un altro operatore chiamato freccia,
che rende questo processo molto più facile.

136
00:06:57,790 --> 00:07:00,750
Il modo in cui funziona è la freccia
è arrivato prima dereferenziazioni

137
00:07:00,750 --> 00:07:03,560
il puntatore a sinistra
lato dell'operatore,

138
00:07:03,560 --> 00:07:06,620
e poi, dopo aver dereferenziato
il puntatore sulla sinistra,

139
00:07:06,620 --> 00:07:09,620
accede al campo a destra.

140
00:07:09,620 --> 00:07:14,170
E così in precedenza abbiamo avuto questo tipo
di Star mia macchina dot tutta questa roba,

141
00:07:14,170 --> 00:07:15,880
come se ci fosse un sacco di cose lì.

142
00:07:15,880 --> 00:07:22,040
Ma quello che possiamo invece fare è questo--
la mia macchina freccia anno è pari a 2.011.

143
00:07:22,040 --> 00:07:23,580
>> Anche in questo caso, quello che sta succedendo qui?

144
00:07:23,580 --> 00:07:25,720
In primo luogo, sto dereference la mia macchina.

145
00:07:25,720 --> 00:07:27,810
Che ancora una volta, è un puntatore qui.

146
00:07:27,810 --> 00:07:31,270
Poi, dopo aver
dereferenziato la mia macchina, io

147
00:07:31,270 --> 00:07:35,130
possono poi accedere ai campi
anno, targa, e contachilometri

148
00:07:35,130 --> 00:07:40,020
proprio come ho potuto prima di avere prima
stella utilizzato per dereferenziare la mia auto,

149
00:07:40,020 --> 00:07:42,020
e dot per accedere al campo.

150
00:07:42,020 --> 00:07:45,290
Così si può avere strutture, è
può avere puntatori a strutture,

151
00:07:45,290 --> 00:07:48,360
e si ha modi per accedere
i campi di queste strutture,

152
00:07:48,360 --> 00:07:52,600
se si dispone di puntatori a
loro o variabili stesse.

153
00:07:52,600 --> 00:07:57,640
Dot o una freccia, a seconda della
come è stato dichiarato la variabile.

154
00:07:57,640 --> 00:08:00,510
Sono Doug Lloyd, questo è CS50.

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