Förord

Variabler; den första grundstenen i Pascal-programmering. Variabler är lagringsplatser för olika typer av data och används i alla program som gör något annat än att bara skriva ut text. När jag satte mig för att skriva artikeln upptäckte jag att den blev väldigt lång, så jag har delat upp den i två delar. Det här är den andra.

Innehåll

  » Räkna med variabler
  » Olika sätt att avrunda tal på
  » Konstanter
  » Omvandlingar
  » Övningar
  » Avslutning

Räkna med variabler

Addition
Addition sker precis så som du tror, med ett vanligt plustecken:


01: program AdditionsTest;
02:
03: uses Crt;
04:
05: {$APPTYPE Console}
06:
07: var Tal1, Tal2, Summa : Integer;
08:
09: begin
10: Write(’Tal1: ’);
11: ReadLn(Tal1);
12: Write(’Tal2: ’);
13: ReadLn(Tal2);
14: Summa := Tal1 + Tal2;
15: WriteLn(’Summan av talen ’, Tal1, ’ och ’, Tal2, ’ är ’, Summa);
16: ReadLn;
17: end.


Subtraktion
Subtraktion sker som ovan fast med ett minustecken (-) istället för plus (+).

Multiplikation
För multiplikation används en asterisk (*).

Division
Nu blir det lite mer intressant, man kan nämligen dividera på två olika sätt. Om du har en flyttalsvariabel (exempelvis Real) går det utmärkt att använda ett vanligt divitionstecken (/). Men om du istället använder dig av ett heltal (Ex. Integer) så kan du ju inte få några decimaler över. Då används funktionen div.


10/3 = 3.3333333…
10 div 3 = 3


Men nu försvinner ju tal. 3*3 är 9, inte 10!
Det är helt riktigt, och det är därför funktionen mod finns. I mod hamnar restprodukten.


10 div 3 = 3
10 mod 3 = 1


Förstår du? När man gör en heltalsdivision blir det ofta något över. Det som skulle bli decimaler i en vanlig division. Dessa lagras i funktionen mod.

Olika sätt att avrunda tal på

Det finns tre sätt att göra avrundningar på. Vi börjar med den enklaste:

Vi tänker oss att vi har gjort en miniräknare, men vi vill inte uppleva tiotals decimaler, vi vill att resultatet ska presenteras med endast två decimaler. Då gör vi så här:


WriteLn(Summa:0:2);


Den sista siffran (2:an) är antalet decimaler. Experimentera och se vad som händer om du ändrar på 0:an.

De två andra funktionerna heter Round och Trunc. De används för att avrunda heltal som vid beräkningar eventuellt råkar innehålla decimaler. Funktionen Round används när du vill avrunda ett tal till närmsta heltal. Funktionen Trunc kommer däremot bara att kapa av decimalerna. Kör följande program och se vad som händer:


program Avrundning;

{$APPTYPE Console}

var Flyttal : Real;
Heltal : Integer;

begin
Flyttal := 4.7;
Heltal := Round(Flyttal);
WriteLn(’Avrundat blir det ’, Heltal);
Heltal := Trunc(Flyttal);
WriteLn(’Avhugget blir det ’, Heltal);
ReadLn;
end.


Konstanter

Konstanter, de är variablernas motsats men kan vara precis lika nyttiga. Säg att du gör ett program där du vill omvandla dollar till kronor. Dollarvärdet i förhållande till kronan är inte speciellt stabilt eller hur? Det vore ju fruktansvärt jobbigt att räkna med om du varje dag ska ändra i programmet på alla de platser där dollarns värden är utskrivna. Då blir det mycket lättare med konstanter.


01: program AdditionsTest;
02:
03: uses Crt;
04:
05: {$APPTYPE Console}
06:
07: const Dollar = 7,41; {notera likhetstecknet}
08:
09: var Kronor, Summa : Real;
10:
11: begin
12: Write(’Antal kronor som ska omvandlas till dollar: ’);
13: ReadLn(Kronor);
14: Summa := Dollar*Kronor;
15: WriteLn(Kronor, ’kr är lika med ’, Summa:0:2, ’ dollar.’); {Summa:0:2, Vad i hela friden?}
16: ReadLn;
17: end.


På rad 7 skapar vi en konstant som vi döper till Dollar, värdet sätts till 7,41 (notera att det är ett ensamt likhetstecken). I detta exempel användes Dollar bara på en plats så det kan tyckas onödigt med konstanten just här, men du förstår principen.

Omvandlingar

Man kan omvandla heltal till tecken och tvärtom med hjälp av Chr och Ord. Detsamma gäller strängar och heltal med funktionerna StrToInt och IntToStr. Här följer ett litet exempel på hur dessa fungerar.


program Konverteringar

uses Crt; SysUtils; {notera att vi behöver lägga till SysUtils i usessatsen}

{$APPTYPE Console}

var Heltal, Error : Integer;
Tecken : Char;
Strang : String;

begin
Tecken := 'A';
WriteLn('Bokstaven A har ASCII-värdet ', Ord(Tecken));
Heltal := 66;
WriteLn('Detta blir ett B: ', Chr(Heltal));

{Heltal görs nu om till en sträng}
Strang := IntToStr(Heltal);
Strang := Strang+'6';
WriteLn('Detta är den oheliga treenigheten: ', Strang);

{Strängen görs nu om till ett heltal}
Heltal := StrToInt(Strang);
Heltal := Heltal div 2;
WriteLn('Heltal innehåller nu ', Heltal);
ReadLn;
end.


Övningar

1. Skriv ett program som frågar efter namn. Låt användaren skriva in sitt namn och skriv därefter ut (om användarens namn är Christoffer) ”Hej Christoffer!”.
2. Skriv ett program som kastar om två variabler. Exempel på utskrift:

Tal1 = 5
Tal2 =7
Men nu är:
Tal1 = 7
Tal2 = 5

3. Gör ett program som omvandlar inmatade sekunder till timmar:minuter:sekunder. Använd mod och div.

Avslutning

Nu var det slut på variabler och konstanter. I nästa artikel är det dags att börja använda villkor.
Återigen, ge mig feedback ;)

0 Kommentarer

Skriv en kommentar på artikeln

Ditt betyg på artikeln

UtmärktLäsvärdIntressantMindre braDålig

Kommentar: