[Powered by Google Translate] JORDANIEN JOZWIAK: Typ gjutning, i den enklaste mening, är en
sätt att ändra en dators tolkning av vissa uppgifter från
implicit eller explicit ändra dess datatyp.
Såsom ändring en int till en flottör, eller vice versa.
För att förstå typ gjutning, behöver vi
börja med grunderna -
datatyper själva.
I datorn språk som C, samtliga variabler har någon form
av datatyp som avgör hur datorn och likaså
användaren tolkar den variabeln.
Numeriska datatyper som en int, lång lång, float och
dubbel, alla har sina egna unika egenskaper och är
används för att ange värden för olika områden och precision.
Typ gjutning kan vi ta ett flyttal som
3,14 och få del innan decimal, 3 i detta fall,
genom att kasta den till en int.
Låt oss ta ett exempel från det engelska språket för en kort
granskning av olika typer, och för att se hur typ gjutning kan förändra
hur vi tolkar en bit data.
För data, låt oss ta symbolerna här.
Jag tänker bara på dessa noggrant konfigurerade linjer som
symboler, utan som någon som vet det engelska språket,
du inser genast att de i själva verket bokstäver.
Du förstod implicit datatypen.
Titta på denna rad bokstäver kan vi se två
olika ord, var och en med sin egen mening.
Där är substantiv, vind, liksom i det blåser utanför.
Och det finns verbet, vind, som i jag behöver
wind min analoga klocka.
Detta är ett intressant exempel, eftersom vi kan se
hur den typ som vi tilldelar våra data, oavsett om substantiv eller
verb, ändrar hur vi använder dessa data -
som ordet vinden eller vind.
Även om en dator inte bryr sig om grammatik och delar
engelska tal gäller samma grundprincip.
Det är, kan vi ändra tolkningen av den exakta
samma data som lagras i minnet genom gjutning helt enkelt till en
annan typ.
Här är storleken på de vanligaste typerna på en 32-bitars
operativsystemet.
Vi har en röding på 1 byte, int och float på 4 byte, en lång
lång och en dubbel på 8 byte.
Eftersom en int tar upp 4 byte, kommer det att ta upp 32 bitar
när den lagras i minnet som en binär serie
av nollor och ettor.
Så länge vår variabel är som en typ int, den
Datorn kommer alltid konvertera dessa ettor och nollor från
binär i det ursprungliga antalet.
Men vi kunde kasta teoretiskt de 32
bitar i en serie booleska typer.
Och sedan datorn skulle inte längre se ett antal, men
istället en samling av nollor och ettor.
Vi kan också försöka läsa dessa data som en annan numerisk
Skriv, eller ens som en sträng med fyra tecken.
När man arbetar med siffror i gjutning, måste du överväga hur
precisionen i ditt värde kommer att påverkas.
Tänk på att precisionen kan stanna samma,
eller du kan förlora precision, men du kan aldrig få precision.
Låt oss gå igenom de tre vanligaste sätten som du kan
förlorar precision.
Gjutning en flottör till en int kommer att orsaka trunkering av allt
efter decimalkommat, så att du är kvar
med hela numret.
Om vi ​​tar flottören X som kommer att motsvara 3,7, kan vi kasta
denna variabel x till en int genom att skriva helt enkelt int i
parentes.
När vi använder denna term här, vi effektivt
att använda värdet tre för vi har trunkeras
allt efter decimalkommat.
Vi kan också konvertera en lång lång tid att en int, som kommer
liknande leda till en förlust av hög-bitarna.
En lång lång tar upp 8 byte, eller 64 bitar i minnet.
Så när vi kastade det till en int som bara har 4 byte, eller 32
bitar, vi hugga huvudsak av alla de bitar som
representerar de högre binära värdena.
Du kan också kasta en dubbel till en flottör, som kommer att ge
dig närmast möjliga flottören till det dubbla utan
nödvändigtvis avrundning det.
Liknar vår långa lång tid att int omvandling förlusten i
precisionen beror på att en dubbel innehåller mer data.
En dubbel kan du lagra 53 signifikanta bitar,
ungefär 16 signifikanta siffror.
Medan en flottör endast tillåter dig att lagra 24
signifikanta bitar, ungefär syv signifikanta siffror.
I dessa två sista fallen kan det vara till hjälp att tänka på
typ gjutning som ändrar storlek på en bild.
När du går från en stor storlek till en liten storlek, kan du inte se
saker som tydligt eftersom du förlorat data
i form av pixlar.
Typ gjutning kan också orsaka problem när vi
kasta Ints till flottar.
Eftersom flyter på en 32-bitars maskin har endast 24
signifikanta bitarna, kan de inte exakt representera värden
över 2 upphöjt till 24, eller 16.777.217.
Nu ska vi prata om explicita och implicita gjutning.
Explicit gjutning är när vi skriver den typ inom parentes
innan ett variabelnamn.
Som ett exempel, innan vi skrev int inom parentes före vår
float variabel x.
På detta sätt får vi int värde,
trunkerade värdet av 3,7 -
3.
Implicit gjutning är när kompilatorn ändras automatiskt
liknande typer till en super typ, eller utför någon annan form av
gjutning utan att användaren behöver skriva
ytterligare kod.
Till exempel när vi lägger till 5 och 1,1, våra värderingar har redan
typer associerade med dem.
Den 5 är en int, medan 1,1 är en flottör.
För att lägga till dem, kastar datorn 5 till en flottör,
som skulle ha varit samma sak som att skriva 5,0 i
första plats.
Men detta sätt säger vi flyta 5 eller 5,0, plus vad som redan
en flottör, 1,1, och därifrån kan vi faktiskt lägga till dessa
värderingar och få värdet 6,1.
Implicit gjutning gör också att vi kan tilldela variabler
olika typer till varandra.
Vi kan alltid ge en mindre exakt typ till en mer
exakt en.
Till exempel, om vi har en dubbel x och en int y -
och dessa kan ha några värden som vi ställer dem till -
vi kan säga x är lika y..
Eftersom dubbel har mer precision än en int, så vi
kommer inte att förlora någon information.
Å andra sidan skulle det inte nödvändigtvis vara korrekt att säga
y är lika med x, eftersom den dubbla kan ha ett större värde än
heltalet.
Och så heltalet inte skulle kunna hålla alla
information som lagras i dubbel.
Implicit gjutning används också i jämförelse operatörer som
större än, mindre än, eller lika operatören.
På så sätt kan vi säga om 5,1 är större än 5, och vi får
resultatet true.
Eftersom 5 är en int, men det kommer att gjutas till en flottör för att
jämföras med flottören 5,1, skulle vi säga 5,1 är
större än 5,0.
Detsamma gäller med att säga om 2,0 är lika lika med 2.
Vi skulle också få sant, eftersom datorn kommer kasta
heltal 2 att flyta och sedan säga 2,0 är lika med lika 2,0,
detta är sant.
Glöm inte att vi även kan kasta mellan Ints och tecken,
eller ASCII-värden.
Tecken måste också reduceras till binär, vilket är varför du
kan enkelt konvertera mellan tecken och deras respektive
ASCII-värden.
Om du vill veta mer om detta, ta en titt video på ASCII.
När du tar en stund att tänka på hur data är lagrade,
det börjar göra mycket vettigt.
Det är precis som skillnaden mellan vind och vind.
Uppgifterna är densamma, men den typ kan ändra hur vi
tolka det.
Mitt namn är Jordan Jozwiak detta CS50.