KiintoarvoMuuttujilla 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 (C:ssä esimerkiksi int, char, float jne.), vaan kyseessä on jaottelu, joka ilmaisee millainen tehtävä muuttujalla kyseisessä ohjelmassa on.
Seuraavassa kuvattavat kymmenen 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
Esimerkkiohjelmien yhteydessä olevan rivinumeroinnin tarkoitus on helpottaa riveihin viittaamista. Ohjelmien suorituksen kannalta rivinumeroinnilla ei ole mitään merkitystä, koska ne ovat muodoltaan C-kielen 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 */ #include <stdio.h>
/* 2 */ #define PII 3.14
/* 3 */ int main()
/* 4 */ {
/* 5 */ float r;
/* 6 */ printf("Anna ympyrän säde: ");
/* 7 */ scanf("%f", &r);
/* 8 */ printf("Ympyrän ala on %.2f\n", PII * r * r);
/* 9 */ exit(0);
/* 10 */ }
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 */ #include <stdio.h>
/* 2 */ int main()
/* 3 */ {
/* 4 */ int kertoja;
/* 5 */ for (kertoja = 1; kertoja <= 10; kertoja++)
/* 6 */ printf("%2d * 3 = %2d\n", kertoja, kertoja * 3);
/* 7 */ exit(0);
/* 8 */ }
Askeltajaa voidaan käyttää myös esimerkiksi lukumäärän
laskemiseen ja taulukon indeksien läpikäymiseen.
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ä 7) 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 */ #include <stdio.h>
/* 2 */ int main()
/* 3 */ {
/* 4 */ float s=0;
/* 5 */ while (s <= 0) {
/* 6 */ printf("Anna neliön sivu: ");
/* 7 */ scanf("%f", &s);
/* 8 */ }
/* 9 */ printf("Neliön ala on %.2f\n", s * s);
/* 10 */ exit(0);
/* 11 */ }
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ä 9) tuorein arvo, mikäli se on pienempi kuin pienin tähän mennessä läpikäydyistä.
/* 1 */ #include <stdio.h>
/* 2 */ int main()
/* 3 */ {
/* 4 */ int i, pienin, luku;
/* 5 */ printf("Anna 1. luku: "); scanf("%d", &pienin);
/* 6 */ for (i = 2; i <= 10; i++) {
/* 7 */ printf("Anna %d. luku: ", i);
/* 8 */ scanf("%d", &luku);
/* 9 */ if (luku < pienin) pienin = luku;
/* 10 */ }
/* 11 */ printf("Pienin luku oli %d\n", pienin);
/* 12 */ exit(0);
/* 13 */ }
(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ä 9) syötteiden kokonaissummaa.
/* 1 */ #include <stdio.h>
/* 2 */ int main()
/* 3 */ {
/* 4 */ int lkm=0;
/* 5 */ float summa=0, luku=0;
/* 6 */ while (luku != -999) {
/* 7 */ printf("Anna luku, -999 lopettaa: ");
/* 8 */ scanf("%f", &luku);
/* 9 */ if (luku != -999) {summa += luku; lkm++; }
/* 10 */ }
/* 11 */ if (lkm) printf("Keskiarvo on %.5f\n", summa / lkm);
/* 12 */ exit(0);
/* 13 */ }
(Muuttuja lkm on askeltaja ja luku on tuoreimman säilyttäjä.)
Muuntaja |
Muuntaja saa uuden arvonsa aina samalla laskentatavalla yhden tai useamman muun muuttujan arvoista. Esimerkkiohjelma pyytää käyttäjältä pääoman ja laskee sekä koron että pääoman kehittymisen kymmenen vuoden ajalle. Muuttuja korko on muuntaja, joka saadaan pääomasta (rivillä 8).
/* 1 */ #include <stdio.h>
/* 2 */ int main()
/* 3 */ {
/* 4 */ float paaoma, korko;
/* 5 */ int i;
/* 6 */ printf("Anna pääoma (positiivinen tai negatiivinen): "); scanf("%f", &paaoma);
/* 7 */ for (i = 1; i <=10; i++) {
/* 8 */ korko = 0.05 * paaoma;
/* 9 */ paaoma += korko;
/* 10 */ printf("%2d vuoden jälkeen korko on %11.2f ja kokonaispääoma on %12.2f\n",
/* 11 */ i, korko, paaoma);
/* 12 */ }
/* 13 */ exit(0);
/* 14 */ }
(Muuttuja paaoma on kokooja ja i on askeltaja.)
Muuntajaa voidaan käyttää myös jonkin tietoalkion tyyppi- tai lajikoodin säilyttämiseen.
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ä 11) esiintyykö syötteiden joukossa yhtään negatiivista arvoa ja jos yksikin negatiivinen arvo löytyy, ei muuttuja enää palaa arvoon false.
/* 1 */ #include <stdio.h>
/* 2 */ #define TRUE 1
/* 3 */ #define FALSE 0
/* 4 */ int main()
/* 5 */ {
/* 6 */ int luku=1, summa=0, neg;
/* 7 */ neg = FALSE;
/* 8 */ while (luku) {
/* 9 */ printf("Anna luku, 0 lopettaa: "); scanf("%d", &luku);
/* 10 */ summa += luku;
/* 11 */ if (luku < 0) neg = TRUE;
/* 12 */ }
/* 13 */ printf("Summa on %d\n", summa);
/* 14 */ if (neg) printf("Joukossa oli negatiivisia lukuja\n");
/* 15 */ exit(0);
/* 16 */ }
(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.
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ä 9).
/* 1 */ #include <stdio.h>
/* 2 */ int main()
/* 3 */ {
/* 4 */ int kuukausi, nykyinen, edellinen, suurinEro;
/* 5 */ printf("Anna 1. arvo: "); scanf("%d", &edellinen);
/* 6 */ printf("Anna 2. arvo: "); scanf("%d", &nykyinen);
/* 7 */ suurinEro = nykyinen - edellinen;
/* 8 */ for (kuukausi = 3; kuukausi <= 12; kuukausi++) {
/* 9 */ edellinen = nykyinen;
/* 10 */ printf("Anna %d. arvo: ", kuukausi);
/* 11 */ scanf("%d", &nykyinen);
/* 12 */ if (nykyinen - edellinen > suurinEro)
/* 13 */ suurinEro = nykyinen - edellinen;
/* 14 */ }
/* 15 */ printf("Suurin ero oli %d\n", suurinEro);
/* 16 */ exit(0);
/* 17 */ }
(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.
Tilapäissäilö |
Muuttuja on tilapäissäilö, jos sen arvoa tarvitaan aina vain hyvin lyhyen ajan. Esimerkkiohjelma tulostaa syötteenään saamasta kahdesta luvusta ensin suuremman ja sitten pienemmän. Muuttujien sisällöt vaihdetaan keskenään käyttämällä tilapäissäilönä muuttujaa tmp (riveillä 8-10), jonka arvolla ei ole jatkossa merkitystä (vaikka ohjelma jatkuisi kuinka pitkään tahansa.)
/* 1 */ #include <stdio.h>
/* 2 */ int main()
/* 3 */ {
/* 4 */ int luku1, luku2, tmp;
/* 5 */ printf("Anna luku: "); scanf("%d", &luku1);
/* 6 */ printf("Anna toinen luku: "); scanf("%d", &luku2);
/* 7 */ if (luku1 < luku2) {
/* 8 */ tmp = luku1;
/* 9 */ luku1 = luku2;
/* 10 */ luku2 = tmp;
/* 11 */ }
/* 12 */ printf("Luvuista suurempi on %d ja pienempi on %d\n",
/* 13 */ luku1, luku2);
/* 14 */ exit(0);
/* 15 */ }
Tilapäissäilöä käytetään usein järjestelijän kahden alkion keskinäisen paikan vaihtamiseen.
Järjestelijä |
Järjestelijä on taulukko, jota käytetään siinä olevien tietojen uudelleen järjestämiseen sen jälkeen, kun taulukko on ensin alustettu joillakin arvoilla. Esimerkkiohjelma pyytää käyttäjältä merkki kerrallaan yhteensä kymmenen merkkiä järjestelijään merkki, kääntää niiden järjestyksen taulukossa ja lopuksi tulostaa merkit tässä käännetyssä järjestyksessä.
/* 1 */ #include <stdio.h>
/* 2 */ int main()
/* 3 */ {
/* 4 */ char merkki[10], tmp;
/* 5 */ int i;
/* 6 */ printf("Anna kymmenen kirjainta: ");
/* 7 */ for (i = 0; i < 10; i++) scanf("%c", &merkki[i]);
/* 8 */ for (i = 0; i < 5; i++) {
/* 9 */ tmp = merkki[i];
/* 10 */ merkki[i] = merkki[9-i];
/* 11 */ merkki[9-i] = tmp;
/* 12 */ }
/* 13 */ for (i = 0; i < 10; i++) printf("%c", merkki[i]);
/* 14 */ printf("\n");
/* 15 */ exit(0);
/* 16 */ }
(Muuttuja tmp on tilapäissäilö ja i on askeltaja.)
Järjestelijää voidaan käyttää taulukon lajitteluun tai muuhun uudelleenjärjestelyyn.
Päivitetty viimeksi: 13.9.2005