Oppaat: C-ohjelmointi: Osa 4 - Standardikirjasto

C-kielessä ei ole valmista keinoa tekstin tulostamiseen näytölle, tiedostojen käsittelyyn, neliöjuuren laskemiseen eikä moneen muuhunkaan tuiki tarpeelliseen asiaan. Tästä syystä jokaisen C-kääntäjän mukana on joukko ohjelmaan liitettäviä kirjastoja, joissa on juuri näitä usein käytettyjä funktioita. Yksi kirjastoista, stdio.h, on kaiketi ennestään tuttu. Näistä kirjastoista käytetään yhdessä nimitystä standardikirjasto, ja kirjastot ja niiden funktiot ovat samat kääntäjästä riippumatta. Tässä oppaassa tutustutaan moniin standardikirjaston funktioihin.

Merkkijonot

Erillistä tietotyyppiä merkkijonoille ei ole, vaan merkkijono tallennetaan char-tyyppiseen taulukkoon. Jokainen merkkijonon merkki vie yhden alkion taulukossa, minkä lisäksi taulukon viimeisessä alkiossa on nollamerkki. Tästä syystä merkkijonon "esimerkki" tallentamiseen tarvitaan taulukko, jossa on kymmenen alkiota:

char mjono[10] = "esimerkki";

0 1 2 3 4 5 6 7 8 9
e s i m e r k k i \0

Merkkijonon merkkejä voi käsitellä aivan samalla tavalla kuin taulukon arvoja. Esimerkiksi edellisessä merkkijonossa mjono[0] on merkki 'e' ja mjono[5] on 'r'. Nollamerkin ansiosta tiedetään, milloin merkkijono päättyy. Seuraava koodinpätkä laskee merkkijonon pituuden:

char mjono[10] = "esimerkki";
int p = 0;
/* kasvatetaan laskuria niin kauan, kuin merkki ei ole nollamerkki */
while (mjono[p] != '\0') {
    p++;
}
printf("Merkkijonon pituus on %d merkkiä.\n", p);

On tärkeää huomata, että koska merkkijonot ovat taulukoita, niitä ei voi vertailla ja yhdistellä tavallisten muuttujien tapaan. Jokaisessa merkkijonoihin liittyvässä toimenpiteessä täytyy ottaa huomioon, että merkkijono on taulukko.

Merkkijonojen käsittely

Standardikirjastossa string.h on joukko tavallisimpia merkkijonoihin liittyviä funktioita. Muun muassa seuraavat funktiot ovat käytössä silloin, kun string.h on liitetty ohjelman alkuun #include-komennolla:

strlen(mjono)           Funktio palauttaa merkkijonon merkkien määrän.
strcpy(kohde, lähde)    Merkkijonon kopiointi toiseen merkkijonoon.
strcmp(mjono1, mjono2)  Kahden merkkijonon vertailu aakkosjärjestyksessä, palautusarvo: 1
                        (mjono1 suurempi), -1 (mjono2 suurempi) tai 0 (merkkijonot samat).
strcat(mjono, jatke)    Kahden merkkijonon yhdistäminen.

Tässä on edellisiin funktioihin liittyvä esimerkki:

#include <stdio.h>
#include <string.h> /* merkkijonofunktiot */

int main(void) {
    char eka[4] = "esi", toka[7] = "merkki";
    char tulos[12];
    printf("%s %d\n", eka, strlen(eka));     /* näytetään eka ja sen pituus   */
    printf("%s %d\n", toka, strlen(toka));   /* näytetään toka ja sen pituus  */
    strcpy(tulos, eka);                      /* kopioidaan tulokseen eka      */
    strcat(tulos, toka);                     /* liitetään tulokseen toka      */
    printf("%s %d\n", tulos, strlen(tulos)); /* näytetään tulos ja sen pituus */
    return 0;
}

Merkkijonotaulukoiden, joiden lopussa on nollamerkki osoittamassa taulukon päättymisestä, käytössä piilee eräs vaara. Jos nollamerkin päälle epähuomiossa kirjoittaa jotain, merkkijonon loppua ei enää tiedetä, ja tietokoneen muistiin saattaa tallentua tietoa taulukon tilanvarauksen jälkeen. Näin voi käydä silloin, kun merkkijono kopioidaan tai yhdistetään liian pieneen taulukkoon. Funktiot strncpy, strncmp ja strncat toimivat muuten samalla tavalla kuin esikuvansa, paitsi että niissä on kolmas parametri, joka ilmoittaa kopioitavien tai vertailtavien merkkien suurimman sallitun määrän.

Muuttujien liittäminen merkkijonon keskelle tapahtuu sprintf-funktiolla, joka toimii lähes samalla tavalla kuin aiemmin tutuksi tullut printf-funktio. Erona on se, että näytölle tulostamisen sijasta tiedot tallennetaan funktion ensimmäisenä parametrina olevaan merkkijonoon. Funktiossa on kuitenkin vaaransa, nimittäin merkkijonolle pitää olla tarpeeksi tilaa, tai tapahtuu kummia:

char edellinen[16] = "edellinen", mjono[16], seuraava[16] = "seuraava";
sprintf(mjono, "Lukujen %d, %d ja %d summa on %d.", 1, 2, 3, 1 + 2 + 3);
printf("mjono = %s\n", mjono); /* "Lukujen 1, 2 ja 3 summa on 6." */
printf("edellinen = %s\n", edellinen); /* "edellinen" */
printf("seuraava = %s\n", seuraava); /* "3 summa on 6." <= Huomaa virhe! */

Edellä tapahtuvaa virhettä kutsutaan ylivuodoksi (engl. overflow). Siinä taulukon rajojen yli menevä tieto tallentuu taulukon jälkeiseen muistiin. Seurauksena voi olla esimerkiksi ohjelman kaatuminen tai tietojen muuttuminen.

Koodin saa turvalliseksi funktiolla snprintf, joka toimii samalla tavalla kuin sprintf mutta ottaa toisena parametrina maksimipituuden. Jos merkkijono on liian pitkä, se katkaistaan maksimipituuteen. Tavallisen taulukon koon saa selville kätevästi sizeof-operaatiolla.

char edellinen[16] = "edellinen", mjono[16], seuraava[16] = "seuraava";
/* Täytetään enintään taulukon koon verran (sizeof(mjono)). */
snprintf(mjono, sizeof(mjono), "Lukujen %d, %d ja %d summa on %d.", 1, 2, 3, 1 + 2 + 3);
printf("mjono = %s\n", mjono); /* "Lukujen 1, 2 ja" <= Teksti katkeaa. */
printf("edellinen = %s\n", edellinen); /* "edellinen" */
printf("seuraava = %s\n", seuraava); /* "seuraava" */

Samoin kuin sprintf muuttaa tietoa merkkijonoksi, sscanf-funktio lukee merkkijonosta mallin mukaan tietoa muuttujiin. Tämän lisäksi merkkijonossa olevan luvun muuttaminen lukumuuttujaksi tapahtuu funktioilla atoi (int), atol (long) ja atof (double) palautettavan muuttujatyypin mukaan.

Tulostus ja syöttö

Tulostukseen käytettävä funktio printf ja syötettä lukeva scanf ovat jo vanhoja tuttuja oppaan edellisistä osista. Aikaisemmin näiden funktioiden toimintaan on viitattu helppotajuisilla ilmauksilla "kirjoittaminen näytölle" ja "lukeminen näppäimistöltä". Näin usein onkin, mutta ei kuitenkaan aina. Esimerkiksi jos ohjelma käynnistetään komentorivillä seuraavalla tavalla, syöte luetaan tiedostosta luku.txt ja tulostus tapahtuu tiedostoon kirjoitus.txt.

ohjelma < luku.txt > kirjoitus.txt

Standardikirjastossa stdio.h on muutama muu tulostamiseen ja syötteen lukemiseen liittyvä funktio: putchar ja getchar yhden merkin tulostamiseen tai lukemiseen, sekä puts ja gets yhden rivin tulostamiseen tai lukemiseen. Kun käytetään funktiota gets, merkkijono luetaan kokonaan rivin loppuun asti, vaikka siinä olisi välilyöntejä.

char nimi[30]; /* tämän taulukon täytyy olla riittävän iso luettavalle merkkijonolle */
printf("Kirjoita nimesi: ");
gets(nimi);
printf("Terve, %s!\n", nimi);

Tiedostojen käsittely

Tiedostojen käsittelyyn liittyvät funktiot sisältyvät nekin stdio.h-kirjastoon. Aluksi ohjelmaan täytyy kirjoittaa tiedosto-osoittimen määrittely:

FILE *tiedosto;

Tämän jälkeen tiedoston avaaminen lukemista tai kirjoittamista varten tapahtuu fopen-funktiolla. Ensimmäisenä parametrina on tiedoston nimi, ja toisena parametrina on avaustapa. Kun käsitellään tekstitiedostoja, avaustapa on "r" (luku), "w" (kirjoitus) tai "a" (kirjoitus loppuun). Jos kirjoitettavaa tiedostoa ei ole olemassa, se luodaan.

tiedosto = fopen("testi.txt", "w");

Nyt tiedosto sisältää avatun tiedoston osoittimen, jota käytetään jatkossa muissa tiedostofunktioissa. Jos tiedoston avaaminen epäonnistuu, osoittimeksi tulee NULL, joka on mm. stdio.h-kirjastossa määritelty vakio. Huom! Jos tiedostonimessä on mukana koko hakemistopolku (esim. "c:\omat\testi.txt"), täytyy kenoviivoja olla niiden erityismerkityksen vuoksi kaksi ("c:\\omat\\testi.txt").

Tekstitiedostoihin liittyvät funktiot ovat samantapaisia kuin tulostus- ja syöttöfunktiot; niiden edessä vain on f-kirjain ja yhtenä parametrina on tiedoston osoitin. Kirjoitusfunktioita ovat fprintf, fputs (yksi rivi, ei lisää rivinvaihtoa kuten puts!) ja fputc (yksi merkki), ja lukufunktioita ovat fscanf, fgets ja fgetc. Tässä kirjoitetaan avattuun tiedostoon kolme lukua samalle riville.

fprintf(tiedosto, "%d %d %d\n", 12, 34, 56);

Äsken kirjoitetut luvut voisi lukea tiedostosta näin (avaustapa tietenkin "r"):

fscanf(tiedosto, "%d %d %d", &luku1, &luku2, &luku3);

Kun tiedostosta on luettu tai siihen on kirjoitettu tarvittavat tiedot, tiedosto täytyy lopuksi sulkea. Tämä tapahtuu fclose-funktiolla.

fclose(tiedosto);

Välillä ei ole ennalta tiedossa, kuinka paljon tietoa tiedostossa on. Tällöin voidaan käyttää funktiota feof, jonka palautusarvo on tosi, kun tiedosto on luettu loppuun asti. Tässä on kokonainen ohjelma, joka lukee tiedoston kaikki rivit ja tulostaa ne näytölle. Ohjelmassa on mukana myös virheenkäsittely siltä varalta, että tiedostoa ei olekaan olemassa.

#include <stdio.h>

int main(void) {
    FILE *tiedosto;
    /* tähän taulukkoon rivi luetaan ennen sen tulostamista */
    char rivi[127];
    /* avataan tekstitiedosto lukemista varten */
    tiedosto = fopen("testi.txt", "r");
    /* onnistuiko tiedoston avaaminen? */
    if (tiedosto != NULL) {
        /* jatketaan tiedoston loppuun asti */
        while (!feof(tiedosto)) {
            /* luetaan seuraava rivi (kuitenkin korkeintaan 127 merkkiä) */
            fgets(rivi, 127, tiedosto);
            /* tulostetaan näytölle äsken luettu rivi */
            printf("%s", rivi);
        }
        fclose(tiedosto);
    } else {
        printf("Myttyyn meni!\n");
    }
    return 0;
}

Jos tiedosto avataan binäärimuodossa, avaustapa on "rb", "wb" tai "ab", ja kirjoitukseen ja lukuun käytetään funktioita fwrite ja fread.

Matemaattiset funktiot

Matemaattiset funktiot ovat kirjastossa math.h. Seuraavassa taulukossa on muutama usein tarvittava kirjastossa oleva funktio:

pow(luku, eksp) potenssilasku
sqrt(luku)      neliöjuuri
ceil(luku)      pyöristys ylöspäin (kok.luvuksi)
floor(luku)     pyöristys alaspäin (kok.luvuksi)
sin(luku)       sinifunktio
cos(luku)       kosinifunktio
tan(luku)       tangenttifunktio

Seuraava ohjelma laskee suorakulmaisen kolmion hypotenuusan pituuden, kun kaksi kateettia on tiedossa. Suorakulmaisessa kolmiossa on voimassa Pythagoraan lause a2 + b2 = c2, jossa a ja b kuvaavat kateetteja ja c on hypotenuusa. Sen vuoksi hypotenuusan pituus lasketaan kaavalla c = √(a2 + b2).

#include <stdio.h>
#include <math.h> /* matematiikkafunktiot */

int main(void) {
    float k1, k2, h;
    printf("Kirjoita kolmion kateettien pituudet: ");
    /* kysytään pituudet käyttäjältä välilyönnillä erotettuina */
    scanf("%f %f", &k1, &k2);
    /* lasketaan hypotenuusan pituus kateettien perusteella */
    h = sqrt(pow(k1, 2) + pow(k2, 2));
    /* tulostetaan hypotenuusan pituus kahden desimaalin tarkkuudella */
    printf("Hypotenuusan pituus on %.2f\n", h);
}

Päivämäärien käsittely

Kirjastossa time.h on päivämääriin ja aikoihin liittyviä funktiota. Päivämäärien tallennusmuoto on kuluneiden sekuntien määrä hetkestä 1.1.1970. Tämänhetkisen päivämäärän ja ajan saa selville funktiolla time, ja sekuntiluvun muuttaminen järkevämpään muotoon tapahtuu esimerkiksi funktiolla localtime. Seuraava esimerkki tulostaa näkyviin päivämäärän, kellonajan sekä pari muuta tietoa.

#include <stdio.h>
#include <time.h> /* päivämääräfunktiot */

int main(void) {
    time_t nyt;             /* sekuntiluku */
    struct tm *aika;        /* päivämäärätietue */
    time(&nyt);             /* haetaan tämänhetkinen päivämäärä */
    aika = localtime(&nyt); /* muutetaan päivämäärä järkevään muotoon */
    printf("Nyt on %d.%d.%d %d:%d:%d\n", aika->tm_mday, aika->tm_mon + 1,
        1900 + aika->tm_year, aika->tm_hour, aika->tm_min, aika->tm_sec);
    printf("Viikonpäivä %d, vuodenpäivä %d\n", aika->tm_wday, aika->tm_yday);
    printf("%d\n", nyt);
}

Tietueen osoittimen yhteydessä käytetään merkintää ->. Päivämäärän esitykseen liittyy muutamia huomionarvoisia asioita: Jostain syystä kuukausien laskeminen aloitetaan nollasta, eli tammikuu on 0 ja joulukuu on 11. Vuoteen täytyy lisätä 1900, eli vuosi 2004 on ilmoitettu muodossa 104. C-kielen (ja amerikkalaisten) mukaan viikko alkaa sunnuntaista, eli 0 on sunnuntai ja 6 on lauantai.

Satunnaisluvut

Satunnaislukuihin liittyvät funktiot ovat kirjastossa stdlib.h. Satunnaislukugeneraattorin alustaminen tapahtuu srand-funktiolla, ja tavallisesti siemenlukuna käytetään senhetkistä aikaa. Samalla siemenluvulla on satunnaislukusarja aina sama. Sen jälkeen rand-funktio palauttaa luvun ainakin väliltä 0 – 32767. Näppärä keino laskea tästä luvusta satunnaisluku omavalintaisella asteikolla on käyttää jakojäännöstä apuna. Seuraava ohjelma arpoo kymmenen satunnaislukua väliltä 0 – 9.

#include <stdio.h>
#include <time.h>
#include <stdlib.h> /* satunnaisluvut */


int main(void) {
    int i;
    time_t siemen;
    time(&siemen);
    /* alustetaan satunnaislukugeneraattori */
    srand(siemen);
    /* tulostetaan kymmenen satunnaislukua väliltä 0 - 9 */
    for (i = 0; i < 10; i++) {
        printf("%d\n", rand() % 10);
    }
}

Lopuksi

Tässä oppaassa ei ole ollut mahdollista esitellä kuin murto-osa standardikirjaston funktioista. Lisää tietoa kirjastoista ja funktioista on esimerkiksi seuraavilla Internet-sivustoilla:

• C/C++ Reference
• C++ Library Reference

Standardikirjaston lisäksi on olemassa lukematon määrä muita kirjastoja mitä erilaisimpiin tarkoituksiin. Omia kirjastoja voi tietysti tehdä myös itse.

Tehtäviä

1. Kuinka merkkijonot tallennetaan C-kielessä?

2. Seuraavan koodinpätkän kirjoittaja on tehnyt montakin virhettä merkkijonojen käsittelyssä. Tee korjaukset.

   char nimi[10];
   nimi = "esi";
   nimi = nimi + "merkki";
   if (nimi == "esimerkki") {
       printf("Ohjelma toimii!\n");
   }

3. Mitä yhteisiä piirteitä löydät näytölle tulostamisesta ja näppäimistön lukemisesta, merkkijonojen käsittelystä ja tiedostojen käsittelystä?

4. Kirjoita ohjelma, joka tulostaa tiedostoon alkuluvut väliltä 2 – 100. Alkuluku on luku, joka on jaollinen pelkästään yhdellä sekä itsellään. Ensimmäiset alkuluvut ovat 2, 3, 5, 7, 11 ja 13. Hyödynnä jakojäännöstä!

5. Kirjoita ohjelma, joka laskee ja tulostaa näytölle tiedostossa olevien aakkosmerkkien määrän (isojen ja pienten kirjainten välille ei eroa). Esimerkkitiedosto:

   Tässä kaikki!

   Ja vastaava tulostus:

   A 1
   I 2
   K 3
   S 2
   T 1
   Ä 2

6. Kirjoita ohjelma, joka ratkaisee toisen asteen yhtälön. Jos yhtälö on ax2 + bx + c, niin ratkaisukaava on x = (-b ± √(b2 - 4ac)) / 2a.

7. Kirjoita ohjelma, joka tarkistaa henkilötunnuksen oikeellisuuden. Tietoa henkilötunnuksen muodostumisesta on esim. täällä.

8. Ovatko rand-funktion tuottamat satunnaisluvut oikeasti satunnaisia?

9. (Vaikea:) Tee itse localtimen tapainen funktio, joka laskee sekuntiluvun perusteella päivän, kuukauden, vuoden, tunnit, minuutit ja sekunnit.

Kaikkien tehtävien ratkaisut tulevat opassarjan seuraavaan osaan, joka on samalla viimeinen!

Antti Laaksonen, 8.4.2004