Okej, har du följt studiehandledningen till del 1?(Studiehandledningen)
Bra.
Overflow
När man arbetar med variabler kan man stöta på ett
problem som kallas för "overflow".
Det är det som händer ifall man hamnar utanför en
datatyps talområde.
Säg att vi använder datatypen shortint som klarar talområdet
-128 - 127.
Vad händer ifall variabeln har värdet 127, (största
möjliga värde för datatypen), och vi ökar den
med ett?
Jo, resultatet blir -128 eftersom vi fått ett "shortint
overflow".
Dvs 127+1=-128. Hm, det är
ju inte alls bra.
Vad har hänt?
Man kan åskådliggöra det här med ett representera
shortint som ett "hjul".
(Notera att alla tal inte är inskrivna i hjulet, de finns där
egentligen.)
Vid addition går man högervarv i hjulet.
Vid subtraktion går man vänstervarv i hjulet.
Ökar man värdet går man medurs i hjulet det antal
steg värdet ska ökas.
Minskar man värdet gör man på motsvarande sätt
fast man går moturs.
Problem uppstår ifall man passerar gränsen mellan positiva
och negativa tal nertill på hjulet. Det är där som
overflow inträffar.
Overflow inträffar alltså
då vi hamnar utanför området datatypen klarar att
hantera.
Prova själv mha hjulet beräkningarna:
-128-1
127+2
-127-10
127*2
0-150
Finns det nu något smart
sätt att skydda sig mot overflow?
Både ja och nej.
Vissa kompilatorer går att ställa in så att de
varnar ifall dataområdet överskrids, men oftast finns
inget skydd mot dessa fel.
I exemplet ovan hade en lösning
på problemet varit att använda en bättre datatyp
istället, t ex datatypen integer.
Men vi kommer alltid, oavsett datatyp, vara begränsade till
ett begränsat dataområde när vi använder variabler.
I verkliga livet finns det oändligt stora tal, skulle de få
plats i datorn skulle det oändliga talet kräva oändligt
med minne för att kunna rymmas. Men datorn har inte oändligt
med minne...
Slutsats
Det finns alltid en gräns för hur stora tal, hur mycket
data vi kan klämma in i datorn. När den gränsen överskrids
får vi overflow.
När datorerna får större och större kapacitet
i framtiden flyttas gränserna för overflow endast längre
bort.
Overflowproblemet kommer dock ALLTID att kvarstå eftersom
vi aldrig kommer att få oändligt stor lagringskapacitet
i en dator.
Överkurs (kommer inte
med på något prov eller dylikt)
För dig som mer i detalj vill veta vad det är som händer
vid overflow.
Datatypen shortint ryms i 8 bitar,
en bit håller reda på ifall talet är positivt eller
negativt. Kvar har vi 7 bitar till att representera olika heltal.
127 skrivs som 111 1111 binärt.
Teckenbiten är 0 för positiva tal och 1 för negativa
tal. Talet 1 skrivs som 1 binärt och lagras som 0000 0001
i datorn, 2 skrivs som 10 binärt och lagras som 0000 0010,
3 skrivs som 11 binärt och lagras som 0000 0011 osv.
127 lagras alltså som 0111 1111.
De negativa talen börjar alltså med en etta, men -1 skrivs
dock inte 1000 0001 som man kanske skulle tycka utan som 1111 1111.
-1 motsvaras av 1111 1111
-2 motsvaras av 1111 1110 osv till
-127 motsvaras av 1000 0001
-128 motsvaras av 1000 0000
Det man gör är att utifrån
1000 0001, först minskar det med 1, dvs 1000 0001-1=1000 0000.
Därefter byter man ut nollorna mot ettor och tvärtom förutom
den första ettan som talar om att talet är negativt. Då
får vi 1111 1111 vilket alltså representerar -1
i datorn. -2 skrivs alltså som 1111 1110.
Vad händer nu ifall vi har har
126 som skrivs 0111 1110 och adderar 1?
Jo, 0111 1110 + 1 = 0111 1111 som är 127.
Allting är som det ska fortfarande, 126+1=127. Inga problem.
Vad händer ifall vi ökar 127 med 1?
Jo, 0111 1111 + 1 = 1000 0000 som i datorn representerar
talet -128.
Här är alltså det som orsakat vårt problem,
vårt "overflow".
Teckenbiten ändras eftersom man försöker lagra ett
större värde än vad datatypen kan hantera.
Vi kan använda samma resonemang
för datatypen integer, skillnaden är att storleken då
är 32 bitar dvs 4 byte.
(shortint hade bara 8 bitar = 1 byte)
Vi kommer även där till en punkt då datatypen inte
längre räcker till. Men den punkten kommer inte förrän
vid -2 147 483 648 - 1 och 2 147 483 647 + 1.
