Variabel-typer

Fra Holstebro HTX Wiki
(Omdirigeret fra Kategori:Variabel-typer)
Skift til: navigering, søgning

Hvis man før har programmeret i et programmeringssprog som javaScript eller PHP, der ikke anvender typer, så kan det virke lidt fremmed-agtigt at skulle specificere typer på sine variabler, men hvis man kigger på hvad en variabel egentlig er, så giver det god mening.

Hvad er en variabel?

Set fra programmørens synspunkt, så er en variabel en "kasse" hvor man kan lægge noget ned i, og igen læse hvad der ligger i "kassen". Man kan altså bruge variabler til at lagre noget i.

Set fra compilerens synspunkt, så er en variabel en henvisning til et sted i hukommelsen, hvor indholdet af variablen ligger, og hvis man kender strukturen i en PIC's hukommelse, der er lagret i RAM, så ligger den organiseret som en række bytes på en række fastlagte adresser.

Variabeltypers sammenhæng med hukommelsen

Den absolut mindste enhed man kan have i en hukommelse er en Bit, der kan være 0 eller 1.

Bit-variabel

Dette er også den mindste type man har i JAL nemlig en bit, der kan defineres som følger:

var bit igang = false

Indholdet i sådan en variabel kan altså tolkes som 0 eller 1, man man kan også tolke det som false eller true (falsk eller sandt), så det kan indeholde en betingelse. Endelig kan man også tolke det som low eller high, hvilket giver god mening, da input og output netop er defineret som bit.

Byte-variabel

Som beskrevet er hukommelsen organiseret i bytes, hvor en byte er 8 bit, og den næste enhed man har er netop en byte, Med 8 bit kan angive 28 = 256 forskellige værdier, så en byte kan indeholde værdier fra 0 til 255, og den defineres som følger:

var byte variabelNavn = initVærdi

variabelNavn et er navn man selv vælger - dog kun med engelske tegn (A-Z og 0-9 samt _) og man kan heller ikke bruge reserverede ord, så en variabel kan ikke hedde byte, og ordet count er også reserveret.

initVærdi er den værdi variablen starter på efter Reset. Man kan udelade det hvis man ikke har brug for at variablen skal have en bestemt værdi ved start.

Det kunne se ud som følger:

var byte antal = 10

Eller hvis man ikke vil initialisere, så kunne det se ud som følger:

var byte cnt

Hvordan man kan forstå hvorfor man netop kan have 256 forskellige værdier i en byte hænger sammen med der binære talsystem, så det største tal man kan have er 27 + 26 + ... + 23 + 22 + 21 + 20 = 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255.

Altså når 0 også angiver en værdi så er det samlet set 256 forskellige værdier.

Normalt vil man tolke indholdet i en byte som et tal fra 0 til 255. Man kan også tolke en byte som enten en karakter, som følger ASCII koden eller som et tal fra -128 til 127, men her skal typen dog være sbyte .

Hvis man ønsker at gemme en karakter i en byte-variabel gøres det som følger:

variabelNavn = "X"

Opførsel af en byte ved overflow

Hvis man tæller op i en almindelig byte-variabel, og kommer til 255, så vil det næste tælleskridt være 0

Hvis der er en byte-variabel med fortegne man tæller over, så vil den gå fra 127 til -128

Der er ikke nogen umiddelbar indikation på at der er overflow, så man skal selv håndtere at man ikke laver overflow i sine variabler, med mindre det er tilsigtet.

Kommatal-variabeler - ikke implementeret

Hvis man ønsker at lagre decimalerne med i en variabel, så kræver det at man anvender floating point variabler - det er slet ikke implementeret i JAL.

Word-variabel

Vil man lagre større værdier over 255 i en variabel, så kan det ikke være i en byte. Her kan JAL hådtere en type der hedder word, der erklæres som følger:

var word stortTal = 1000

En variabel af typen word består af 2 bytes, altså 16 bit hvor de har en betydning fra 215 ned til 20. Det betyder at den kan indeholde ialt 215 + 214 + 214 + ... + 22 + 21 + 20 = 32768 + 16384 + 8192 + ... + 4 + 2 + 1 = 65536.

Altså kan en variabel rumme tal fra 0 til 65535.

Når man arbejder med word-variable, så skal man være opmærksom på at et word faktisk ligger i 2 bytes, så det tager længere tid for processoren at flytte med dem, og beregninger tager endnu længere tid. Normalt vil det ikke give problemer.

Et andet sted hvor det kan give problemer er hvis man anvender word-variabler i forbindelse med interrupt, der kan man risikere at interruptet kan ændre i en variabel midt i det man foretager sig, så den ene byte i word-variablen er ændret midt i en sætning man udfører, det kan give lidt specielle problemer man skal være opmærksom på.

Double Word-variabel

Den næste variabeltype der er defineret i JAL er en DWORD, så består af 4 bytes, altså 32 bit, og igen kunne man regne på det, men resultatet bliver at den kan rumme talområdet fra 0 til 4.294.967.295.

Variabler med fortegn

Det giver ingen mening at bits skal have et fortegne, da et fortegn (+ eller -) netop kan angives med 1 bit.

Derimod kan bytes have et fortegn, hvis man ønsker det, men som lige forklaret, så koster det en bit, og hvis man kigger på lagringen af de binære tal, så giver det god mening at lade den mest betydende bit (der ellers havde værdien 27) være den bit der angiver fortegnet.

Ved at lade binært 0 stå for +, så vil en positiv byte have samme repræsentation i en normal byte som i en byte, hvor der er angivet fortegn. Det er en fordel at det ikke skal tolkes forskelligt.

Ved at se på hvad der sker når man tæller ned over 0, så kan man finde den repræsentation der er mest logisk for programsproget, nemlig den hvor det ikke gør nogen forskel om man tolker det som en byte eller som en byte med fortegn:

 Binært    Decimalt    med fortegn
00000010       2            +2 
00000001       1            +1 
00000000       0             0 
11111111     255            -1 
11111110     254            -2 
11111101     253            -3 

Som det kan ses, så er der kun en definition af 0, der er altså ikke et +0 og et -0 som rent regneteknisk giver rigtig god mening, men det betyder så også at der er en skæv repræsentation af de positive tal og de negative tal, hvis man ikke tæller 0 med. Hvordan den kommer til udtryk kan vi se, hvis vi kigger på at tælle over fra de positive til de negative tal, hvor det ser ud som følger:


 Binært    Decimalt    med fortegn
01111101     125          +125 
01111110     126          +126 
01111111     127          +127 
10000000     128          -128 
10000001     129          -127 
10000010     130          -126 

Det giver altså et enkelt negativt tal mere end de positive

Byte med fortegn

En byte med fortegne er defineret som en sbyte som følger:

var sbyte tal = -3

Området for en sbyte er fra -128 til +127


Word med fortegn

Et word med fortegne er defineret som SWord som følger:

var SWord setpunkt = -333

Området for SWord er fra -32767 til +32768

Double Word med fortegn

Et DWord med fortegne er defineret som en SDWord som følger:

var SDWord stortMedFortegn = -3000000

Området for en SDWord er fra -2147483648 til +2147483647

Type Casting

Normalt, så vil man tilpasse sin kode, så det er den samme type variabler der anvendes i sammenhæng, men i nogle tilfælde kan det være praktisk at kunne lægge en variabeltype over i en anden. Det kan være man har lavet nogle udregninger som er placeret i et word, for ikke at give overflow, men som udregningerne er, så bliver resultatet en værdi, der med sikkerhed kan være i en byte. Her kunne man ønske at det skal gemmes i en byte.

Et meget simpelt eksempel kunne være:

var byte dat_byte = 0
var word dat_word = 30

dat_byte = byte(dat_word)

Her vil de 30 der står i dat_word komme over i dat_byte.

Hvis man ikke angiver at man vil typecaste, og bare lægger dat_word ind i dat_byte, så vil compileren komme med en advarsel, at der kan ske tab af data - men koden vil stadig virke på samme måde.

var byte dat_byte = 0
var word dat_word = 300

dat_byte = byte(dat_word)

Hvis man gennemfører denne kode, så vil compileren ikke lave vrøvl, men de 300 vil ikke kunne være i dat_byte, og resultatet vil være at det der ligger i dat_word, som er lagret i 2 bytes som et 1-tal (med betydningen 1 * 256) og tallet 44, altså tilsammen 300, der vil der kun blive taget den laves betydende byte (de 44), så resultatet bliver at der kommer til at stå 44 i dat_byte.

Arrays

Et array er en samling af et fast antal variabler under et navn.

Ideen med et array er at man kan henvende sig til de forskellige variabler ved hjælp af et index, som er et tal der angiver hvilken af variablerne man skal henvende sig til.

Arrayet defineres med et navn, en type og et antal i arrayet som vist her:

var byte maalinger [5]

Dette giver et array med 5 variabler med index 0, 1, 2, 3 og 4.

Hvis man i koden vil skrive en værdi ind i variabel med index 1, så skriver man:

maalinger [1] = 57

Hvis man vil sikre sig at alle variabler i arrayet står på 0 kan man gøre følgende:

var byte maalinger [5]
var byte n

for 5 using n loop
   maalinger[n] = 0
end loop

Begrænsninger i arrays

Der er ikke nogen kodemæssig begrænsning på arrays i JAL, men PIC'en sætter en naturlig grænse.

Hvis man f.x. ønsker et array med 50 variabler af typen dword, der hver fylder 4 byte, så vil det totalt fylde 200 byte, hvilket kan være ret voldsomt i en PIC der kun har 256 byte RAM.