Oppaat: C-ohjelmointi: Osa 3 - Ehdot, silmukat ja funktiot

Tämän oppaan alussa tutustutaan tosiin ja epätosiin lausekkeisiin, jotka liittyvät tärkeällä tavalla seuraavaan aiheeseen: ohjelman kulkuun vaikuttaviin ehtolauseisiin ja saman asian monta kertaa toistaviin silmukoihin. Toinen tärkeä uusi asia on omien funktioiden luominen. Funktioiden avulla koodi lyhenee ja selkeytyy, ja virheiden korjaaminen on myös helpompaa. Luodaanpa oppaassa myös silmäys osoitinmuuttujiin, jotka osoittavat toiseen tietokoneen muistissa olevaan muuttujaan.

Tosi ja epätosi

C-kielessä lauseke, jonka arvo on 0, on epätosi. Kaikki muut arvot ovat tosia. Erillistä tietotyyppiä totuusarvolle ei ole.

Lausekkeita voidaan vertailla operaattoreilla == (yhtä suuri), != (erisuuri), < (pienempi), > (suurempi), <= (pienempi tai yhtä suuri) ja >= (suurempi tai yhtä suuri). Lisäksi käytössä on loogiset operaattorit ! (tosi, jos lauseke on epätosi), && (tosi, jos kummatkin lausekkeet ovat tosia) ja || (tosi, jos ainakin jompikumpi lauseke on tosi). Sulkujen käyttö operaattoreiden yhteydessä on mahdollista.

Seuraavassa listassa on esimerkkejä tosista ja epätosista lausekkeista:

Huomaa merkintöjen = ja == ero. Edellistä käytetään arvon sijoittamiseen muuttujaan ja jälkimmäistä kahden lausekkeen vertailuun. Jos muuttujan arvoksi tulee muu kuin 0, on sijoituslauseke aina tosi.

Ehtolause if

if-ehtolauseen jäljessä oleva koodi suoritetaan, jos ehto on tosi. Seuraavassa esimerkissä tulostetaan tekstiä näytölle, jos a-muuttujan arvo on suurempi kuin viisi.

if (a > 5)
    printf("a on suurempi kuin viisi.\n");

Jos suoritettavia lauseita on useampia, ne täytyy kirjoittaa aaltosulkujen sisään. Seuraavassa esimerkissä a:n arvoksi muutetaan nolla, jos sen arvo on yli viisi. Sen jälkeen tulostetaan vielä tekstiä näytölle.

if (a > 5) {
    a = 0;
    printf("a:n arvo muuttui nollaksi, koska se oli yli viisi.\n");
}

Jos ehtolauseessa on else-osa, sen perässä oleva koodi suoritetaan silloin, kun ehto ei ole tosi. Seuraavassa esimerkissä tarkistetaan ensin, onko a-muuttujan arvo viisi. Jos ei ole, tarkistetaan onko a:n arvo suurempi kuin viisi. Jos ei ole näinkään, siirrytään viimeiseen else-lauseeseen ja a:n täytyy olla pienempi kuin viisi. Kussakin tapauksessa tulostetaan erilainen teksti näytölle.

if (a == 5)
    printf("a on viisi.\n");
else if (a > 5)
    printf("a on suurempi kuin viisi.\n");
else
    printf("a on pienempi kuin viisi.\n");

Seuraavassa on hieman monimutkaisempi ehtorakenne, joka ilmoittaa, onko vuosi karkausvuosi vai ei. Jos vuosiluku on neljällä jaollinen, se on karkausvuosi. Kuitenkin sadalla jaollinen vuosi on karkausvuosi ainoastaan silloin, kun se on myös 400:lla jaollinen. Aaltosulut eivät olisi oikeastaan pakollisia, koska joka ehdon perässä on vain yksi ohjelmalause, mutta ne ovat tässä mukana selkeyden vuoksi.

if (vuosi % 4 == 0) {
    if (vuosi % 100 == 0) {
        if (vuosi % 400 == 0) {
            printf("On karkausvuosi.\n");
        } else {
            printf("Ei ole karkausvuosi.\n");
        }
    } else {
        printf("On karkausvuosi.\n");
    }
} else {
    printf("Ei ole karkausvuosi.\n");
}

Silmukat while ja do

while-silmukan sisällä olevaa koodia toistetaan niin kauan, kuin silmukan alussa oleva ehto on tosi. Seuraava silmukka tulostaa näytölle luvut yhdestä kymmeneen. Aluksi a-muuttujan arvo on 1, ja sitä kasvatetaan joka tulostuksen jälkeen. Silmukkaa toistetaan niin kauan, kuin a:n arvo on 10 tai pienempi.

a = 1;
while (a <= 10) {
    printf("%d ", a);
    a++;
}
printf("\n");
/* tulostus: "1 2 3 4 5 6 7 8 9 10" */

do-silmukka on muuten täysin samanlainen kuin while-silmukka, paitsi että ehdon tarkistus on silmukan lopussa. Siksi do-silmukan välissä oleva koodi suoritetaan varmasti ainakin kerran. Seuraavassa on lukujen 1 – 10 tulostus toteutettuna do-silmukalla.

a = 1;
do {
    printf("%d ", a);
    a++;
} while (a <= 10);
printf("\n");
/* tulostus: "1 2 3 4 5 6 7 8 9 10" */

Pidä huolta siitä, että silmukan ehto muuttuu aikanaan epätodeksi. Muuten silmukka jatkuu loputtomiin ja ohjelma jumiutuu.

for-silmukka

for-silmukan määrittelyssä on kolme osaa: muuttujan alustus, silmukan jatkamisehto ja muuttujan kasvatus tai vähennys. Jokaisella kierroksella muuttujan arvo kasvaa tai vähenee, ja silmukan toistaminen jatkuu niin kauan, kuin ehto pysyy totena. Tässä on – kolmannen kerran – esimerkki, joka tulostaa näytölle luvut yhdestä kymmeneen.

for (i = 1; i <= 10; i++) {
    printf("%d ", i);
}
printf("\n");
/* tulostus: "1 2 3 4 5 6 7 8 9 10" */

Muuttujan arvo voi kasvaa yhtä suuremmissa tai pienemmissä erissä. Seuraavassa tulostetaan parilliset luvut 2, 4, 6, 8 ja 10. Joka kierroksella muuttujan arvo kasvaa kahdella.

for (i = 2; i <= 10; i += 2) {
    printf("%d ", i);
}
printf("\n");
/* tulostus: "2 4 6 8 10" */

Samaten muuttujan arvo voi vähentyä kasvamisen sijaan. Seuraavassa on lukujen 10 – 1 tulostus, jossa muuttujan arvo on aluksi 10, vähenee yhdellä joka kierroksella, ja silmukka jatkuu niin kauan, kuin muuttujan arvo on 1 tai suurempi.

for (i = 10; i >= 1; i--) {
    printf("%d ", i);
}
printf("\n");
/* tulostus: "10 9 8 7 6 5 4 3 2 1" */

Silmukan keskeyttäminen

Silmukka voidaan keskeyttää break-lauseella, vaikka ehto ei olisi vielä muuttunut epätodeksi. Lisäksi continue-lause siirtyy suoraan silmukan alkuun seuraavalle kierrokselle. Seuraavassa esimerkissä silmukka jatkuisi ehtonsa puolesta loputtomiin (jos luku ei ole 0, se on aina tosi), mutta break-lause keskeyttää silmukan, kun a:n arvo on yli kymmenen. Taas kerran siis luvut 1 – 10 tulevat näytölle.

a = 1;
while (1) {
    printf("%d ", a);
    a++;
    if (a > 10)
        break;
}
printf("\n");
/* tulostus: "1 2 3 4 5 6 7 8 9 10" */

Funktio

Funktio koostuu kahdesta osasta: koodin alussa olevasta esittelystä ja itse funktiosta. Seuraavassa on funktio nimeltä moikka, joka tulostaa näytölle tervehdyksen aina, kun sitä kutsutaan. Ohjelmassa funktiota kutsutaan kolmesti, minkä vuoksi näytölle tulostuu kolmesti teksti "Moikka!" ja rivinvaihto. Funktion esittely on samanlainen kuin itse funktion ensimmäinen rivi, mutta se päättyy puolipisteeseen.

#include <stdio.h>

/* funktion esittely */
void moikka(void);

int main(void) {
    /* funktiokutsu */
    moikka();
    moikka();
    moikka();
    return 0;
}

/* itse funktio */
void moikka(void) {
    printf("Moikka!\n");
}

Parametrit ovat muuttujia, jotka välittyvät funktiolle sitä kutsuneesta koodista. Funktion parametrit kirjoitetaan sulkuihin funktion nimen jälkeen. Jos parametreja ei ole, niiden paikalle tulee merkintä void. Jos parametreja on useampia, ne erotetaan pilkuilla. Seuraava funktio (muista kirjoittaa esittely koodin alkuun!) tulostaa parametrina olevan markkamäärän sekä vastaavan rahamäärän euroina.

void euroiksi(float markat) {
    printf("%.2f markkaa on %.2f euroa.\n", markat, markat / EUROKERROIN);
}

Koodin alussa on määritelty vakioksi euron ja markan välinen muuntokerroin (1 euro = 5,94573 markkaa). Jos sama muuttumaton arvo saattaa toistua useassa ohjelman kohdassa, kannattaa käyttää vakioita, koska vakion arvon muuttaminen vaikuttaa samalla kertaa koko ohjelmaan ja vakion nimen muistaminen on helppoa. Ennen varsinaista ohjelman käännöstä vakiot korvautuvat niitä vastaavilla arvoilla.

#define EUROKERROIN 5.94573

Tätä funktiota voisi sitten kutsua ohjelmassa näin:

euroiksi(10);
/* tulostus: "10.00 markkaa on 1.68 euroa." */

Funktiota voisi kuitenkin vielä parantaa. Euromäärälle saattaa tulla ohjelmassa muutakin käyttöä, joten on parempi, jos funktio suoraan tulostamisen sijasta palauttaa arvonaan euromäärän funktiota kutsuneeseen koodiin. Palautusarvon tyyppi merkitään funktion alkuun, ja jos funktio ei palauta mitään, niin tyypin tilalla on void. Palautusarvon asettava return-lause poistuu saman tien funktiosta. Uusi monikäyttöisempi funktio näyttää tältä:

float euroiksi(float markat) {
    return markat / EUROKERROIN;
}

Nyt funktiota voisi käyttää ohjelmassa vaikkapa näin:

printf("Kirja maksaa %.2f euroa.\n", euroiksi(60));
/* tulostus: "Kirja maksaa 10.09 euroa." */

Funktion palautusarvoa voidaan siis käyttää aivan samalla tavalla kuin muuttujan arvoa.

Osoittimet

Jokaisella muuttujalla on tietokoneen muistissa oma paikkansa, johon sen arvo on tallennettu. Muuttujan muistiosoite selviää kirjoittamalla sen nimen eteen &-merkki. Osoitinmuuttuja, jonka nimen eteen määrittelyssä kirjoitetaan *-merkki, osoittaa toiseen ohjelmassa olevaan muuttujaan. Varsinainen muuttuja ja siihen liittyvä osoitinmuuttuja viittaavat yhteen ja samaan arvoon tietokoneen muistissa. Seuraavassa esimerkissä muuttujan arvoa muutetaan osoitinmuuttujan kautta.

/* muuttuja on tavallinen muuttuja, osoitin on osoitinmuuttuja */
int muuttuja, *osoitin;
/* laitetaan osoitin osoittamaan muuttujaan */
osoitin = &muuttuja;
/* asetetaan muuttujan arvoksi 123 */
*osoitin = 123;
/* nyt muuttujan arvo on 123! */
printf("%d\n", muuttuja);

Osoitinmuuttujan nimi sellaisenaan tarkoittaa siis muuttujan osoitetta. Jos nimen edessä on *-merkki, osoitin viittaa muuttujan sisältöön. Ennen kuin osoitinmuuttujaa voi käyttää, jonkun toisen muuttujan osoite täytyy tallentaa siihen. Osoitinmuuttujaan on tallennettu pelkästään muuttujan osoite tietokoneen muistissa, joka vaihtelee jokaisella ohjelman suorituskerralla.

Osoittimet ja funktiot

Osoittimia tarvitaan muun muassa silloin, kun kokonaisen taulukon tiedot täytyy välittää funktiolle. Koko taulukon sisältö ei voi olla nimittäin funktion parametrina. Funktiolle välitetään pelkästään taulukon ensimmäisen alkion osoite muistissa. Taulukon alkiot tallennetaan aina perätysten muistiin. Seuraavassa ohjelmassa funktiolle välitetään taulukon osoite, ja taulukon kaikki kolme alkiota tulostetaan näytölle.

#include <stdio.h>

void naytatiedot(int tiedot[3]);

int main(void) {
   int taulukko[3] = {1, 2, 3};
   naytatiedot(taulukko);
}

void naytatiedot(int tiedot[3]) {
    printf("%d %d %d\n", tiedot[0], tiedot[1], tiedot[2]);
    /* tulostus: "1 2 3" */
}

Mutta miksi ohjelmassa ei ole osoittimiin liittyviä merkintöjä? Tämä johtuu siitä, että funktion parametrina taulukko tarkoittaa oikeasti samaa kuin &taulukko[0] ja tiedot[indeksi] tarkoittaa samaa kuin *(tiedot + indeksi). Tällaisten lyhenteiden käyttäminen on vain paljon mukavampaa kuin osoitinmerkintöjen. Samaan tapaan mahdollista on välittää funktiolle tavallisen muuttujan tai tietuemuuttujan osoite. Tietueen yksittäiseen muuttujaan osoitetaan merkinnällä tietue->muuttuja, joka tarkoittaa samaa kuin (*tietue).muuttuja.

Osoittimille on käyttöä myös silloin, kun funktion täytyy palauttaa useampi kuin vain yksi arvo. Osoittimien avulla funktio pystyy muuttamaan sen parametrien arvoa pysyvästi. Esimerkissä on kolme muuttujaa, joiden arvoiksi funktio asettaa 12, 34 ja 56. Muuttujiin viitataan niiden osoitteiden avulla, jotka ovat funktion parametreina. Lopuksi muuttujien uudet arvot tulostetaan näytölle.

#include <stdio.h>

void arvot(int *a, int *b, int *c);

int main(void) {
    int eka, toka, kolmas;
    arvot(&eka, &toka, &kolmas);
    printf("%d %d %d\n", eka, toka, kolmas);
    /* tulostus: "12 34 56" */
}

void arvot(int *a, int *b, int *c) {
    *a = 12;
    *b = 34;
    *c = 56;
}

Tehtäviä

1. Määritä a:n ja b:n arvot niin, että lauseke 2 * a + b == 11 && 3 * a - b == 4 on tosi.

2. Mitä vikaa on seuraavassa koodissa?

   if (nopeus = 100) {
       printf("Nopeus on 100 km/h.\n");
   }

3. Mitä tarkoittaa *-merkki muuttujan nimen edessä? Entä &-merkki?

4. Muuta karkausvuoden tarkistus funktioksi, jonka parametrina on tarkistettava vuosi ja joka palauttaa arvon 1, jos vuosi on karkausvuosi, tai muuten arvon 0.

5. Kirjoita ohjelma, joka kysyy käyttäjältä syötettävien lukujen määrän, kysyy sitten nämä luvut yksi kerrallaan, ja lopuksi laskee ja tulostaa näytölle lukujen keskiarvon.

6. Kirjoita ohjelma, joka tulostaa näytölle kertotaulun 1 – 10. Muuta sitten ohjelmaa niin, että kertotaulun koon voi kirjoittaa koodin alussa vakion arvoksi.

7. C-kielessä switch-lausetta käytetään tähän tapaan:

   switch (a) {
       case 1:
           printf("a on yksi.\n");
           break;
       case 2:
           printf("a on kaksi.\n");
           break;
       case 3:
           printf("a on kolme.\n");
           break;
       default:
           printf("a on jotain muuta.\n");
           break;
   }

   Mitä parannuksia tekisit tämän ehtorakenteen muodostukseen, jos olisit C-kielen suunnittelija?

Antti Laaksonen, 19.2.2004