1
00:00:07,632 --> 00:00:10,270
[Powered by Google Translate] GIORDANIA Jozwiak: fusione Type, nel senso più semplice, è un

2
00:00:10,270 --> 00:00:13,300
modo di alterare l'interpretazione di un computer di alcuni dati da

3
00:00:13,300 --> 00:00:16,560
implicitamente o esplicitamente modificando il tipo di dati.

4
00:00:16,560 --> 00:00:19,940
Come cambiare un int in un float, o viceversa.

5
00:00:19,940 --> 00:00:21,550
Per capire cast di tipo, abbiamo bisogno di

6
00:00:21,550 --> 00:00:22,680
iniziare con le basi -

7
00:00:22,680 --> 00:00:24,140
tipi di dati stessi.

8
00:00:24,140 --> 00:00:26,960
In linguaggi di programmazione come C, tutte le variabili hanno un qualche tipo

9
00:00:26,960 --> 00:00:29,690
del tipo di dati che determina come il computer, e similmente

10
00:00:29,690 --> 00:00:32,140
l'utente, interpreta quella variabile.

11
00:00:32,140 --> 00:00:35,160
Tipi di dati numerici, come un int, long long, float e

12
00:00:35,160 --> 00:00:38,110
doppie, tutte hanno le loro caratteristiche uniche e sono

13
00:00:38,110 --> 00:00:41,370
utilizzato per specificare i valori di diverse gamme e precisione.

14
00:00:41,370 --> 00:00:44,800
Tipo di fusione ci permette di prendere un numero in virgola mobile come

15
00:00:44,800 --> 00:00:49,170
3.14 e ottenere la parte prima del decimale, 3 in questo caso,

16
00:00:49,170 --> 00:00:51,590
per il cast a int.

17
00:00:51,590 --> 00:00:53,900
Prendiamo un esempio dalla lingua inglese per un breve

18
00:00:53,900 --> 00:00:56,910
revisione dei tipi, e per vedere come casting di tipo può cambiare

19
00:00:56,910 --> 00:00:59,380
il nostro modo di interpretare un pezzo di dati.

20
00:00:59,380 --> 00:01:05,269
Per i dati, prendiamo i simboli qui.

21
00:01:05,269 --> 00:01:07,570
Ho solo fare riferimento a queste linee attentamente configurati come

22
00:01:07,570 --> 00:01:10,100
simboli, ma come qualcuno che conosce la lingua inglese,

23
00:01:10,100 --> 00:01:12,750
si riconosce immediatamente che essi sono, infatti, lettere.

24
00:01:12,750 --> 00:01:15,580
È implicitamente inteso il tipo di dati.

25
00:01:15,580 --> 00:01:17,620
Guardando questa stringa di lettere che possiamo vedere due

26
00:01:17,620 --> 00:01:20,140
parole diverse, ognuna con un proprio significato.

27
00:01:20,140 --> 00:01:25,530
C'è il nome, il vento, come il vento soffia in esterni.

28
00:01:25,530 --> 00:01:28,280
E c'è il verbo, il vento, come in ho bisogno di

29
00:01:28,280 --> 00:01:31,410
vento il mio orologio analogico.

30
00:01:31,410 --> 00:01:33,420
Questo è un esempio interessante, perché possiamo vedere

31
00:01:33,420 --> 00:01:36,270
come il tipo che assegniamo ai nostri dati, sia sostantivo o

32
00:01:36,270 --> 00:01:39,080
verbo, cambia il modo che usiamo questi dati -

33
00:01:39,080 --> 00:01:41,730
come il vento parola o vento.

34
00:01:41,730 --> 00:01:44,100
Anche se un computer non si preoccupa di grammatica e parti

35
00:01:44,100 --> 00:01:47,750
di parola inglese, lo stesso principio di base si applica.

36
00:01:47,750 --> 00:01:50,290
In altre parole, siamo in grado di cambiare l'interpretazione della esatta

37
00:01:50,290 --> 00:01:53,140
stessi dati in memoria, semplicemente colata ad una

38
00:01:53,140 --> 00:01:54,576
tipo diverso.

39
00:01:54,576 --> 00:01:57,250
Qui sono le dimensioni dei tipi più comuni su un 32-bit

40
00:01:57,250 --> 00:01:58,340
sistema operativo.

41
00:01:58,340 --> 00:02:02,070
Abbiamo un char a 1 byte, int e float a 4 byte, un lungo

42
00:02:02,070 --> 00:02:04,390
lunga e una doppia a 8 byte.

43
00:02:04,390 --> 00:02:07,670
Dato che un int occupa 4 byte, ci vorranno 32 bit

44
00:02:07,670 --> 00:02:10,060
quando viene memorizzato come una serie binaria

45
00:02:10,060 --> 00:02:11,500
di zero e uno.

46
00:02:11,500 --> 00:02:14,020
Fino a quando la nostra variabile rimane un tipo int, il

47
00:02:14,020 --> 00:02:16,740
computer sarà sempre convertire i uni e zeri di

48
00:02:16,740 --> 00:02:19,120
binario nel numero originale.

49
00:02:19,120 --> 00:02:21,270
Tuttavia, si potrebbe teoricamente lanciare quelle 32

50
00:02:21,270 --> 00:02:23,510
bit in una serie di tipi booleani.

51
00:02:23,510 --> 00:02:26,090
E poi il computer non sarebbe più vedere un numero, ma

52
00:02:26,090 --> 00:02:28,810
invece una serie di zero e uno.

53
00:02:28,810 --> 00:02:31,570
Si potrebbe anche provare a leggere i dati come un valore numerico diverso

54
00:02:31,570 --> 00:02:34,660
tipo, o anche come una stringa di quattro caratteri.

55
00:02:34,660 --> 00:02:37,820
Quando si tratta di numeri in fusione, è necessario considerare come

56
00:02:37,820 --> 00:02:40,470
la precisione del tuo valore sarà influenzato.

57
00:02:40,470 --> 00:02:43,240
Tenete a mente che la precisione può restare lo stesso,

58
00:02:43,240 --> 00:02:47,150
o si può perdere la precisione, ma non si può mai guadagnare in precisione.

59
00:02:47,150 --> 00:02:49,060
Andiamo attraverso i tre modi più comuni che è possibile

60
00:02:49,060 --> 00:02:50,400
perdere precisione.

61
00:02:50,400 --> 00:02:53,060
Lanciare una float in un int causerà troncamento di tutto

62
00:02:53,060 --> 00:02:54,900
dopo la virgola, quindi si è lasciato

63
00:02:54,900 --> 00:02:55,950
con il numero intero.

64
00:02:55,950 --> 00:03:02,000
Se prendiamo la x galleggiante che sarà uguale a 3.7, si può lanciare

65
00:03:02,000 --> 00:03:05,580
questa variabile x in un int semplicemente scrivendo int in

66
00:03:05,580 --> 00:03:07,050
parentesi.

67
00:03:07,050 --> 00:03:10,010
Ogni volta che usiamo questo termine qui, faremo in modo efficace

68
00:03:10,010 --> 00:03:12,810
utilizzare il valore di tre perché abbiamo troncato

69
00:03:12,810 --> 00:03:14,880
tutto dopo il punto decimale.

70
00:03:14,880 --> 00:03:17,210
Possiamo anche convertire un lungo tempo per un int, che sarà

71
00:03:17,210 --> 00:03:20,760
similmente portare a una perdita di bit di ordine superiore.

72
00:03:20,760 --> 00:03:23,910
Una lunga lunga occupa 8 byte, o 64 bit in memoria.

73
00:03:23,910 --> 00:03:27,050
Così, quando il cast ad un int che ha solo 4 byte, o 32

74
00:03:27,050 --> 00:03:29,820
bit, stiamo essenzialmente tagliando tutti i bit che

75
00:03:29,820 --> 00:03:32,420
rappresentano i valori binari superiori.

76
00:03:32,420 --> 00:03:34,690
Si potrebbe anche lanciare un doppio di un galleggiante, che darà

77
00:03:34,690 --> 00:03:37,340
si il galleggiante più vicino possibile al doppio senza

78
00:03:37,340 --> 00:03:39,100
necessariamente arrotondamento.

79
00:03:39,100 --> 00:03:41,840
Simile al nostro long long int alla conversione, la perdita di

80
00:03:41,840 --> 00:03:44,890
precisione perché un doppio contiene più dati.

81
00:03:44,890 --> 00:03:47,910
Un doppio permette di memorizzare 53 bit significativi,

82
00:03:47,910 --> 00:03:50,650
circa 16 cifre significative.

83
00:03:50,650 --> 00:03:53,050
Considerando che un galleggiante solo consentirà di memorizzare 24

84
00:03:53,050 --> 00:03:56,235
bit significativi, circa sette cifre significative.

85
00:03:56,235 --> 00:03:58,700
In questi ultimi due casi, può essere utile pensare

86
00:03:58,700 --> 00:04:01,200
digitare fusione il ridimensionamento di una foto.

87
00:04:01,200 --> 00:04:03,860
Quando si passa da una dimensione di grandi dimensioni a una dimensione piccola, non si può vedere

88
00:04:03,860 --> 00:04:05,600
le cose nel modo più chiaro perché hai perso i dati

89
00:04:05,600 --> 00:04:07,530
sotto forma di pixel.

90
00:04:07,530 --> 00:04:09,270
Tipo di fusione può anche causare problemi quando si

91
00:04:09,270 --> 00:04:11,050
gettato int a float.

92
00:04:11,050 --> 00:04:13,920
Dal momento che galleggia su una macchina a 32 bit solo 24

93
00:04:13,920 --> 00:04:16,959
bit significativi, essi non possono rappresentare accuratamente valori

94
00:04:16,959 --> 00:04:22,750
oltre 2 alla potenza di 24, o 16.777.217.

95
00:04:22,750 --> 00:04:25,540
Ora parliamo di cast esplicito e implicito.

96
00:04:25,540 --> 00:04:28,000
Fusione esplicita è quando scriviamo il tipo tra parentesi

97
00:04:28,000 --> 00:04:29,430
prima di un nome di variabile.

98
00:04:29,430 --> 00:04:33,100
Per fare un esempio, prima di int scritto tra parentesi prima del nostro

99
00:04:33,100 --> 00:04:35,640
float variabile x.

100
00:04:35,640 --> 00:04:37,200
In questo modo, si ottiene il valore di int, il

101
00:04:37,200 --> 00:04:38,593
valore troncato di 3,7 -

102
00:04:38,593 --> 00:04:40,370
3.

103
00:04:40,370 --> 00:04:42,970
Cast implicito è quando il compilatore cambia automaticamente

104
00:04:42,970 --> 00:04:46,340
tipi simili a un super tipo, o esegue qualche altro tipo di

105
00:04:46,340 --> 00:04:48,310
colata senza richiedere all'utente di scrivere

106
00:04:48,310 --> 00:04:49,720
alcun codice aggiuntivo.

107
00:04:49,720 --> 00:04:53,550
Per esempio, quando si aggiungono 5 e 1.1, i nostri valori già

108
00:04:53,550 --> 00:04:55,680
tipi ad essi associati.

109
00:04:55,680 --> 00:04:59,480
Il 5 è un int, mentre 1.1 è un float.

110
00:04:59,480 --> 00:05:02,390
Per aggiungerli, il computer getta 5 in un float,

111
00:05:02,390 --> 00:05:04,530
che sarebbe stata la stessa cosa che scrivere 5.0 nella

112
00:05:04,530 --> 00:05:06,476
primo posto.

113
00:05:06,476 --> 00:05:13,210
Ma in questo modo diciamo galleggiante 5 o 5.0, oltre a ciò che era già

114
00:05:13,210 --> 00:05:16,960
un galleggiante, 1.1, e da lì si può aggiungere questi

115
00:05:16,960 --> 00:05:18,640
valori e ottenere il valore di 6.1.

116
00:05:21,170 --> 00:05:23,500
Cast implicito ci permette anche di assegnare le variabili di

117
00:05:23,500 --> 00:05:25,590
tipi diversi tra loro.

118
00:05:25,590 --> 00:05:28,110
Possiamo sempre assegnare un tipo meno preciso in un più

119
00:05:28,110 --> 00:05:29,250
uno precisa.

120
00:05:29,250 --> 00:05:37,060
Per esempio, se abbiamo una doppia x, y e un int -

121
00:05:37,060 --> 00:05:40,120
e questi potrebbero avere tutti i valori che li impostati -

122
00:05:40,120 --> 00:05:43,560
si può dire x è uguale a y.

123
00:05:43,560 --> 00:05:46,340
Poiché la doppia ha una maggiore precisione di un int, quindi abbiamo

124
00:05:46,340 --> 00:05:48,380
non perdere alcuna informazione.

125
00:05:48,380 --> 00:05:50,420
D'altra parte, non sarebbe necessariamente corretto dire

126
00:05:50,420 --> 00:05:54,060
y è uguale a x, perché la doppia potrebbe avere un valore maggiore di

127
00:05:54,060 --> 00:05:55,220
il numero intero.

128
00:05:55,220 --> 00:05:57,420
E così l'intero potrebbe non essere in grado di contenere tutti i

129
00:05:57,420 --> 00:05:59,560
informazioni memorizzate nel doppio.

130
00:05:59,560 --> 00:06:02,610
Cast implicito è utilizzato anche in operatori di confronto come

131
00:06:02,610 --> 00:06:06,410
superiore, inferiore, o l'operatore di uguaglianza.

132
00:06:06,410 --> 00:06:13,050
In questo modo siamo in grado di dire se 5.1 è maggiore di 5, e si ottiene il

133
00:06:13,050 --> 00:06:14,750
risultato vero.

134
00:06:14,750 --> 00:06:18,470
Poiché 5 è un int, ma sarà lanciato ad un galleggiante, al fine di

135
00:06:18,470 --> 00:06:22,090
essere confrontato con il galleggiante 5.1, diremmo 5.1 è

136
00:06:22,090 --> 00:06:24,550
superiore a 5,0.

137
00:06:24,550 --> 00:06:31,320
Lo stesso vale con dire se è uguale a 2,0 è uguale a 2.

138
00:06:31,320 --> 00:06:34,190
Ci piacerebbe anche avere vero, perché il computer sarà il cast

139
00:06:34,190 --> 00:06:39,750
intero 2 a stare a galla e poi dire 2,0 è uguale uguale a 2.0,

140
00:06:39,750 --> 00:06:41,660
questo è vero.

141
00:06:41,660 --> 00:06:44,180
Non dimenticate che siamo in grado di lanciare tra interi e caratteri,

142
00:06:44,180 --> 00:06:46,350
o valori ASCII.

143
00:06:46,350 --> 00:06:49,690
Chars anche bisogno di essere ridotto a binario, che è il motivo per

144
00:06:49,690 --> 00:06:51,920
può convertire facilmente tra i caratteri e le loro rispettive

145
00:06:51,920 --> 00:06:53,260
Valori ASCII.

146
00:06:53,260 --> 00:06:56,180
Per ulteriori informazioni su questo, la nostra video su ASCII.

147
00:06:56,180 --> 00:06:58,080
Quando si prende un momento per pensare a come i dati memorizzato,

148
00:06:58,080 --> 00:06:59,990
comincia a fare un sacco di senso.

149
00:06:59,990 --> 00:07:02,790
E 'come la differenza tra il vento e il vento.

150
00:07:02,790 --> 00:07:05,490
Dati è la stessa, ma il tipo si può cambiare il modo

151
00:07:05,490 --> 00:07:06,720
interpretarla.

152
00:07:06,720 --> 00:07:10,430
Il mio nome è Jordan Jozwiak, questo CS50.