Muuttujien roolit

Muuttujilla on ohjelmissa eräitä tyypillisiä käyttötapoja, joita kutsutaan muuttujien rooleiksi. Esimerkiksi muuttuja, jonka arvoa ei muuteta enää kertaakaan muuttujan alustamisen jälkeen, kutsutaan kiintoarvoksi. Muuttujien rooleja ei pidä sekoittaa muuttujien perustietotyyppeihin (Pascalissa esimerkiksi integer, char, boolean jne.), vaan kyseessä on jaottelu, joka ilmaisee millainen tehtävä muuttujalla kyseisessä ohjelmassa on.

Seuraavassa kuvattavat yksitoista eri roolia riittävät kattamaan lähes kaikki yksinkertaisissa ohjelmissa esiintyvät muuttujat. Useimmiten esiintyvät roolit ovat kiintoarvo, askeltaja ja tuoreimman säilyttäjä, jotka kattavat noin 70 % kaikista muuttujista. Toisaalta on huomattava, että kaikilla muuttujilla ei välttämättä ole mitään alla esitellyistä rooleista.

Muuttujien roolit, jotka on esitelty tarkemmin alla, ovat

• kiintoarvo
• askeltaja
• tuoreimman säilyttäjä
• sopivimman säilyttäjä
• kokooja
• seuraaja
• yksisuuntainen lippu
• tilapäissäilö
• järjestelijä
• säiliö
• kulkija

Esimerkkiohjelmien yhteydessä olevan rivinumeroinnin tarkoitus on helpottaa riveihin viittaamista. Ohjelmien suorituksen kannalta rivinumeroinnilla ei ole mitään merkitystä, koska ne ovat muodoltaan Pascal-kommentteja.

Kiintoarvo

Muuttujan rooli on kiintoarvo, jos sen arvoa ei muuteta ohjelman suorituksen aikana muuttujan alustamisen jälkeen. Esimerkkiohjelma kysyy käyttäjältä ympyrän säteen ja ilmoittaa sitten ympyrän alan. Muuttuja r on kiintoarvo. Kyseinen muuttuja saa ohjelman suorituksen aikana yhden kerran arvon (rivillä 7), joka ei sen jälkeen muutu. Kiintoarvoa voidaan käyttää ohjelman eri kohdissa - esimerkissä kahdesti rivillä 8.

(*1*)  program YmpyranAla (input,output);
(*2*)  const PII = 3.14;
(*3*)  var r: real;
(*4*)  begin
(*5*)     writeln;
(*6*)	  write ('Anna ympyrän säde: ');
(*7*)	  readln (r);
(*8*)     writeln ('Ympyrän ala on ', PII * r * r)
(*9*)  end.

Askeltaja

Askeltaja käy läpi arvoja jollain systemaattisella tavalla. Alla on esimerkki silmukkarakenteesta, jossa käytetään muuttujaa kertoja askeltajana. Esimerkkiohjelma tulostaa kolmosen kertotaulun askeltajan käydessä läpi arvot yhdestä kymmeneen.

(*1*) program Kertotaulu (output);
(*2*) var kertoja: integer;
(*3*) begin
(*4*)    for kertoja := 1 to 10 do
(*5*)        writeln(kertoja, ' * 3 = ', kertoja*3)
(*6*) end.

Tuoreimman säilyttäjä

Muuttuja on tuoreimman säilyttäjä, jos sen arvo on viimeisin jostakin tietystä joukosta läpikäyty arvo tai yksinkertaisesti vain arvo, joka on syötetty viimeksi. Esimerkkiohjelma pyytää käyttäjältä syötettä toistuvasti (rivillä 6) kunnes syöte on kelvollinen. Tässä ohjelmassa muuttuja s on tuoreimman säilyttäjä, koska siitä löytyy kulloinkin viimeksi syötetty arvo.

(*1*)  program NelionAla (input,output);
(*2*)  var s: real;
(*3*)  begin
(*4*)     repeat
(*5*)	     write ('Anna neliön sivu: ');
(*6*)	     readln (s)
(*7*)	  until s > 0;
(*8*)	  writeln('Neliön ala on ', s * s)
(*9*)  end.

Sopivimman säilyttäjä

Sopivimman säilyttäjän arvo on "paras" tai jollain muulla tavoin halutuin siihen asti läpikäydyistä arvoista. Arvojen paremmuuden mittamisessa ei ole mitään rajoituksia: halutuin voi tarkoittaa esimerkiksi pienintä tai suurinta lukua tai sellaista lukua, joka on lähinnä jotain tiettyä arvoa.

Esimerkkiohjelma selvittää, mikä käyttäjän syöttämistä kymmenestä kokonaisluvusta on pienin. Muuttuja pienin on sopivimman säilyttäjä, koska siihen sijoitetaan (rivillä 8) tuorein arvo, mikäli se on pienempi kuin pienin tähän mennessä läpikäydyistä.

(*1*)  program EtsiPienin (input,output);
(*2*)  var i, pienin, luku: integer;
(*3*)  begin
(*4*)     write('Anna 1. luku: '); readln(pienin);
(*5*)     for i := 2 to 10 do begin
(*6*)        write('Anna ',i,'. luku: ');
(*7*)        readln(luku);
(*8*)        if luku < pienin then pienin := luku
(*9*)     end;
(*10*)    writeln ('Pienin luku oli ', pienin)
(*11*) end.

(Muuttuja i on askeltaja ja luku on tuoreimman säilyttäjä.)

Kokooja

Kokoojan arvo kerääntyy kaikista siihen mennessä läpikäydyistä arvoista. Esimerkkiohjelma ottaa vastaan yksi kerrallaan käyttäjän syöttämiä kokonaislukuja, kunnes käyttäjä syöttää luvun -999, jonka jälkeen ohjelma laskee syötteiden keskiarvon. Muuttuja summa on kokooja: siihen kootaan (rivillä 10) syötteiden kokonaissummaa.

(*1*)  program Keskiarvo (input,output);
(*2*)  var lkm: integer;
(*3*)      summa, luku: real;
(*4*)  begin
(*5*)     summa := 0;
(*6*)     lkm := 0;
(*7*)     repeat
(*8*)        write('Anna luku, -999 lopettaa: ');
(*9*)        readln(luku);
(*10*)       if luku <> -999 then summa := summa+luku;
(*11*)       if luku <> -999 then lkm := lkm+1
(*12*)    until luku = -999;
(*13*)    if lkm > 0 then writeln('Keskiarvo on  ', summa / lkm)
(*14*) end.

(Muuttuja lkm on askeltaja ja luku on tuoreimman säilyttäjä.)

Seuraaja

Seuraaja saa aina arvokseen jonkin tietyn toisen muuttujan vanhan arvon. Esimerkkiohjelma pyytää käyttäjältä 12 kokonaislukua ja kertoo lopuksi, mikä oli suurin kahden perättäisen syötetyn luvun ero. Muuttuja edellinen on seuraaja: se seuraa muuttujaa nykyinen (rivillä 8).

(*1*)  program SuurinEro (input,output);
(*2*)  var kuukausi, nykyinen, edellinen, suurinEro: integer;
(*3*)  begin
(*4*)     write('Anna 1. arvo: '); readln(edellinen);
(*5*)     write('Anna 2. arvo: '); readln(nykyinen);
(*6*)     suurinEro := nykyinen - edellinen;
(*7*)     for kuukausi := 3 to 12 do begin
(*8*)        edellinen := nykyinen;
(*9*)        write('Anna ', kuukausi, '. arvo: ');
(*10*)       readln(nykyinen);
(*11*)       if nykyinen - edellinen > suurinEro
(*12*)          then suurinEro := nykyinen - edellinen
(*13*)    end;
(*14*)    writeln('Suurin ero oli ', suurinEro)
(*15*) end.

(Muuttuja kuukausi on askeltaja, nykyinen on tuoreimman säilyttäjä ja suurinEro on sopivimman säilyttäjä.)

Seuraajia käytetään paljon linkitettyjen tietorakenteiden yhteydessä osoittamaan käsiteltävää alkiota edeltänyttä alkiota.

Yksisuuntainen lippu

Yksisuuntainen lippu on Boolen muuttuja joka ei saa enää alkuperäistä arvoaan sen jälkeen, kun se on kerran muuttunut. Esimerkkiohjelma tulostaa käytäjän antamien lukujen summan ja ilmoittaa oliko syötteiden joukossa yhtään negatiivista lukua. Yksisuuntainen lippu neg tarkkailee (rivillä 10) esiintyykö syötteiden joukossa yhtään negatiivista arvoa ja jos yksikin negatiivinen arvo löytyy, ei muuttuja enää palaa arvoon false.

(*1*)  program Summa (input,output);
(*2*)  var luku, summa: integer;
(*3*)      neg: Boolean;
(*4*)  begin
(*5*)     summa := 0;
(*6*)	  neg := false;
(*7*)     repeat
(*8*)        write('Anna luku, 0 lopettaa: '); readln(luku);
(*9*)        summa := summa + luku;
(*10*)       if luku < 0 then neg := true
(*11*)    until luku = 0;
(*12*)    writeln('Summa on ', summa);
(*13*)    if neg then writeln('Joukossa oli negatiivisia lukuja')
(*14*) end.

(Muuttuja luku on tuoreimman säilyttäjä ja summa on kokooja.)

Yksisuuntaista lippua voidaan käyttää myös esimerkiksi tarkkailemaan virheen esiintymistä syöttötiedoissa, jotta ohjelma huomaisi pyytää syötteitä uudelleen.

Tilapäissäilö

Muuttuja on tilapäissäilö, jos sen arvoa tarvitaan aina vain hyvin lyhyen ajan. Esimerkkiohjelma ottaa vastaan käyttäjän syöttämiä tuotteiden verottomia hintoja ja tulostaa aina kokonaishinnan ja veron osuuden siitä. Tilapäissäilöön vero lasketaan veron suuruus (rivillä 8), jota käytetään sitten välittömästi seuraavassa lauseessa kahteen kertaan (riveillä 9 ja 10).

(* 1 *)  program Verotus(input,output);
(* 2 *)  const veroProsentti = 16;
(* 3 *)  var veroton, vero: real;
(* 4 *)  begin
(* 5 *)     repeat
(* 6 *)     write('Anna veroton hinta (0 lopettaa): '); readln(veroton);
(* 7 *)        if veroton <> 0 then begin
(* 8 *)           vero := veroton * veroProsentti / 100;
(* 9 *)           writeln('Kokonaishinta ', veroton+vero : 1 : 2,
(* 10 *)                  ' josta vero ', vero : 1 : 2)
(* 11 *)       end
(* 12 *)    until veroton = 0
(* 13 *) end.

(Muuttuja veroton on tuoreimman säilyttäjä.)

Tilapäissäilöä käytetään tyypillisesti ohjelman tehostamiseen (suorittamalla laskutoimitus, jonka tulosta tarvitaan useasti, vain kertaalleen) tai ohjelman selventämiseen (laskemalla tulos omaan muuttujaansa vaikka tämä ei ole välttämättä tarpeen). Tilapäissäilöä käytetään usein myös järjestelijän kahden alkion keskinäisen paikan vaihtamiseen.

Järjestelijä

Järjestelijä on tietorakenne, jota käytetään siinä olevien tietojen uudelleen järjestämiseen sen jälkeen, kun se on ensin alustettu joillakin arvoilla. Esimerkkiohjelma pyytää käyttäjältä merkki kerrallaan yhteensä kymmenen merkkiä taulukkona toteutettuun järjestelijään merkki, kääntää niiden järjestyksen taulukossa ja lopuksi tulostaa merkit tässä käännetyssä järjestyksessä.

(*1*)  program Kaanna (input, output);
(*2*)  var merkki: array[1..10] of char;
(*3*)      tmp: char;
(*4*)      i: integer;
(*5*)  begin
(*6*)     for i := 1 to 10 do begin
(*7*)        write('Anna kirjain: '); readln(merkki[i])
(*8*)     end;
(*9*)     for i := 1 to 5 do begin
(*10*)       tmp := merkki[i];
(*11*)       merkki[i] := merkki[11-i];
(*12*)       merkki[11-i] := tmp
(*13*)    end;
(*14*)    for i:=1 to 10 do write(merkki[i]);
(*15*)    writeln
(*16*) end.

(Muuttuja tmp on tilapäissäilö ja i on askeltaja.)

Järjestelijää voidaan käyttää lajitteluun tai muuhun uudelleenjärjestelyyn.

Säiliö

Säiliö on tietorakenne, johon voidaan lisätä ja josta voidaan poistaa tietoja. Esimerkkiohjelma toteuttaa pinon, johon käyttäjä voi lisätä uusia kokonaislukuja komennolla "u" (riveillä 11-15) ja poistaa pinossa vielä olevista luvuista viimeksi lisätyn komennolla "p" (riveillä 16-19). Pino tallennetaan säiliönä toimivaan taulukkoon taulukko.

(* 1 *)  program Pino(input,output);
(* 2 *)  const KOKO = 10;
(* 3 *)  var taulukko: array [1..KOKO] of integer;
(* 4 *)      pinta, uusi: integer;
(* 5 *)      komento: char;
(* 6 *)  begin
(* 7 *)     pinta := 0;
(* 8 *)     repeat
(* 9 *)     write('Anna komento: '); readln(komento);
(* 10 *)    case komento of
(* 11 *)       'u': if pinta < KOKO then begin
(* 12 *)               write('Anna sisältö: '); readln(uusi);
(* 13 *)               pinta := pinta + 1;
(* 14 *)               taulukko[pinta] := uusi
(* 15 *)            end;
(* 16 *)       'p': if pinta > 0 then begin
(* 17 *)               writeln('Poistuu ', taulukko[pinta]);
(* 18 *)               pinta := pinta - 1
(* 19 *)            end
(* 20 *)    end
(* 21 *)    until komento = 'q'
(* 22 *) end.

(Muuttuja pinta on kulkija, uusi on tuoreimman säilyttäjä ja komento on tuoreimman säilyttäjä.)

Kulkija

Kulkija käy läpi jotain tietorakennetta. Esimerkkiohjelma toteuttaa erityisellä alkuelementillä varustetun linkitetyn listan, johon käyttäjä voi lisätä kokonaislukuja komennolla "u" (riveillä 13-19) ja tulostaa listan komennolla "t" (riveillä 20-26). Muuttuja p on kulkija: se käy läpi listan kaikki alkiot (riveillä 16 ja 24).

(* 1 *)  program Lista(input,output);
(* 2 *)  type alkioOs = ^alkio;
(* 3 *)       alkio = record sisalto: integer; linkki: alkioOs end;
(* 4 *)  var alku, p, t: alkioOs;
(* 5 *)      uusi: integer;
(* 6 *)      komento: char;
(* 7 *)  begin
(* 8 *)     new(alku);
(* 9 *)     alku^.linkki := nil;
(* 10 *)    repeat
(* 11 *)    write('Anna komento: '); readln(komento);
(* 12 *)    case komento of
(* 13 *)       'u': begin
(* 14 *)               write('Anna sisältö: '); readln(uusi);
(* 15 *)               p := alku;
(* 16 *)               while p^.linkki <> nil do p := p^.linkki;
(* 17 *)               new(t); t^.sisalto := uusi; t^.linkki :=nil;
(* 18 *)               p^.linkki := t;
(* 19 *)            end;
(* 20 *)       't': begin
(* 21 *)               p := alku^.linkki;
(* 22 *)               while p <> nil do begin
(* 23 *)                  writeln(p^.sisalto);
(* 24 *)                  p := p^.linkki
(* 25 *)               end
(* 26 *)            end
(* 27 *)    end
(* 28 *)    until komento = 'q'
(* 29 *) end.

(Muuttuja alkio on kiintoarvo, t on tilapäissäilö, uusi on tuoreimman säilyttäjä, komento on tuoreimman säilyttäjä, kenttä sisalto on kiintoarvo ja kenttä linkki on kiintoarvo.)

Päivitetty viimeksi: 22.1.2006