1
00:00:07,632 --> 00:00:10,270
[Powered by Google Translate] JORDANIEN JOZWIAK: Typ gjutning, i den enklaste mening, är en

2
00:00:10,270 --> 00:00:13,300
sätt att ändra en dators tolkning av vissa uppgifter från

3
00:00:13,300 --> 00:00:16,560
implicit eller explicit ändra dess datatyp.

4
00:00:16,560 --> 00:00:19,940
Såsom ändring en int till en flottör, eller vice versa.

5
00:00:19,940 --> 00:00:21,550
För att förstå typ gjutning, behöver vi

6
00:00:21,550 --> 00:00:22,680
börja med grunderna -

7
00:00:22,680 --> 00:00:24,140
datatyper själva.

8
00:00:24,140 --> 00:00:26,960
I datorn språk som C, samtliga variabler har någon form

9
00:00:26,960 --> 00:00:29,690
av datatyp som avgör hur datorn och likaså

10
00:00:29,690 --> 00:00:32,140
användaren tolkar den variabeln.

11
00:00:32,140 --> 00:00:35,160
Numeriska datatyper som en int, lång lång, float och

12
00:00:35,160 --> 00:00:38,110
dubbel, alla har sina egna unika egenskaper och är

13
00:00:38,110 --> 00:00:41,370
används för att ange värden för olika områden och precision.

14
00:00:41,370 --> 00:00:44,800
Typ gjutning kan vi ta ett flyttal som

15
00:00:44,800 --> 00:00:49,170
3,14 och få del innan decimal, 3 i detta fall,

16
00:00:49,170 --> 00:00:51,590
genom att kasta den till en int.

17
00:00:51,590 --> 00:00:53,900
Låt oss ta ett exempel från det engelska språket för en kort

18
00:00:53,900 --> 00:00:56,910
granskning av olika typer, och för att se hur typ gjutning kan förändra

19
00:00:56,910 --> 00:00:59,380
hur vi tolkar en bit data.

20
00:00:59,380 --> 00:01:05,269
För data, låt oss ta symbolerna här.

21
00:01:05,269 --> 00:01:07,570
Jag tänker bara på dessa noggrant konfigurerade linjer som

22
00:01:07,570 --> 00:01:10,100
symboler, utan som någon som vet det engelska språket,

23
00:01:10,100 --> 00:01:12,750
du inser genast att de i själva verket bokstäver.

24
00:01:12,750 --> 00:01:15,580
Du förstod implicit datatypen.

25
00:01:15,580 --> 00:01:17,620
Titta på denna rad bokstäver kan vi se två

26
00:01:17,620 --> 00:01:20,140
olika ord, var och en med sin egen mening.

27
00:01:20,140 --> 00:01:25,530
Där är substantiv, vind, liksom i det blåser utanför.

28
00:01:25,530 --> 00:01:28,280
Och det finns verbet, vind, som i jag behöver

29
00:01:28,280 --> 00:01:31,410
wind min analoga klocka.

30
00:01:31,410 --> 00:01:33,420
Detta är ett intressant exempel, eftersom vi kan se

31
00:01:33,420 --> 00:01:36,270
hur den typ som vi tilldelar våra data, oavsett om substantiv eller

32
00:01:36,270 --> 00:01:39,080
verb, ändrar hur vi använder dessa data -

33
00:01:39,080 --> 00:01:41,730
som ordet vinden eller vind.

34
00:01:41,730 --> 00:01:44,100
Även om en dator inte bryr sig om grammatik och delar

35
00:01:44,100 --> 00:01:47,750
engelska tal gäller samma grundprincip.

36
00:01:47,750 --> 00:01:50,290
Det är, kan vi ändra tolkningen av den exakta

37
00:01:50,290 --> 00:01:53,140
samma data som lagras i minnet genom gjutning helt enkelt till en

38
00:01:53,140 --> 00:01:54,576
annan typ.

39
00:01:54,576 --> 00:01:57,250
Här är storleken på de vanligaste typerna på en 32-bitars

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

41
00:01:58,340 --> 00:02:02,070
Vi har en röding på 1 byte, int och float på 4 byte, en lång

42
00:02:02,070 --> 00:02:04,390
lång och en dubbel på 8 byte.

43
00:02:04,390 --> 00:02:07,670
Eftersom en int tar upp 4 byte, kommer det att ta upp 32 bitar

44
00:02:07,670 --> 00:02:10,060
när den lagras i minnet som en binär serie

45
00:02:10,060 --> 00:02:11,500
av nollor och ettor.

46
00:02:11,500 --> 00:02:14,020
Så länge vår variabel är som en typ int, den

47
00:02:14,020 --> 00:02:16,740
Datorn kommer alltid konvertera dessa ettor och nollor från

48
00:02:16,740 --> 00:02:19,120
binär i det ursprungliga antalet.

49
00:02:19,120 --> 00:02:21,270
Men vi kunde kasta teoretiskt de 32

50
00:02:21,270 --> 00:02:23,510
bitar i en serie booleska typer.

51
00:02:23,510 --> 00:02:26,090
Och sedan datorn skulle inte längre se ett antal, men

52
00:02:26,090 --> 00:02:28,810
istället en samling av nollor och ettor.

53
00:02:28,810 --> 00:02:31,570
Vi kan också försöka läsa dessa data som en annan numerisk

54
00:02:31,570 --> 00:02:34,660
Skriv, eller ens som en sträng med fyra tecken.

55
00:02:34,660 --> 00:02:37,820
När man arbetar med siffror i gjutning, måste du överväga hur

56
00:02:37,820 --> 00:02:40,470
precisionen i ditt värde kommer att påverkas.

57
00:02:40,470 --> 00:02:43,240
Tänk på att precisionen kan stanna samma,

58
00:02:43,240 --> 00:02:47,150
eller du kan förlora precision, men du kan aldrig få precision.

59
00:02:47,150 --> 00:02:49,060
Låt oss gå igenom de tre vanligaste sätten som du kan

60
00:02:49,060 --> 00:02:50,400
förlorar precision.

61
00:02:50,400 --> 00:02:53,060
Gjutning en flottör till en int kommer att orsaka trunkering av allt

62
00:02:53,060 --> 00:02:54,900
efter decimalkommat, så att du är kvar

63
00:02:54,900 --> 00:02:55,950
med hela numret.

64
00:02:55,950 --> 00:03:02,000
Om vi ​​tar flottören X som kommer att motsvara 3,7, kan vi kasta

65
00:03:02,000 --> 00:03:05,580
denna variabel x till en int genom att skriva helt enkelt int i

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

67
00:03:07,050 --> 00:03:10,010
När vi använder denna term här, vi effektivt

68
00:03:10,010 --> 00:03:12,810
att använda värdet tre för vi har trunkeras

69
00:03:12,810 --> 00:03:14,880
allt efter decimalkommat.

70
00:03:14,880 --> 00:03:17,210
Vi kan också konvertera en lång lång tid att en int, som kommer

71
00:03:17,210 --> 00:03:20,760
liknande leda till en förlust av hög-bitarna.

72
00:03:20,760 --> 00:03:23,910
En lång lång tar upp 8 byte, eller 64 bitar i minnet.

73
00:03:23,910 --> 00:03:27,050
Så när vi kastade det till en int som bara har 4 byte, eller 32

74
00:03:27,050 --> 00:03:29,820
bitar, vi hugga huvudsak av alla de bitar som

75
00:03:29,820 --> 00:03:32,420
representerar de högre binära värdena.

76
00:03:32,420 --> 00:03:34,690
Du kan också kasta en dubbel till en flottör, som kommer att ge

77
00:03:34,690 --> 00:03:37,340
dig närmast möjliga flottören till det dubbla utan

78
00:03:37,340 --> 00:03:39,100
nödvändigtvis avrundning det.

79
00:03:39,100 --> 00:03:41,840
Liknar vår långa lång tid att int omvandling förlusten i

80
00:03:41,840 --> 00:03:44,890
precisionen beror på att en dubbel innehåller mer data.

81
00:03:44,890 --> 00:03:47,910
En dubbel kan du lagra 53 signifikanta bitar,

82
00:03:47,910 --> 00:03:50,650
ungefär 16 signifikanta siffror.

83
00:03:50,650 --> 00:03:53,050
Medan en flottör endast tillåter dig att lagra 24

84
00:03:53,050 --> 00:03:56,235
signifikanta bitar, ungefär syv signifikanta siffror.

85
00:03:56,235 --> 00:03:58,700
I dessa två sista fallen kan det vara till hjälp att tänka på

86
00:03:58,700 --> 00:04:01,200
typ gjutning som ändrar storlek på en bild.

87
00:04:01,200 --> 00:04:03,860
När du går från en stor storlek till en liten storlek, kan du inte se

88
00:04:03,860 --> 00:04:05,600
saker som tydligt eftersom du förlorat data

89
00:04:05,600 --> 00:04:07,530
i form av pixlar.

90
00:04:07,530 --> 00:04:09,270
Typ gjutning kan också orsaka problem när vi

91
00:04:09,270 --> 00:04:11,050
kasta Ints till flottar.

92
00:04:11,050 --> 00:04:13,920
Eftersom flyter på en 32-bitars maskin har endast 24

93
00:04:13,920 --> 00:04:16,959
signifikanta bitarna, kan de inte exakt representera värden

94
00:04:16,959 --> 00:04:22,750
över 2 upphöjt till 24, eller 16.777.217.

95
00:04:22,750 --> 00:04:25,540
Nu ska vi prata om explicita och implicita gjutning.

96
00:04:25,540 --> 00:04:28,000
Explicit gjutning är när vi skriver den typ inom parentes

97
00:04:28,000 --> 00:04:29,430
innan ett variabelnamn.

98
00:04:29,430 --> 00:04:33,100
Som ett exempel, innan vi skrev int inom parentes före vår

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

100
00:04:35,640 --> 00:04:37,200
På detta sätt får vi int värde,

101
00:04:37,200 --> 00:04:38,593
trunkerade värdet av 3,7 -

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

103
00:04:40,370 --> 00:04:42,970
Implicit gjutning är när kompilatorn ändras automatiskt

104
00:04:42,970 --> 00:04:46,340
liknande typer till en super typ, eller utför någon annan form av

105
00:04:46,340 --> 00:04:48,310
gjutning utan att användaren behöver skriva

106
00:04:48,310 --> 00:04:49,720
ytterligare kod.

107
00:04:49,720 --> 00:04:53,550
Till exempel när vi lägger till 5 och 1,1, våra värderingar har redan

108
00:04:53,550 --> 00:04:55,680
typer associerade med dem.

109
00:04:55,680 --> 00:04:59,480
Den 5 är en int, medan 1,1 är en flottör.

110
00:04:59,480 --> 00:05:02,390
För att lägga till dem, kastar datorn 5 till en flottör,

111
00:05:02,390 --> 00:05:04,530
som skulle ha varit samma sak som att skriva 5,0 i

112
00:05:04,530 --> 00:05:06,476
första plats.

113
00:05:06,476 --> 00:05:13,210
Men detta sätt säger vi flyta 5 eller 5,0, plus vad som redan

114
00:05:13,210 --> 00:05:16,960
en flottör, 1,1, och därifrån kan vi faktiskt lägga till dessa

115
00:05:16,960 --> 00:05:18,640
värderingar och få värdet 6,1.

116
00:05:21,170 --> 00:05:23,500
Implicit gjutning gör också att vi kan tilldela variabler

117
00:05:23,500 --> 00:05:25,590
olika typer till varandra.

118
00:05:25,590 --> 00:05:28,110
Vi kan alltid ge en mindre exakt typ till en mer

119
00:05:28,110 --> 00:05:29,250
exakt en.

120
00:05:29,250 --> 00:05:37,060
Till exempel, om vi har en dubbel x och en int y -

121
00:05:37,060 --> 00:05:40,120
och dessa kan ha några värden som vi ställer dem till -

122
00:05:40,120 --> 00:05:43,560
vi kan säga x är lika y..

123
00:05:43,560 --> 00:05:46,340
Eftersom dubbel har mer precision än en int, så vi

124
00:05:46,340 --> 00:05:48,380
kommer inte att förlora någon information.

125
00:05:48,380 --> 00:05:50,420
Å andra sidan skulle det inte nödvändigtvis vara korrekt att säga

126
00:05:50,420 --> 00:05:54,060
y är lika med x, eftersom den dubbla kan ha ett större värde än

127
00:05:54,060 --> 00:05:55,220
heltalet.

128
00:05:55,220 --> 00:05:57,420
Och så heltalet inte skulle kunna hålla alla

129
00:05:57,420 --> 00:05:59,560
information som lagras i dubbel.

130
00:05:59,560 --> 00:06:02,610
Implicit gjutning används också i jämförelse operatörer som

131
00:06:02,610 --> 00:06:06,410
större än, mindre än, eller lika operatören.

132
00:06:06,410 --> 00:06:13,050
På så sätt kan vi säga om 5,1 är större än 5, och vi får

133
00:06:13,050 --> 00:06:14,750
resultatet true.

134
00:06:14,750 --> 00:06:18,470
Eftersom 5 är en int, men det kommer att gjutas till en flottör för att

135
00:06:18,470 --> 00:06:22,090
jämföras med flottören 5,1, skulle vi säga 5,1 är

136
00:06:22,090 --> 00:06:24,550
större än 5,0.

137
00:06:24,550 --> 00:06:31,320
Detsamma gäller med att säga om 2,0 är lika lika med 2.

138
00:06:31,320 --> 00:06:34,190
Vi skulle också få sant, eftersom datorn kommer kasta

139
00:06:34,190 --> 00:06:39,750
heltal 2 att flyta och sedan säga 2,0 är lika med lika 2,0,

140
00:06:39,750 --> 00:06:41,660
detta är sant.

141
00:06:41,660 --> 00:06:44,180
Glöm inte att vi även kan kasta mellan Ints och tecken,

142
00:06:44,180 --> 00:06:46,350
eller ASCII-värden.

143
00:06:46,350 --> 00:06:49,690
Tecken måste också reduceras till binär, vilket är varför du

144
00:06:49,690 --> 00:06:51,920
kan enkelt konvertera mellan tecken och deras respektive

145
00:06:51,920 --> 00:06:53,260
ASCII-värden.

146
00:06:53,260 --> 00:06:56,180
Om du vill veta mer om detta, ta en titt video på ASCII.

147
00:06:56,180 --> 00:06:58,080
När du tar en stund att tänka på hur data är lagrade,

148
00:06:58,080 --> 00:06:59,990
det börjar göra mycket vettigt.

149
00:06:59,990 --> 00:07:02,790
Det är precis som skillnaden mellan vind och vind.

150
00:07:02,790 --> 00:07:05,490
Uppgifterna är densamma, men den typ kan ändra hur vi

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

152
00:07:06,720 --> 00:07:10,430
Mitt namn är Jordan Jozwiak detta CS50.