1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] Parliamo di array.

2
00:00:09,360 --> 00:00:12,780
Quindi, perché si vuole usare gli array?

3
00:00:12,780 --> 00:00:17,210
Beh diciamo che hai un programma che ha bisogno di memorizzare 5 ID studenti.

4
00:00:17,210 --> 00:00:21,270
Potrebbe sembrare ragionevole avere 5 variabili separate.

5
00:00:21,270 --> 00:00:24,240
Per motivi che vedremo tra un po ', iniziamo a contare da 0.

6
00:00:24,240 --> 00:00:30,700
Le variabili che dovrete sarà id0 int, int id1, e così via.

7
00:00:30,700 --> 00:00:34,870
La logica che vogliamo eseguire su un ID studente dovrà essere copiato e incollato

8
00:00:34,870 --> 00:00:36,870
per ciascuno di questi ID studenti.

9
00:00:36,870 --> 00:00:39,710
Se vogliamo verificare quali studenti capita di essere in CS50,

10
00:00:39,710 --> 00:00:43,910
avremo prima bisogno di verificare se id0 rappresenta lo studente al corso.

11
00:00:43,910 --> 00:00:48,070
Poi, per fare la stessa cosa per lo studente successivo, avremo bisogno di copiare e incollare il codice per ID0

12
00:00:48,070 --> 00:00:54,430
e sostituire tutte le occorrenze di id0 con id1 e così via per id2, 3, e 4.

13
00:00:54,430 --> 00:00:57,560
>> Non appena si sente che abbiamo bisogno di copiare e incollare,

14
00:00:57,560 --> 00:01:00,440
si dovrebbe cominciare a pensare che ci sia una soluzione migliore.

15
00:01:00,440 --> 00:01:05,360
Ora, cosa succede se ti rendi conto che non è bisogno di 5 ID studente, ma piuttosto 7?

16
00:01:05,360 --> 00:01:09,570
Hai bisogno di andare indietro nel codice sorgente e aggiungere in un ID5, un id6,

17
00:01:09,570 --> 00:01:14,260
e copiare e incollare la logica per verificare se gli ID appartengono alla classe di questi 2 nuovi ID.

18
00:01:14,260 --> 00:01:19,600
Non vi è nulla che collega tutti questi ID insieme, e quindi non c'è modo di chiedere

19
00:01:19,600 --> 00:01:22,040
il programma di fare questo per gli ID da 0 a 6.

20
00:01:22,040 --> 00:01:26,120
Bene, ora ci si rende conto di avere 100 studenti ID.

21
00:01:26,120 --> 00:01:30,770
Sta cominciando a sembrare meno ideale per necessità di dichiarare separatamente ciascuno di questi ID,

22
00:01:30,770 --> 00:01:33,760
e copiare e incollare qualsiasi logica per i nuovi ID.

23
00:01:33,760 --> 00:01:38,380
Ma forse siamo determinati, e lo facciamo per tutti i 100 studenti.

24
00:01:38,380 --> 00:01:42,240
Ma cosa succede se non si sa quanti studenti ci sono in realtà?

25
00:01:42,240 --> 00:01:47,320
Ci sono solo alcuni studenti n e il programma deve chiedere all'utente cosa che n è.

26
00:01:47,320 --> 00:01:50,250
Uh oh. Questo non è di andare a lavorare molto bene.

27
00:01:50,250 --> 00:01:53,820
Il programma funziona solo per qualche numero costante di studenti.

28
00:01:53,820 --> 00:01:57,520
>> Risolvere tutti questi problemi è la bellezza di array.

29
00:01:57,520 --> 00:01:59,930
Così che cosa è un array?

30
00:01:59,930 --> 00:02:04,480
In alcuni linguaggi di programmazione di un tipo di matrice potrebbe essere in grado di fare un po 'di più,

31
00:02:04,480 --> 00:02:09,960
ma qui ci concentreremo sulla struttura di base di dati di matrice così come lo vedrai in C.

32
00:02:09,960 --> 00:02:14,030
Un array è solo un grande blocco di memoria. Tutto qui.

33
00:02:14,030 --> 00:02:17,770
Quando diciamo che abbiamo un array di 10 interi, che significa semplicemente che abbiamo un po 'di blocco

34
00:02:17,770 --> 00:02:20,740
di memoria che è abbastanza grande da contenere 10 interi separati.

35
00:02:29,930 --> 00:02:33,410
Supponendo che un numero intero di 4 byte, questo significa che un array di 10 interi

36
00:02:33,410 --> 00:02:37,180
è un blocco continuo di 40 byte in memoria.

37
00:02:42,660 --> 00:02:46,280
Anche quando si utilizzano array multidimensionali, che non andranno in a qui,

38
00:02:46,280 --> 00:02:49,200
è ancora solo un grosso blocco di memoria.

39
00:02:49,200 --> 00:02:51,840
La notazione multidimensionale è solo una comodità.

40
00:02:51,840 --> 00:02:55,640
Se avete un 3 a 3 matrice multidimensionale di interi,

41
00:02:55,640 --> 00:03:00,650
allora il vostro programma in realtà solo considerare questo come un grosso blocco di 36 byte.

42
00:03:00,650 --> 00:03:05,460
Il numero totale di interi è 3 volte 3, e ciascun intero occupa 4 byte.

43
00:03:05,460 --> 00:03:07,750
>> Diamo un'occhiata a un esempio di base.

44
00:03:07,750 --> 00:03:10,660
Possiamo vedere qui 2 modi diversi di matrici che dichiarano.

45
00:03:15,660 --> 00:03:18,580
Dovremo commentare uno di loro fuori per il programma per la compilazione

46
00:03:18,580 --> 00:03:20,900
poiché noi dichiariamo x due volte.

47
00:03:20,900 --> 00:03:25,140
Daremo uno sguardo ad alcune delle differenze tra questi 2 tipi di dichiarazioni in un po '.

48
00:03:25,140 --> 00:03:28,560
Entrambe queste linee di dichiarare un array di dimensione n,

49
00:03:28,560 --> 00:03:30,740
dove abbiamo # define N, 10.

50
00:03:30,740 --> 00:03:34,460
Si potrebbe facilmente hanno chiesto all'utente di specificare un numero intero positivo

51
00:03:34,460 --> 00:03:37,250
e utilizzato come numero intero che un certo numero di elementi nella nostra matrice.

52
00:03:37,250 --> 00:03:41,960
Come il nostro esempio ID studente prima, questo è un po 'come dichiarare completamente separati 10

53
00:03:41,960 --> 00:03:49,000
variabili immaginario; x0, x1, x2, e così via fino a xN-1.

54
00:03:57,270 --> 00:04:00,840
Ignorando le linee in cui si dichiara l'array, notare le parentesi quadre intatte

55
00:04:00,840 --> 00:04:02,090
all'interno di cicli.

56
00:04:02,090 --> 00:04:09,660
Quando si scrive qualcosa di simile x [3], che mi limiterò a leggere come x staffa 3,

57
00:04:09,660 --> 00:04:13,090
si può pensare a come chiedere l'immaginario x3.

58
00:04:13,090 --> 00:04:17,519
Notare che con un array di dimensione N, questo significa che il numero all'interno delle parentesi,

59
00:04:17,519 --> 00:04:22,630
che chiameremo l'indice, può essere qualsiasi cosa, da 0 a N-1,

60
00:04:22,630 --> 00:04:25,660
che è un totale di indici n.

61
00:04:25,660 --> 00:04:28,260
>> Per riflettere su come questo funziona davvero

62
00:04:28,260 --> 00:04:31,260
ricordare che la matrice è un grosso blocco di memoria.

63
00:04:31,260 --> 00:04:37,460
Supponendo che un numero intero è di 4 byte, l'x intero array è un blocco 40 byte di memoria.

64
00:04:37,460 --> 00:04:41,360
Quindi x0 si riferisce ai primi 4 byte del blocco.

65
00:04:45,810 --> 00:04:49,230
X [1] si riferisce ai successivi 4 byte e così via.

66
00:04:49,230 --> 00:04:53,760
Ciò significa che l'inizio di x è mai tutto il programma deve tenere traccia di.

67
00:04:55,660 --> 00:04:59,840
Se si desidera utilizzare x [400], il programma sa che questo è equivalente

68
00:04:59,840 --> 00:05:03,460
a soli 1600 byte dopo l'inizio della x.

69
00:05:03,460 --> 00:05:08,780
Dove si ottiene 1.600 byte da? E 'a soli 400 volte 4 byte per intero.

70
00:05:08,780 --> 00:05:13,170
>> Prima di procedere, è molto importante rendersi conto che in C

71
00:05:13,170 --> 00:05:17,080
non vi è alcuna applicazione dell'indice che usiamo nella matrice.

72
00:05:17,080 --> 00:05:23,180
Il nostro grande blocco è a soli 10 numeri interi a lungo, ma non griderà contro di noi se scriviamo x [20]

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

74
00:05:26,060 --> 00:05:28,240
L'indice non ha nemmeno bisogno di essere un numero.

75
00:05:28,240 --> 00:05:30,630
Può essere qualsiasi espressione arbitraria.

76
00:05:30,630 --> 00:05:34,800
Nel programma si usa la variabile i del ciclo for per indice nella matrice.

77
00:05:34,800 --> 00:05:40,340
Questo è un modello molto comune, loop da i = 0 alla lunghezza della matrice,

78
00:05:40,340 --> 00:05:43,350
e poi ho utilizzando come indice per l'array.

79
00:05:43,350 --> 00:05:46,160
In questo modo in modo efficace ciclo sull'intera matrice,

80
00:05:46,160 --> 00:05:50,600
ed è possibile assegnare ad ogni punto della matrice o utilizzarlo per un po 'di calcolo.

81
00:05:50,600 --> 00:05:53,920
>> Nel primo ciclo for, i inizia a 0,

82
00:05:53,920 --> 00:05:58,680
e così sarà assegnare al punto 0 nella matrice, il valore 0 volte 2.

83
00:05:58,680 --> 00:06:04,370
Poi i passi, e si assegna il primo posto nella matrice il valore 1 volte 2.

84
00:06:04,370 --> 00:06:10,170
Poi i passi di nuovo e così via fino a quando si assegna alla posizione N-1 nella matrice

85
00:06:10,170 --> 00:06:13,370
il valore di N-1 2 volte.

86
00:06:13,370 --> 00:06:17,810
Per questo abbiamo creato un array con i primi 10 numeri pari.

87
00:06:17,810 --> 00:06:21,970
Evens Forse sarebbe stato un po 'meglio il nome della variabile di x,

88
00:06:21,970 --> 00:06:24,760
ma che avrebbe dato via le cose.

89
00:06:24,760 --> 00:06:30,210
Il secondo ciclo for poi a stampare i valori che abbiamo già memorizzati all'interno della matrice.

90
00:06:30,210 --> 00:06:33,600
>> Proviamo eseguire il programma con entrambi i tipi di dichiarazioni di matrice

91
00:06:33,600 --> 00:06:36,330
e dare un'occhiata all'uscita del programma.

92
00:06:51,450 --> 00:06:57,020
Per quanto si può vedere, il programma si comporta allo stesso modo per entrambi i tipi di dichiarazioni.

93
00:06:57,020 --> 00:07:02,230
Diamo anche un'occhiata a cosa succede se cambiamo il primo ciclo di non fermare a N

94
00:07:02,230 --> 00:07:05,040
ma piuttosto dire 10.000.

95
00:07:05,040 --> 00:07:07,430
Ben oltre la fine della matrice.

96
00:07:14,700 --> 00:07:17,210
Oops. Forse avete visto questo prima.

97
00:07:17,210 --> 00:07:20,440
Un errore di segmentazione significa che il programma è andato in crash.

98
00:07:20,440 --> 00:07:24,430
Si inizia a vedere questi quando si tocca le aree di memoria non si deve toccare.

99
00:07:24,430 --> 00:07:27,870
Qui stiamo toccando 10.000 posti oltre l'inizio di x,

100
00:07:27,870 --> 00:07:31,920
che è evidentemente un posto nella memoria non si deve toccare.

101
00:07:31,920 --> 00:07:37,690
Così la maggior parte di noi probabilmente non sarebbe accidentalmente messo 10000 al posto di N,

102
00:07:37,690 --> 00:07:42,930
ma cosa succede se facciamo qualcosa di più sottile, come dire di scrittura inferiore o uguale a N

103
00:07:42,930 --> 00:07:46,830
nella condizione di ciclo rispetto a meno di N.

104
00:07:46,830 --> 00:07:50,100
Ricordate che un array ha solo indici da 0 a N-1,

105
00:07:50,100 --> 00:07:54,510
il che significa che è indice N oltre la fine della matrice.

106
00:07:54,510 --> 00:07:58,050
Il programma non può andare in crash in questo caso, ma è ancora un errore.

107
00:07:58,050 --> 00:08:01,950
In realtà, questo errore è così comune che ha il suo nome,

108
00:08:01,950 --> 00:08:03,970
un off da 1 errore.

109
00:08:03,970 --> 00:08:05,970
>> Questo è tutto per le basi.

110
00:08:05,970 --> 00:08:09,960
Quindi quali sono le principali differenze tra i 2 tipi di dichiarazioni di matrice?

111
00:08:09,960 --> 00:08:13,960
Una differenza è dove il grande blocco di memoria va.

112
00:08:13,960 --> 00:08:17,660
Nella prima dichiarazione, che chiamerò la staffa-array di tipo,

113
00:08:17,660 --> 00:08:20,300
anche se questo non è affatto un nome convenzionale,

114
00:08:20,300 --> 00:08:22,480
andrà in pila.

115
00:08:22,480 --> 00:08:27,450
Considerando che, nella seconda, che chiamerò il puntatore-array di tipo, andrà sul mucchio.

116
00:08:27,450 --> 00:08:32,480
Ciò significa che quando la funzione ritorna, la matrice staffa verrà automaticamente deallocato,

117
00:08:32,480 --> 00:08:36,419
che, come si deve chiamare explicitily libero sull'array puntatore

118
00:08:36,419 --> 00:08:38,010
oppure si ha una perdita di memoria.

119
00:08:38,010 --> 00:08:42,750
Inoltre, la matrice di supporto non è in realtà una variabile.

120
00:08:42,750 --> 00:08:45,490
Questo è importante. E 'solo un simbolo.

121
00:08:45,490 --> 00:08:49,160
Si può pensare ad esso come una costante che il compilatore sceglie per voi.

122
00:08:49,160 --> 00:08:52,970
Ciò significa che non si può fare qualcosa di simile x + + con il tipo di supporto,

123
00:08:52,970 --> 00:08:56,240
anche se questo è perfettamente valido con il tipo di puntatore.

124
00:08:56,240 --> 00:08:58,270
>> Il tipo di puntatore è una variabile.

125
00:08:58,270 --> 00:09:01,510
Per il tipo di puntatore, abbiamo due blocchi distinti di memoria.

126
00:09:01,510 --> 00:09:06,060
La variabile x stesso viene memorizzato nella pila ed è solo un singolo puntatore,

127
00:09:06,060 --> 00:09:08,620
ma il grande blocco di memoria è memorizzato sul mucchio.

128
00:09:08,620 --> 00:09:11,010
La variabile x nello stack memorizza solo l'indirizzo

129
00:09:11,010 --> 00:09:14,010
del grande blocco di memoria sul mucchio.

130
00:09:14,010 --> 00:09:17,370
Una conseguenza di ciò è la dimensione dell'operatore.

131
00:09:17,370 --> 00:09:22,480
Se chiedete la dimensione della matrice supporto, vi darà la dimensione del grande blocco di memoria,

132
00:09:22,480 --> 00:09:24,620
qualcosa come 40 byte,

133
00:09:24,620 --> 00:09:26,920
ma se chiedete per la dimensione del tipo di puntatore di array,

134
00:09:26,920 --> 00:09:32,740
vi darà la dimensione della variabile x stesso, che l'apparecchio è probabile soli 4 byte.

135
00:09:32,740 --> 00:09:36,530
Usando il puntatore-array di tipo, non è possibile chiedere direttamente

136
00:09:36,530 --> 00:09:38,530
la dimensione del grande blocco di memoria.

137
00:09:38,530 --> 00:09:42,530
Questo di solito non è molto più di una restrizione dato che molto raramente desidera che la dimensione

138
00:09:42,530 --> 00:09:46,980
del grande blocco di memoria, e siamo in grado di calcolare se di solito ne abbiamo bisogno.

139
00:09:46,980 --> 00:09:51,490
>> Infine, la matrice staffa succede a fornirci una scorciatoia per l'inizializzazione di un array.

140
00:09:51,490 --> 00:09:56,130
Vediamo come possiamo scrivere i primi 10 numeri interi, anche utilizzando il initilization di scelta rapida.

141
00:10:11,220 --> 00:10:14,470
Con l'array puntatore, non c'è un modo per fare un collegamento come questo.

142
00:10:14,470 --> 00:10:18,120
Questa è solo un'introduzione a ciò che si può fare con gli array.

143
00:10:18,120 --> 00:10:20,990
La loro presenza in quasi tutti i programmi che scrivi.

144
00:10:20,990 --> 00:10:24,390
Speriamo che ora è possibile vedere un modo migliore di fare l'esempio degli studenti ID

145
00:10:24,390 --> 00:10:26,710
dall'inizio del video.

146
00:10:26,710 --> 00:10:29,960
>> Il mio nome è Rob Bowden, e questo è CS50.