[Powered by Google Translate] JORDAN Jozwiak: Type gieten, in de meest eenvoudige zin een
manier om een ​​computer de interpretatie van sommige gegevens te veranderen door
impliciet of expliciet het veranderen van de data type.
Zoals het veranderen van een int een float of vice versa.
Om type casting te begrijpen, moeten we
beginnen met de basis -
gegevenstypen zelf.
In computer talen zoals C, alle variabelen hebben een soort
van het gegevenstype dat bepaalt hoe de computer, en ook
de gebruiker, interpreteert die variabele.
Numerieke data types, zoals een int, long long, float en
dubbele, hebben allemaal hun eigen unieke kenmerken en zijn
gebruikt om waarden van verschillende reeksen en precisie geven.
Type casting laat ons toe om een ​​floating point getal te nemen, zoals
3.14 en krijg het deel voor de komma, 3 in dit geval,
door gieten aan een int.
Laten we eens een voorbeeld nemen aan het Engels voor een korte
beoordelen van de typen, en om te zien hoe typecasting kan veranderen
de manier waarop we interpreteren van een stuk van de gegevens.
Voor data, laten we hier neemt u de symbolen.
Ik zie deze zorgvuldig geconfigureerd lijnen als
symbolen, maar als iemand die weet de Engels taal,
je onmiddellijk erkennen dat ze, in feite, brieven.
U impliciet begrepen het gegevenstype.
Kijkend naar deze reeks letters zien we twee
andere woorden, elk met een eigen betekenis.
Er het zelfstandig naamwoord, wind, zoals in de wind buiten.
En er is het werkwoord, wind, net als in ik moet
wind mijn analoge horloge.
Dit is een interessant voorbeeld, omdat we kunnen zien
hoe het type dat we aan onze gegevens, of zelfstandig naamwoord of
werkwoord, verandert de manier waarop we deze gegevens gebruiken -
als het woord wind of wind.
Hoewel een computer niet de zorg over grammatica en delen
van het Engels spreken, hetzelfde principe geldt.
Dat is, kunnen we de interpretatie van de exacte
Dezelfde gegevens opgeslagen in het geheugen door eenvoudig het gieten een
ander type.
Hier zijn de afmetingen van de meest voorkomende types op een 32-bit
besturingssysteem.
We hebben een char op 1 byte, int en float op 4 bytes, een lange
lang en een dubbel op 8 bytes.
Omdat een int neemt 4 bytes, zal het nemen 32 bits
wanneer het wordt opgeslagen in geheugen als een binaire reeks
van nullen en enen.
Zolang onze variabele blijft als een type int, de
computer zal altijd converteren die enen en nullen van
binair naar het oorspronkelijke aantal.
We konden echter theoretisch werpen die 32
bits in een reeks Boolean types.
En dan is de computer niet langer een nummer zien, maar
in plaats daarvan een verzameling van nullen en enen.
We kunnen ook proberen om die gegevens te lezen als een andere numerieke
typen, of zelfs als een reeks van vier tekens.
Bij het omgaan met getallen in gieten, moet je nadenken over hoe
de precisie van uw waarde wordt beïnvloed.
Houd in gedachten dat de precisie kan hetzelfde blijven,
of je kunt verliezen precisie, maar je kunt nooit winnen precisie.
Laten we gaan door voor de drie meest voorkomende manieren waarop u kunt
verliezen precisie.
Het gieten van een float naar een int zal leiden tot inkorting van alles
na de komma, dus je bent vertrokken
het gehele getal.
Als we de vlotter x die gelijk zal zijn aan 3,7, kunnen we werpen
deze variabele x naar een int door simpelweg te schrijven int in
haakjes.
Wanneer we deze term gebruiken hier, zullen we effectief
worden met behulp van de waarde drie, want we hebben afgekapt
alles na de komma.
We kunnen ook converteren van een lange lange naar een int, die zal
eveneens leiden tot een verlies van hoge orde bits.
Een lange lange neemt 8 bytes, of 64 bits in het geheugen.
Dus als we wierp het naar een int die slechts 4 bytes, of 32
bits, zijn we in wezen afhakken alle bits die
geven de binaire waarden hoger.
Je zou ook kunnen werpen een tweepersoonsbed een vlotter, die geeft
u zo dicht mogelijk vlotter naar de dubbele zonder
noodzakelijkerwijs het afronden.
Soortgelijke onze lange lang int conversie, het verlies in
precisie omdat een dubbele meer gegevens bevat.
Een dubbele zal u toelaten om 53 significante bits op te slaan,
ongeveer 16 significante cijfers.
Overwegende dat een vlotter kunt u alleen tot 24 op te slaan
significante bits, ongeveer zeven significante cijfers.
In de laatste twee gevallen kan het nuttig zijn om na te denken over
typ gieten als de grootte van een foto.
Als je van een groot formaat voor een klein formaat, kun je niet zien
dingen zo duidelijk, omdat je verloren gegevens
in de vorm van pixels.
Type casting kan ook leiden tot problemen wanneer we
gegoten ints naar praalwagens.
Sinds drijft op een 32-bit machine alleen hebben 24
significante bits, kunnen ze niet nauwkeurig waarden
over 2 tot de macht 24 of 16777217.
Laten we nu praten over expliciete en impliciete casting.
Expliciete casting is wanneer we schrijven het type tussen haakjes
voor een variabele naam.
Als voorbeeld voor we schreven int haakjes voor onze
drijven variabele x.
Zo krijgen we int waarde,
afgeknotte waarde van 3,7 -
3.
Impliciete casting is wanneer de compiler automatisch gewijzigd
soortgelijke een super type, of voert een ander soort
gieten zonder dat de gebruiker te schrijven
extra code.
Bijvoorbeeld, wanneer we 5 en 1,1 toe te voegen, onze waarden al
types banden met hen hebben.
De 5 is een int, terwijl 1,1 is een vlotter.
Om toegevoegd, de computer werpt 5 een float,
die zou zijn hetzelfde als het schrijven van 5.0 in de
eerste plaats.
Maar op deze manier zeggen we float 5, of 5,0, plus wat er al
een float, 1,1, en van daaruit kunnen we daadwerkelijk toe te voegen deze
waarden en de waarde 6.1.
Impliciete casting laat ons ook toe te wijzen variabelen van
verschillende types elkaar.
We kunnen een minder precieze aard altijd toe te wijzen tot een meer
precies een.
Bijvoorbeeld, als we een dubbele x en y een int -
en deze kunnen geen waarden die we hen -
kunnen we zeggen x gelijk is aan y.
Omdat de dubbele meer precisie dan een int, dus we
verliest geen informatie.
Anderzijds zou het niet noodzakelijk juist te zeggen
y gelijk x, omdat de dubbele zou een grotere waarde dan
de integer.
En zo integer mogelijk niet alle houden
opgeslagen in de dubbele.
Impliciete casting wordt ook gebruikt in vergelijking operators zoals
groter dan, kleiner dan of gelijkheid operator.
Zo kunnen we zeggen of 5,1 groter is dan 5, en krijgen we de
leiden waar.
Omdat 5 is een int, maar het zal worden uitgebracht op een vlotter om
worden vergeleken met de vlotter 5,1, zouden we zeggen 5.1 is
groter dan 5,0.
Hetzelfde geldt voor te zeggen als 2,0 is gelijk aan gelijk is aan 2.
We hadden ook waar, want de computer zal werpen de
gehele getal 2 om vervolgens drijven en zeggen 2,0 is gelijk aan gelijk is aan 2,0,
dit geldt.
Vergeet niet dat wij ook kunnen uitbrengen tussen ints en tekens,
of ASCII-waarden.
Chars moeten ook worden teruggebracht tot binair, dat is waarom je
kan eenvoudig converteren tussen tekens en hun respectieve
ASCII-waarden.
Voor meer informatie over deze, kijk op onze video-on-ASCII.
Wanneer u even de tijd om na te denken over de manier waarop gegevens zijn opgeslagen,
het begint te maken veel zin.
Het is net als het verschil tussen de wind en wind.
De gegevens zijn hetzelfde, maar het type kan veranderen hoe we
interpreteren.
Mijn naam is Jordan Jozwiak, deze CS50.