Syöttö- ja tulostusoperaatiot

Transkriptio

1 Syöttö- ja tulostusoperaatiot 19 Syöttö- ja tulostusoperaatiot C++-kieli ei itse sisällä mitään määräyksiä syötölle ja tulostukselle. Tämän luvun aiheena on standardikirjaston syöttö- ja tulostusmahdollisuudet, jotka tarjoavat ohjelmallesi laitteesta riippumattomat syöttö- ja tulostusoperaatiot. Olemme jo käyttäneet osaa näistä operaatioista kaikissa esimerkeissämme, kun olemme lukeneet syöttötietoa näppäimistöltä ja kirjoittaessamme näytölle. Nyt käsittelemme näitä lisää. Käsittelemme myöskin, miten voimme lukea ja kirjoittaa levylle. Tässä luvussa käsittelemme seuraavia aiheita: Mika virta on Mitkä ovat standardivirrat Miten binäärivirrat eroavat tekstivirroista Miten tiedostovirtoja luodaan ja miten niitä käytetään Miten virtojen operaatioiden virheet rekisteröidään ja miten niitä käsitellään Miten muotoilemattomia virtaoperaatioita käytetään Miten numeerista tietoa kirjoitetaan tiedostoon binäärisenä Miten olioita voidaan kirjoittaa virtaan ja lukea virrasta Miten <<- ja >>-operaattorit määritellään uudelleen luokalle Virtojen tuen toteutus malleille Miten luodaan merkkijonovirtoja C++:n syöttö ja tulostus Kun kirjoitat C++-ohjelmiasi, tarvitset monenlaisia syöttö- ja tulostusoperaatioita. Ohjelmasi saattaa tarvita lukea tietoa tietokannasta, muodostaa ja näyttää grafiikkaa näytöllä, olla yhteydessä toiseen tietokoneeseen modeemin avulla tai lähiverkon välityksellä. Kaikilla näillä esimerkeillä on (vähintään) yksi yhteinen tekijä: ne ovat kokonaan C++-kielen ja kirjastojen toiminnallisuuden ulkopuolella. 755

2 C++ Ohjelmoijan käsikirja Tämä tarkoittaa sitä, että useimmissa tapauksissa käytät syöttö- ja tulostusominaisuuksia, jotka eivät ole osa C++:n standardia, vaikka ne voivat hyvinkin olla osa C++-kehitysympäristöäsi. Saattaa olla myös niin, että jotkut C++:n ominaisuudet eivät ole yhteensopivat sen ympäristön kanssa, jossa ohjelma on tarkoitus suorittaa. Tietokoneesi kontrolloi näytön ja näppäimistön käsittelyä ja voi olla niin, että cin ja cout eivät ole mahdollisia. Näin on esimerkiksi silloin, kun ohjelmoit esimerkiksi Microsoft Windows -ohjelmia. Näitä ominaisuuksia kuitenkin emuloidaan useissa Windowsin C++ -kehitysympäristöissä. C++:ssa määritellyt ominaisuudet ovat tietysti yhä tärkeitä, koska ne muodostavat standardikirjaston monenlaiset toiminnallisuudet. Ne eivät pelkästään tarjoa tiedoston syöttö- ja tulostusominaisuuksia, vaan sisältävät myös tiedon muotoilun merkkijonopohjaisen I/O:n avulla. Virrat Standardikirjaston syöttö- ja tulostustoiminnot tapahtuvat virtojen avulla. Virta on abstrakti kuvaus syöttö- tai tulostuslaitteesta, joka on ohjelmasi tiedon lähteenä tai kohteena. Voit havainnollistaa virtoja merkkien jonona, joka virtaa ulkoisen laitteen ja tietokoneesi keskusmuistin välillä. Voit kirjoittaa tietoa tulostusvirtaan ja lukea tietoa syöttövirrasta; jotkut virrat tukevat sekä tietojen syöttöä että tulostusta. Virtojen tiedonsiirrossa on kaksi muotoa: tekstimuoto ja binäärimuoto. Vaikka merkkien virtaa luetaan ja kirjoitetaan molemmissa muodoissa, tekstimuodossa virta voi muuntaa joitakin merkkejä, kun ne luetaan tai kirjoitetaan fyysiseen virtaan. Milloin tällainen muunnos tapahtuu ja miten merkit muunnetaan, riippuu laiteympäristöstä. Joissain laitteistoissa virtaan kirjoitettu yksittäinen rivinvaihtomerkki korvataan kahdella merkillä: rivinvaihdolla ja rivinpalauttimella. Binäärimuodossa tällaisia muunnoksia ei tehdä, joten alkuperäiset merkit siirretään sellaisinaan. Kahden tiedonsiirtomuodon lisäksi on kaksi tapaa, joilla voit lukea tietoa virrasta tai kirjoittaa tietoa virtaan. Ensiksi voit lukea ja kirjoittaa erityyppistä tietoa <<- ja >>-operaattoreiden avulla. Näin olemme tehneet kirjan kaikissa esimerkeissä lukiessamme näppäimistöltä tai kirjoittaessamme näytölle. Ne ovat muotoiltuja syöttö/tulostusoperaatioita. Binäärinen, numeerinen tieto, kuten kokonaisluvut ja liukuluvut, muunnetaan vastaavaan merkkimuotoon ennen kuin ne kirjoitetaan virtaan ja vastaavasti toisin päin, kun tietoa luetaan. Nämä operaatiot voivat olla teksti- tai binäärimuodossa, mutta yleisemmin ne suoritetaan tekstimuodossa. Kaikki tämän kirjan cout-virtaan kirjoitukset ja cin-virrasta luvut ovat tekstimuotoisia muotoiltuja I/Ooperaatioita. Toinen virtojen käyttötapa on lukea tai kirjoittaa merkkipohjaista tietoa. Luku- tai kirjoitusoperaatio voi kohdistua yhteen merkkiin, tiettyyn määrään merkkejä tai merkkijoukkoon, jonka päättää jonkinlainen erotinmerkki. Kaikkein tärkeintä tässä käyttötavassa on mahdollisuus lukea tai kirjoittaa tavuja. Nämä ovat muotoilemattomia syöttö/tulostusoperaatioita. Vaikka nämä operaatiot eivät itse muotoile tietoa, tekstimuodon tieto voidaan silti muuntaa, riippuen suoritusympäristöstä. 756

3 Syöttö- ja tulostusoperaatiot Pääsyy virtojen käytölle C++:ssa on se, että lähdeteksti voidaan näin tehdä riippumattomaksi itse kohteena olevasta fyysisestä laitteesta. Tällä on muutamia etuja. Ensinnäkin sinun ei tarvitse murehtia kunkin laitteen fyysisiä ominaisuuksia, koska ne otetaan huomioon virran toimesta. Toiseksi, ohjelmasi toimii näin hyvinkin erilaisten syöttö/tulostuslaitteiden kanssa ilman, että koodiin tulee tehdä mitään muutoksia. Tulostusvirran fyysisenä kohteena - eli laitteena, johon kirjoittamasi tieto lopulta menee - voi olla mikä tahansa laite, joka voi ottaa vastaan tavuja. Se on tavallisesti näyttö, kiintolevyn tiedosto tai kirjoitin. Standardikirjasto määrittelee kolme tulostusvirtaa, cout, cer ja clog, jotka on tavallisesti liitetty näyttöön. cout on standardi tulostusvirta ja sekä cerr että clog ovat kummatkin liitetyt standardiin virhevirtaan, jota käytetään ilmoittamaan ohjelmasi virheistä. Kahden jälkimmäisen virran ero on siinä, että cerr on puskuroimaton (eli tieto kirjoitetaan välittömästi tulostuslaitteelle) ja clog on puskuroitu (eli tieto kirjoitetaan vasta, kun puskuri on täynnä). Tieto Tieto Ohjelma Syöttövirrat Näppäimistö cin Tulostusvirrat cout cerr clog Kirjoitin Näyttö Syöttövirta voi periaatteessa myös olla mikä tahansa tiedon lähde, mutta se on tavallisesti tiedosto tai näppäimistö. Standardikirjasto määrittelee standardin syöttövirran cin, joka on tavallisesti liitetty näppäimistöön. Kuten olet jo varmasti arvannut, C++:n virrat ovat luokkien olioita ja standardivirrat ovat etukäteen määriteltyjä olioita, jotka on valmiiksi liitetty laitteistosi tiettyyn ulkoiseen laitteeseen. Kun olemme lukeneet olioita cin-virrasta >>-operaattorin avulla tai kirjoittaneet olioita coutvirtaan <<-operaattorin avulla, olemme käyttäneet näiden olioiden uudelleenmääriteltyjä operator<<() ja operator>>() -funktioita. Standardivirtojen kohdalla kaikki on valmiiksi määritelty ja niitä voidaan käyttää suoraan. Jos kuitenkin haluat käyttää jotain muita virtoja kuin standardivirtoja - esimerkiksi tiedostojen syöttöä ja tulostusta - sinun tulee luoda tarvittavat oliot ja liittää ne fyysiseen tiedon lähteeseen tai kohteeseen. Katsotaan seuraavaksi luokkia, jotka määrittelevät virrat. 757

4 C++ Ohjelmoijan käsikirja Virtaluokat Virtojen syöttöön/tulostukseen liittyy muutamia luokkia, mutta tärkeimmät, joista me olemme kiinnostuneet, ja niiden väliset suhteet kuvataan seuraavassa kaaviossa. ios_base Pitää kirjaa virran tilasta ja muodosta istream Perättäis- ja hajasyöttö ios Testaa ja asettaa virran tilan ostream Perättäis- ja hajatulostus ifstream Tiedostosyöttö iostream Perättäis- ja hajasyöttö/tulostus fstream Tiedosto syöttö/tulostus ofstream Tiedostotulostus 758 Tämä on yksinkertaistettu kuvaus, mutta se riittää perusteiden ymmärtämiseen. ios_base on tavallinen luokka, kun taas muut ovat mallien ilmentymiä - istream on esimerkiksi basic_istream-mallin ilmentymä ja ios on basic_ios-mallin ilmentymä. Olemme kuitenkin kiinnostuneet luokista eikä malleista, koska käytämme luokkia ohjelmissamme. Virtaluokilla on yhteinen kantaluokka, ios, joka perii ios_base-luokalta liput, jotka pitävät kirjaa virran tilasta ja käytössä olevasta muodosta. Eli kaikki syöttö/tulostusoperaatioita tarjoavat virtaluokat sisältävät yhteisen joukon tila- ja muotolippuja sekä funktiot niiden tutkimiseen ja asettamiseen. Standardi syöttövirta cin on istream-tyyppinen olio ja standardit tulostusvirrat cout, cerr ja clog ovat ostream-tyyppisiä olioita. Kuten huomaat, tiedostovirtojen luokilla ifstream, fstream ja ofstream on istream tai ostream tai molemmat kantaluokkana, joten operaatiot, joita olemme käyttäneet standardivirtojen kanssa, toimivat myös tiedostojen kohdalla. Malleilla on yleensä tyyppiparametrit, jotka määrittelevät tietyn virran merkkijoukon ja kaaviossa esitetyt luokat toimivat char-tyyppisten merkkien kanssa. Näistä malleista on ilmentymät myös wchar_t-tyyppisille merkeille, nimeltään wistrean, wostream, wiostream, wifstream, wofstream ja wfstream. Emme käsittele näitä luokkia tässä luvussa, mutta ne toimivat samaan tapaan kuin tavuperustaiset virtaluokat. Koska tulet joskus näkemään viittauksia alkuperäisiin malleihin niistä muodostettujen luokkien sijaan, sinun tulee tuntea myös mallien nimet. Virtojen luokat on määritelty typedef:n avulla:

5 Syöttö- ja tulostusoperaatiot typedef basic_ios<char> ios; typedef basic_istream<char> istream; typedef basic_ostream<char> ostream; typedef basic_iostream<char> iostream; typedef basic_ifstream<char> ifstream; typedef basic_ofstream<char> ofstream; typedef basic_fstream<char> fstream; Vastaavien wchar_t-tyyppisten merkkivirtojen kohdalla on tyyppiparametrin arvot wchar_t eikä char. Käytämme tässä luvussa lyhennettyjä muotoja, koska ne ovat huomattavasti helpompia kirjoittaa! Standardivirrat Standardivirrat on määritelty virtaluokkien olioina nimiavaruuteen std. Seuraavat määrittelyt ovat otsikkotiedostossa iostream: extern istream cin; extern ostream cout; extern ostream cerr; extern ostream clog; Otsikkotiedosto iostream määrittelee myös vastaavat wchar_t-tyyppiset oliot: extern wistream wcin; extern wostream wcout; extern wostream wcerr; extern wostream wclog; Olemme jo käyttäneet runsaasti standardia syöttövirtaa cin ja standardia tulostusvirtaa cout. cerr ja clog -virtoja käytetään aivan samaan tapaan kuin cout-virtaakin. Emme käsittele enää tässä luvussa standardivirtojen käyttöä, koska sitä on käsitelty jo kirjan aikaisemmissa luvuissa. Sen sijaan käsittelemme niiden sisäistä toimintaa ja miten samoja tekniikoita voidaan käyttää muidenkin virtojen yhteydessä. Aloitamme jo tutuista muotoilluista virtaoperaatioista ja käsittelemme niiden käyttöä tiedostojen yhteydessä. Sen jälkeen katsomme, miten muotoilemattomat virtaoperaatiot toimivat ja miten voimme käyttää niitä hyödyksemme. Virtojen <<- ja >>-operaattorit Standardivirtojen yhteydessä käyttämämme <<- ja >>-operaattorit toimivat aivan samaan tapaan myös muiden virtojen kanssa. Kaikki standardivirrat toimivat tekstimuodossa, koska tämän muoto varmistaa, että tieto tulostetaan oikein. <<- ja >>-operaattoreiden toimintaan kuuluu muuntaminen tiedon sisäisestä binäärisestä esitysmuodosta ulkoiseen merkkimuotoon. Kun käytät näitä operaattoreita muiden virtojen kuin standardivirtojen yhteydessä, haluat tavallisesti käyttää niitä tekstimuodossa, koska ne on tarkoitettu tekstimuotoisen datan käsittelyyn. Tekstimuotoa käytetään sen vuoksi, että tiedon esitysmuoto olisi oikea. 759

6 C++ Ohjelmoijan käsikirja Virtojen >>-operaattori Funktio operator>>() on toteutettu joukkona uudelleenmääriteltyjä istream-luokan jäseniä ja se tukee perustietotyyppien lukua mistä tahansa syöttövirrasta. Tästä operaattorista on uudelleenmääritelty versio jokaiselle C++:n perustietotyypille. Katsotaan, miten jo kirjoittamamme koodi liittyy näihin operaattoreihin, kun kirjoitamme esimerkiksi lauseet: int i = 0; double x = 0.0; cin >> i >>x; Muista, että cin on istream-tyyppinen olio. Viimeinen lause, joka lukee kaksi muuttujaa standardivirrasta, muuntuu tässä muotoon: (cin.operator>>(i)).operator>>(x); 760 Kuten saatat odottaakin, operator>>()-funktiota kutsutaan joka kerta, kun käytät >>operaattoria. Funktio operator>>() palauttaa viittauksen virtaolioon, jolle sitä kutsuttiin (tässä tapauksessa cin), joten paluuarvoa käytetään kutsuttaessa seuraavaa operaattorifunktiota. Funktion operator>>() parametrin tulee olla viittaus, jotta funktio voi tallettaa virrasta luetun arvon parametrinään saamaansa muuttujaan. Tyhjä merkki tulkitaan aina kahden arvon erottavaksi erotinmerkiksi, joten et voi lukea tyhjiä merkkejä ohjelmaasi istream-luokan operator>>()-jäsenillä. Ylimääräiset tyhjät merkit jätetään huomioimatta. Muistat varmaankin, että meidän tulee käyttää getline()-funktiota, jos haluamme lukea rivin tekstiä näppäimistöltä. Funktio operator>>() on toteutettu uudelleenmääriteltynä joukkona istream-luokan jäseniä. Se on määritelty seuraaville perustietotyypeille: short int long unsigned short unsigned int unsigned long float double long double bool void* Funktio, joka tukee näistä viimeistä, void*-tyyppiä, mahdollistaa osoitteen lukemisen minkä tahansa tyyppiseen osoittimeen, paitsi char-tyyppiseen osoittimeen, joka osoittaa null-merkkiin päättyvään merkkijonoon ja käsitellään erikoistapauksena. Minkä tahansa tyyppinen osoitin voidaan välittää parametrinä funktiolle. Käytössä on ei-jäsenversiot operator>>()-funktiosta, jotka hyväksyvät parametreinä null-merkkiin päättyvät merkkijonot. Niiden prototyypit ovat seuraavat: istream& operator>>(istream& in, signed char* pstr); istream& operator>>(istream& in, unsigned char* pstr); Jompaa kumpaa näistä osoittimista käytetään, kun käytät null-merkkiin päättyvää merkkijonoa >>-operaattorin yhteydessä. Jos haluat lukea osoitteen ja tallettaa sen char*-tyyppiseen osoittimeen, sinun tulee lukea se void*-tyyppisenä ja muuntaa osoite char*-tyyppiseksi ennen talletusta. Yksittäisen merkin lukeminen >>-operaattorin avulla voidaan myöskin tehdä operator>>()- funktiolla, joka ei ole istream-luokan jäsen, koska se voidaan toteuttaa istream-olioille määritellyllä get()-funktiolla. Tällaisia funktioita on kolme versiota, riippuen luettavan yksittäi-

7 Syöttö- ja tulostusoperaatiot sen merkin tyypistä: char, signed char ja unsigned char. Palaamme get()-funktioon myöhemmin tässä luvussa. Virtojen <<-operaattori Funktio operator<<() on uudelleenmääritelty ostream-luokassa perustietotyyppiä olevien arvojen muotoiltua tulostusta varten. Tulostus cout-virtaan toimii samalla tavalla kuin syöttö cinvirrasta. Voit kirjoittaa i:n ja x:n arvot cout-virtaan lauseella: cout << i << << x; Tämä lause muuntuu kolmeksi operator<<()-funktion kutsuksi: operator<<(cout.operator<<(i), ).operator<<(x); Kaikki operator<<()-funktion versiot palauttavat viittauksen virtaolioon, jolle sitä kutsuttiin, joten paluuarvoa voidaan aina käyttää uudessa operator<<()-funktion kutsussa. Kuten olemme jo maininneet, operator<<()-funktiot, jotka kirjoittavat virtaan yksittäisiä merkkejä ja nullmerkkiin päättyviä merkkijonoja, on toteutettu ei-jäsenfunktioina. Tästä syystä operaattorifunktio, jonka kutsu kirjoittaa i:n, on välilyönnin kirjoittavan funktiokutsun ensimmäinen parametri. Jälkimmäinen palauttaa virtaolion, jota käytetään kutsuttaessa jäsenfunktiota, joka kirjoittaa x:n arvon. Funktio operator<<() on uudelleenmääritelty ostream-luokassa samoille (edellä mainituille) tyypeille kuin operator>>()-funktio on uudelleenmääritelty istream-luokassa. Lisäksi yksittäisen merkin ja null-merkkiin päättyvän merkkijonon tulostusta tuetaan ei-jäsentyyppisellä versiolla operator<<()-funktiosta. Funktioiden, jotka tulostavat yksittäisen merkin tulostusvirtaan, prototyypit ovat seuraavat: ostream& operator<<(ostream& out, char ch); ostream& operator<<(ostream& out, signed char ch); ostream& operator<<(ostream& out, unsigned char ch); Vastaavat funktiot, jotka tulostavat null-merkkiin päättyvän merkkijonon, ovat seuraavat: ostream& operator<<(ostream& out, const char* pstr); ostream& operator<<(ostream& out, const signed char* pstr); ostream& operator<<(ostream& out, const unsigned char* pstr); Nyt huomaat, miksi voit tulostaa merkkijonon osoittimen avulla, vaikka muun tyyppiset osoittimet tulostetaan virtaan aina osoitteena. Koska nämä funktiot ovat olemassa, const char*-tyyppisen muuttujan lähettäminen tulostusvirtaan kirjoittaa merkkijonon, johon osoitin osoittaa, eikä osoitinmuuttujaan talletettua osoitetta. Jos jostain syystä haluat, että osoittimen osoite tulostetaan, sinun tulee eksplisiittisesti muuntaa se void*-tyyppiseksi. Tällöin kutsutaan tämän tyyppistä ostream-luokan funktiota ja osoite lähetetään virtaan. Eli seuraavat lauseet: const char* pviesti = Enemmän on vähemmän ja vähemmän on enemmän. ; cout << pviesti; Nyt viesti tulostetaan. Jos haluat tulostaa pviesti:n osoitteen, sinun tulee kirjoittaa tulostuslause seuraavasti: cout << static_cast<void*>(pviesti); 761

8 C++ Ohjelmoijan käsikirja Virtojen muokkausfunktiot Olemme jo käyttäneet useita muokkausfunktioita tulostuksen muotoilussa. Seuraavia muotoilufunktioita voidaan käyttää virtojen yhteydessä: Muokkausfunktio Tarkoitus 762 dec Asettaa kokonaisluvusta desimaaliluvuksi muunnoksen kantaluvun. oct Asettaa kokonaisluvusta oktaaliluvuksi muunnoksen kantaluvun. hex Asettaa kokonaisluvusta heksadesimaaliluvuksi muunnoksen kantaluvun. fixed Tulostaa liukuluvut kiinteän desimaalimäärän mukaan ilman eksponenttia. scientific Tulostaa liukuluvut tieteellisessä eksponenttimuodossa. boolalpha Esittää bool-arvot englanninkielisinä sanoina true ja false. noboolalpha Esittää bool-arvot lukuina 1 ja 0. showbase Näyttää oktaali- (0 etuliite) ja heksadesimaalikokonaisluvun (0x etuliite) kannan. noshowbase Jättää oktaali- ja heksadesimaalikokonaislukujen kannan näyttämättä. showpoint Tulostaa liukuluvut virtaan aina desimaalipisteellisinä. noshowpoint Tulostaa kokonaiset liukuluvut ilman desimaalipisteitä. showpos Tulostaa +-etuliitteen positiivisille kokonaisluvuille. noshowpos Ei +-etuliitettä positiivisille kokonaisluvuille. skipws Ohitetaan syötteen tyhjät merkit. noskipws Syötteen tyhjiä merkkejä ei ohiteta. uppercase Käytetään isoja kirjaimia heksadesimaalinumeroille A - F ja E eksponentille. nouppercase Käytetään pieniä kirjaimia heksadesimaalinumeroille a - f ja e eksponentille. internal Lisätään täyttömerkit, jotta tulostus on kentän levyinen. left Tasaa arvot tulostuskentän vasempaan reunaan. right Tasaa arvot tulostuskentän oikeaan reunaan. endl Kirjoittaa rivinvaihtomerkin virran puskuriin ja kirjoittaa puskurin sisällön virtaan. flush Kirjoittaa virran puskurin sisällön virtaan. Kaikki nämä muokkausfunktiot voidaan kirjoittaa suoraan virtaan: int 1 = 1000; cout << hex << uppercase << i; Tämä tulostaa kokonaisluvun i arvon heksadesimaalisena arvona, käyttäen isoja heksadesimaalinumeroita A- F. Eli näytölle tulostuu 3E8. On mielenkiintoista tutkia, miksi tämä toimii. Kuten tiedät, <<-operaattori saa aikaan operator<<()-funktion kutsun, mutta mitään näkemistämme muodoista ei voida käyttää tässä, koska ne käsittelevät ainoastaan virtaan tulostettuja arvoja. Näiden muokkausfunktioiden käyttöön ei kuulu tiedon lähettämistä virtaan, joten ne eivät voi olla arvoja. Kaikki edellisen

9 Syöttö- ja tulostusoperaatiot listan muokkausfunktiot ovat osoittimia samantyyppisiin funktioihin. Kun käytät muokkausfunktiota, kutsutaan operator<<()-funktion erikoisversiota, joka hyväksyy osoittimen funktioon ja jonka parametrinä on muokkausfunktio. Selventääksemme tätä, muokkausfunktio hex on tämän funktion nimi: ios_base& hex(ios_base& str); Voit käyttää tätä muokkausfunktiota esimerkiksi lauseessa: cout << hex << i; Tämä muuntuu muotoon: (cout.operator<<(hex)).operator<<(i); Ensimmäisessä operator<<()-funktion kutsussa on patametrinä osoitin funktioon, hex. Operaattorifunktiossa kutsutaan hex()-funktiota, joka asettaa tulostusmuodon siten, että i:n arvo tulostetaan virtaan heksadesimaalisessa muodossa. Luokka ios_base, joka esiintyi hex()-funktion prototyypissä, on ios-luokan kantaluokka. Koska kaikki virtaluokat on periytetty tästä luokasta, tyyppi ios_base& voi viitata mihin tahansa virtaolioon. Kaikki muokkausfunktiot ovat osoittimia funktioihin, joiden parametrin ja paluuarvon tyyppi on viittaus ios_base-luokkaan, joten niiden kaikkien tuloksena kutsutaan samaa operator<<()-funktion versiota, joka puolestaan kutsuu parametrin osoittamaa funktiota. ios_base määrittelee lippuja, jotka kontrolloivat virtaa. Muodostinfunktiota käytettäessä kutsuttava funktio muuttaa asiaankuuluvien lippujen tilaa, jotta saadaan oikea tulos. Voit muokata näitä lippuja suoraan virtaolion funktioilla setf() ja unsetf(), mutta muokkausfunktioiden käyttö on huomattavasti helpompaa. Parametrilliset muokkausfunktiot Tietyille muokkausfunktioille voidaan välittää parametri. Niiden käyttö vaatii, että sisällytät iomanip-otsikkotiedoston lähdetekstiisi, koska se sisältää näiden muokkausfunktioiden esittelyt. Näitä muokkausfunktioita käytetään samaan tapaan kuin muitakin muokkausfunktioita, eli lisäämällä funktion kutsu virtaan. Nämä muokkausfunktiot ovat seuraavat: Muokkausfunktio setprecision(int n) setw(int n) setfill(char ch) setbase(int base) Tarkoitus Asettaa liukulukujen tulostuksen tarkkuudeksi n numeroa. Tämä asetus säilyy voimassa kunnes muutat sen. Asettaa seuraavan tulostuksen kentän leveydeksi n merkkiä. Tämä asetus palautetaan oletusarvoiseksi jokaisen tulostuksen jälkeen. Oletusarvona on, että kenttä on juuri riittävä tulostettavaa arvoa varten. Asettaa täyttömerkiksi ch:n. Täyttömerkkiä käytetään, kun kentän leveys on tulostettavaa arvoa suurempi. Tämä asetus on modaalinen, joten se säilyy voimassa kunnes muutat sen uudelleen. Asettaa tulostusmuodon kokonaisluvusta oktaaliseen, desimaaliseen tai heksadesimaaliseen (vastaavat arvot ovat 8, 10 ja 16). Muut arvot eivät muuta tulostuksen kantalukua. 763

10 C++ Ohjelmoijan käsikirja Näiden kaikkien muokkausfunktioiden paluuarvon tyyppi on kääntäjäkohtainen. Voit käyttää niitä esimerkiksi seuraavanlaisessa lauseessa: cout << endl << setw(10) << setfill( * ) << left << i; Tämä lause tulostaa i:n arvon vasemmalle tasattuun kenttään, jonka leveys on 10 merkkiä. Kenttä täytetään *-merkeillä, jos tulostettavan arvon oikealle puolelle jäisi tyhjiä merkkejä. Täyttömerkki on voimassa kaikissa seuraavissakin tulostuksissa, mutta kentän leveys tulee säätää erikseen ennen jokaista tulostusta. On virhe kirjoittaa sulkeet sellaisten muokkausfunktioiden ympärille, jotka ovat osoittimia (kuten left). Joten älä sekoita niitä tässä käsittelemiimme neljään muokkausfunktioon. Otsikkotiedosto iomanip esittelee myöskin funktiot setiosflags() ja resetiosflags(), joita voit maskin avulla käyttää asettamaan tai palauttamaan virran muotoilua kontrolloivia lippuja. Funktiolle välitettävä maski muodostetaan bittitason OR-operaattorilla, jolloin voidaan yhdistää ios_base-luokassa määritellyt liput. Jokaisen lipun nimi on sama kuin sen asettavan muokkausfunktion nimi, joten voit asettaa vasemmalle tasaavan lipun ja heksadesimaalisen tulostuksen lipun seuraavasti: cout << endl << setw(10) << setiosflags(ios::left ios::hex) << i; Tämä tulostaa i:n vasemmalle tasattuna heksadesimaaliarvona kenttään, joka on 10 merkkiä leveä. Voimme kirjoitta liput ios:n avulla, koska liput on peritty ios-luokkaan ios_baseluokasta. 764 Tiedostovirrat Tiedostojen käsittelyssä voit käyttää kolmenlaisia virtaluokkien olioita: ifstream, ofstream ja fstream. Kuten näimme aikaisemmin, näiden kantaluokkina ovat vastaavasti luokat istream, ostream ja iostream. istream-olio mallintaa tiedostovirtaa, josta voit lukea, ofstream-olio mallintaa tiedostovirtaa, johon voit kirjoittaa ja fstream on tiedostovirta, josta voit lukea ja johon voit kirjoittaa. Voit liittää tiedostovirran olion levyn fyysiseen tiedostoon, kun luot sen. Vaihtoehtoisesti voit luoda tiedostovirtaolion, jota ei ole liitetty tiettyyn tiedostoon ja käyttää jäsenfunktiota liittämään olio tiettyyn fyysiseen tiedostoon. Jotta tiedostosta voidaan lukea tai kirjoittaa, tiedosto tulee avata liittämällä se ohjelmaasi kertomalla käyttöjärjestelmälle, miten aiot tiedostoa käyttää. Jos liität tiedoston tiedostovirtaolioon oliota luotaessa, tiedosto avataan heti ja se on heti ohjelman käytettävissä. Huomaa, että olioon liitettyä fyysistä tiedostoa voidaan muuttaa, joten voit käyttää yhtä ja samaa ofstream-oliota kirjoittamaan eri tiedostoihin ohjelman suorituksen eri vaiheissa. Tiedostovirralla on muutamia tärkeitä ominaisuuksia. Sillä on pituus, joka kertoo virran merkkien lukumäärän; sillä on alkukohta, joka on virran ensimmäinen merkki; ja sillä on loppukohta, joka on virran viimeistä merkkiä seuraava sijaintikohta. Sillä on myöskin nykyinen sijainti, joka on virran merkin indeksi, josta seuraava luku tai kirjoitus alkaa. Tiedostovirran ensimmäinen merkki on sijaintikohdassa 0. Näiden ominaisuuksien avulla voit liikkua tiedostossa ja lukea kiinnostavat osat tai kirjoittaa vain tiedoston tiettyihin osiin.

11 Tiedostoon kirjoittaminen Syöttö- ja tulostusoperaatiot Aloitamme tiedostovirtojen tutkimisen katsomalla, miten voimme kirjoittaa tiedostovirtaan. Tulostustiedosto kuvataan ofstream-oliolla, jonka voimme luoda seuraavasti: ofstream tultied( tiedostonimi ); tiedostonimi-niminen tiedosto avataan automaattisesti tulostusta varten, joten voit kirjoittaa siihen välittömästi oletusmuodossa, eli tekstimuodossa. Jos tiedostoa tiedostonimi ei ole olemassa, se luodaan. Jos se on olemassa, kaikki tiedostoon aikaisemmin talletettu tieto menetetään ja nyt tiedostoon kirjoittamastasi tulee tiedoston uusi sisältö. Vaikka et edes kirjoittaisi tiedostoon tiedoston avauksen jälkeen, tiedostoon aikaisemmin talletettu tieto menetetään ja tiedosto on tyhjä tiedosto. Oliolla tultied on ostream-aliolio, joten kaikki standardivirran cout yhteydessä käsittelemämme virtaoperaatiot toimivat myös tultied-olion yhteydessä. Voimme testata tätä uudella versiolla luvun 7 esimerkistä 7.6, joka muodosti alkulukuja. Kokeile itse - Tiedostoon kirjoittaminen Voimme kirjoittaa alkuluvut näytön sijaan tiedostoon. Meidän tarvitsee ainoastaan määritellä ostream-olio tiedostoa varten ja käyttää sitä cout-olion tilalla. Seuraavassa ovat muuttuneet koodirivit esitetty harmaina: // Esimerkki Tiedostoon kirjoittaminen #include <fstream> // Tiedostovirtoja varten #include <iostream> #include <iomanip> using namespace std; int main() const int max = 100; long alkuluvut[max] = 2, 3, 5; int lkm = 3; long koe = 5; bool onalkuluku = true; do koe += 2; int i = 0; // Alkulukujen haluttu määrä // Ensimmäiset kolme alkulukua // Laskettujen alkulukujen lukumäärä // Alkulukukandidaatti // Alkuluku on löydetty // Seuraava tarkistettava arvo // Alkulukutaulukon indeksi // Yritetään jakaa alkulukukandidaatti kaikilla jo löydetyillä alkuluvuilla do onalkuluku = koe % *(alkuluvut + i) > 0; // False jos jaollinen while(++i < lkm && onalkuluku); if(onalkuluku) // Alkuluku löytyi... *(alkuluvut + lkm++) = koe; //...joten talletetaan se alkulukuihin while(lkm < max); ofstream tultied("c:\\harjdata\\aluvut.txt"); // Määritellään tiedostovirtaolio 765

12 C++ Ohjelmoijan käsikirja // Tulostetaan viisi alkulukua riville for(int i = 0 ; i < max ; i++) if(i % 5 == 0) tultied << endl; tultied << setw(10) << *(alkuluvut + i); cout << endl; return 0; // Rivinvaihto 1. riville ja joka 5. alkuluvun jälkeen Tämä ohjelma ei lähetä mitään tulostusta näytölle. Ainoa tulostus tapahtuu tiedostoon. Huomaa, että jos käytät esimerkissä ollutta hakemistopolkua, sinun tulee luoda HarjData-kansio ennen ohjelman suoritusta. Ohjelma luo ainoastaan tiedoston, ei kansiota. Kuinka se toimii Ensiksi sisällytämme fstream-otsikkotiedoston, joka määrittelee tiedostovirtojen luokat: #include <fstream> // Tiedostovirtoja varten Emme enää tarvitse iostream-otsikkotiedostoa, koska emme käytä yhtäkään standardivirtaa. Kaikki laskennat ovat samat kuin luvussa 7, joten ensimmäinen muutos main()-funktiossa on tulostustiedostovirran olion esittely: ofstream tultied("c:\\harjdata\\aluvut.txt"); // Määritellään tiedostovirtaolio 766 Tämä määrittelee ofstream-olion tultied ja liittää sen C:-levyllä olevassa HarjData-kansiossa olevaan aluvut.txt-tiedostoon. Tämä koodi käyttää MSDOS:n merkintätapaa, joten käytä tarvittaessa laiteympäristösi merkintätapaa. Huomaa, että sinun tulee käyttää kahta kenoviivaa, jotta saat hakemistopolkuun yhden kenoviivan, koska yksi \-merkki aloittaa koodinvaihtomerkin. Tässä olemme käyttäneet tiedoston tarkentimena.txt, koska kirjoitamme tiedostoon tekstimuodossa ja tiedostoa voidaan tarkastella ohjelmalla, joka käsittelee.txt-tiedostoja. Emme ole lisänneet tähän koodiin epäonnistumisten (tai onnistumisten) testausta, mutta käsittelemme niitä hieman myöhemmin. Jos et määrittele hakemistopolkua, tiedoston oletetaan olevan nykyisessä kansiossa. Jos se ei ole siellä jo olemassa, se luodaan sinne. Tässä kohtaa sinun kannattaa sijoittaa kansio jonnekin sopivaan paikkaan, jossa voit vapaasti kokeilla tiedosto-operaatioita. Kun käytät täydellistä nimeä hakemistopolkuineen, voit varmistua, että et tuhoa vahingossa mitään tärkeää. Viimeinen muutos ohjelmaan on muuttaa se kirjoittamaan tiedostoon samaan tapaan kuin alunperin kirjoitimme cout-olioon käyttämällä <<-operaattoria: for(int i = 0 ; i < max ; i++) if(i % 5 == 0) // Rivinvaihto 1. riville ja joka 5. alkuluvun jälkeen tultied << endl; tultied << setw(10) << *(alkuluvut + i);

13 Syöttö- ja tulostusoperaatiot Kun ohjelman suoritus päättyy, löydät aluvut.txt-tiedoston C:\HarjData-kansiosta (tai muusta käyttämästäsi kansiosta). Jos katsot sen sisältöä tekstieditorilla, huomaat, että tiedosto sisältää samat luvut kuin alkuperäinen versio tulosti näytölle. Jos olisimme tarvinneet tiedostoa vain väliaikaisena talletuspaikkana, emmekä olisi halunneet katsoa sisältöä suoraan, olisimme voineet jättää rivinvaihdot tulostamatta. Olisimme silti tarvinneet tyhjät merkit arvojen välissä, jos tarkoituksenamme olisi lukea ne takaisin >>-operaattorilla. Olisimme kuitenkin voineet pienentää sen yhteen välilyöntiin. Tällöin tulostuslauseet näyttäisivät seuraavilta: for(int i = 0 ; i < max ; i++) tultied << << *(alkuluvut + i); Huomaa, että meidän ei tarvitse tehdä mitään sulkeaksemme tiedoston. Kun ostream-olio tuhotaan, siihen liitetty tiedosto suljetaan automaattisesti, joten tiedostomme suljetaan, kun tultied-olion näkyvyysalue päättyy. Jos haluat sulkea tiedoston eksplisiittisesti, voit kutsua olion close()-funktiota. Seuraava lause sulkee tultied-olioomme liitetyn tiedoston: tultied.close(); Minun järjestelmässäni ostream-olio kirjoittaa olemassa olevien tiedostojen yli. Voit varmistaa, toimiiko sinun järjestelmäsi tällä tavalla suorittamalla ohjelman uudelleen erilaisella alkulukujen määrällä ja katsomalla tiedoston sisältöä uudelleen. Sinun ei aina tarvitse kirjoittaa koko tiedostoa uudelleen; se vain on oletuksena. Käsittelemme myöhemmin tässä luvussa, miten voit kontrolloida tiedostoon kirjoittamista. Tiedostosta lukeminen Lukeaksesi tiedostosta, voit luoda ifstream-tyyppisen olion ja liittää sen levyllä olevaan tiedostoon: const char* tiedostonimi = C:\\HarjData\\aluvut.txt ; ifstream syottied(tiedostonimi); Tämä määrittelee syottied-olion ja liittää sen C:-levyllä HarjData-kansiossa olevaan aluvut.txt-tiedostoon ja avaa tiedoston. Jos haluat lukea tiedostosta, sen tulee olla olemassa, mutta niinhän ei aina ole, vaikka niin kuvittelisitkin! Mitä tapahtuu, jos yrität lukea tiedostosta, jota ei ole aikaisemmin muodostettu? Määrittelyn puolesta ei tapahdu mitään: meillä on vain tiedostovirta, joka ei toimi. Varmistaaksemme, että kaikki on niin kuin pitäisi, meidän täytyy testata tiedoston tila. Tämän tekemiseen on monta vaihtoehtoa. Yksi mahdollisuus on kutsua ifstream-olion is_open()- jäsentä, joka palauttaa arvon true, jos tiedosto on auki ja arvon false, jos se ei ole auki. Toinen vaihtoehto on kutsua ios-luokasta perittyä fail()-funktiota, joka palauttaa arvon true, jos tapahtui tiedostovirhe. Vaihtoehtoisesti voit käyttää!-operaattoria tiedostovirran olion kanssa. 767

14 C++ Ohjelmoijan käsikirja Tämä operaattori on uudelleenmääritelty ios-luokassa ja tarkistaa luokalle määritellyt tilatiedot. Kun sitä käytetään virtaolion kanssa, se palauttaa arvon true, jos virta ei ole hyväksyttävässä tilassa. Uudelleenmääritellyn!-operaattorin käyttö on sama kuin fail()-funktion käyttö, joten voimme varmistaa virtaolion hyväksyttävän tilan seuraavasti: if(!syottied) cout << endl << Tiedoston << tiedostonimi << avaus ei onnistu ; return 1; Voit testata tulostustiedoston olemassaolon samaan tapaan, koska ofstream-luokka perii myöskin uudelleenmääritellyn!-operaattorin. Se perii myöskin fail()-funktion ja toteuttaa is_open()- funktion. Käsittelemme virtojen virhetilanteita hieman myöhemmin tässä luvussa. Tiedoston tukeminen tekstimuodossa on kuin tiedon lukemista cin-oliosta - >>-operaattoria käytetään aivan samaan tapaan. Emme kuitenkaan välttämättä tiedä, kuinka monta arvoa tiedostossa on, joten miten tiedämme, että olemme saavuttaneet tiedoston lopun? ofstreamluokka on perinyt basic_ios-luokalta eof()-funktion, joka palauttaa arvon true, kun tiedoston loppu on saavutettu, joten voimme jatkaa lukemista kunnes näin tapahtuu. 768 Kokeile itse - Tiedoston lukeminen Nyt meillä on tarpeeksi tietoa tiedostovirrasta lukemisesta, jotta voimme lukea takaisin edellisessä esimerkissä tiedostoon kirjoittamamme luvut. Luemme tiedostoa ja tulostamme arvot näytölle. Seuraavassa on esimerkin koodi: // Esimerkki 19.2 Alkulukujen tiedoston lukeminen #include <fstream> #include <iostream> #include <iomanip> using namespace std; int main() const char* tiedostonimi = "C:\\HarjData\\aluvut.txt"; // Luettavan tiedoston nimi ifstream syottied(tiedostonimi); // Luo syöttövirran olion // Varmistetaan, että tiedostovirta on ok! if(!syottied) cout << endl << "Tiedoston " << tiedostonimi << " avaus ei onnistu"; return 1; long aluku = 0; int lkm = 0; while(!syottied.eof()) // Jatketaan kunnes EOF syottied >> aluku; // Luetaan arvo tiedostosta cout << (lkm++ % 5 == 0? "\n" : "") << setw(10) << aluku; cout << endl;

15 Syöttö- ja tulostusoperaatiot return 0; Esimerkin tulostus näyttää seuraavalta: Kuinka se toimii Luomme tiedostovirran olion seuraavilla lauseilla: const char* tiedostonimi = "C:\\HarjData\\aluvut.txt"; // Luettavan tiedoston nimi ifstream syottied(tiedostonimi); // Luo syöttövirran olion Ennen kuin käytämme tiedostoa, testaamme, avattiinko se oikein: if(!syottied) cout << endl << "Tiedoston " << tiedostonimi << " avaus ei onnistu"; return 1; Kantaluokasta ios periytetyn olion syottied funktio operator!() palauttaa arvon true, jos muodostinfunktio ei pystynyt luomaan ja avaamaan virtaoliota oikein. Näin tapahtuu esimerkiksi silloin, kun tiedostoa ei ole olemassa. Jos jotain meni väärin, tulostamme virheilmoituksen ja lopetamme ohjelman suorituksen. Kun olemme varmoja, että tiedosto on auki, luemme yksinkertaisesti arvot tiedostosta ja tulostamme ne standardiin tulostusvirtaan cout: long aluku = 0; int lkm = 0; while(!syottied.eof()) // Jatketaan kunnes EOF syottied >> aluku; // Luetaan arvo tiedostosta cout << (lkm++ % 5 == 0? "\n" : "") << setw(10) << aluku; 769

16 C++ Ohjelmoijan käsikirja while-silmukan suoritusta jatketaan kunnes syottied-olion eof()-jäsenfunktio palauttaa arvon true. Silmukassa luemme arvon syottied-virrasta muuttujaan aluku ja tulostamme arvon cout-virtaan. Ehto-operaattori tulostaa rivinvaihdon joka viidennen arvon jälkeen. Kun tiedoston viimeinen arvo on luettu, eof() palauttaa arvon true, koska nykyinen tiedostosijainti on tiedoston lopussa. Tiedoston avaustavan asetus Tiedoston avaustapa ifstream- ja ofstream-olioille kertoo, mitä voit tiedoston kanssa tehdä. Sen määräävät bittimaskin arvot, jotka on määritelty ios_base-luokassa ja peritty iosluokkaan openmode-tyyppisinä arvoina. Mahdolliset maskin arvot ovat: Arvo ios::app ios::ate ios::binary ios::in ios::out ios::trunc Tarkoitus Siirrytään tiedoston loppuun ennen jokaista kirjoitusta (lisäys). Tämä varmistaa, että voit vain lisätä tiedostossa jo olevaan; et voi korvata tiedostossa olevaa. Siirrytään tiedoston loppuun avauksen yhteydessä. Voit siirtää nykyisen sijainnin muualle ohjelmaan. Asetetaan binäärimuoto tekstimuodon sijaan. Binäärimuodossa kaikki merkit siirretään sellaisinaan tiedostoon tai tiedostosta. Avaa tiedoston lukua varten. Avaa tiedoston kirjoitusta varten. Kutistetaan olemassa oleva tiedosto tyhjäksi. Koska nämä ovat maskiarvoja, avaustapa määritellään näiden arvojen yhdistelmillä bittitason OR:n avulla. Tiedostolle, joka avataan binäärimuotoista, vain tiedoston loppuun lisäävää kirjoitusta varten, avaustapa määritellään lausekkeella ios::out ios::app ios::binary. Voit avata tiedoston myös lukua ja kirjoitusta varten kirjoittamalla ios::in ja ios::out; tässä tilanteessa sinun tulee käyttää fstream-tyyppistä oliota, kuten pian huomaamme. Avaustapa määritellään tiedostovirran luokan muodostinfunktion toisena parametrinä. Sekä ifstream- että ofstream-muodostinfunktioilla on openmode-tyyppinen toinen parametri, jolle on määritelty oletusarvo. ifstream-olion oletusarvoinen avaustapa on ios::in, joka avaa tiedoston lukua varten. ofstream-olion oletusarvona on ios::out ios::trunc, joka määrittelee, että tiedosto avataan kirjoitusta varten. Jos tiedosto on jo olemassa, sen pituudeksi asetetaan nolla, jolloin varmistetaan, että olemassa oleva sisältö hävitetään. Oletetaan, että haluat määritellä tiedoston avaustavan sellaiseksi, että voit vain lisätä tietoa tiedostoon. Voit tehdä tämän seuraavilla lauseilla: cont char* tiedostonimi = C:\\HarjData\\aluvut.txt ; ofstream tultied(tiedostonimi, ios::out ios:app); 770

17 Syöttö- ja tulostusoperaatiot Jos suljet tiedostovirran eksplisiittisesti virtaolion close()-funktiolla, voit avata tiedoston uudelleen uudella avaustavalla kutsumalla open()-funktiota. Open()-funktiolla on kaksi parametriä. Ensimmäinen on tiedoston nimi ja toinen on avaustavan maski. Toisen parametrin oletusarvo on sama kuin luokan muodostinfunktiossakin. Voimme sulkea tultied-virran ja avata sen uudelleen eri avaustavalla seuraavilla lauseilla: tultied.close(); tultied.open(tiedostonimi); Tämä avaa tiedoston uudelleen korvaustilaan, koska toisen parametrin oletusarvo on ios::out ios::trunc. Kokeile itse - Avaustavan määrittely Voimme käyttää alkuluku-esimerkkiämme vielä kerran. Nyt muodostamme ja tulostamme haluamasi alkuluvut tiedostoon, jotta niitä voidaan käyttää uudelleen tulevaisuudessa. Tällöin ohjelman tulee muodostaa ainoastaan alkuluvut, jotka eivät vielä ole tiedostossa. Kaikki tiedostossa jo olevat alkuluvut voidaan tulostaa välittömästi. Seuraavassa on esimerkin koodi: // Esimerkki 19.3 Alkulukutiedoston luku ja kirjoitus #include <fstream> #include <iostream> #include <iomanip> #include <cmath> #include <string> using namespace std; long seuraluku(long viimaluku, const char* tiedostonimi); // Etsii viimeistä // seuraavan alkuluvun int main() const char* tiedostonimi = "C:\\HarjData\\aluvut.txt"; int alkm = 0; // Haluttujen alkulukujen lukumäärä int lkm = 0; // Löydettyjen alkulukujen lukumäärä long viimaluku = 0; // Viimeisin löydetty alkuluku // Luetaan haluttu alkulukujen lukumäärä int yritykset = 0; // Yritysten lukumäärä cout << "Montako alkulukua haluat (vähintään 3)?: "; do if(yritykset) cout << endl << " Vähintään 3, yritä uudelleen: "; cin >> alkm; if(++yritykset == 5) // Viisi yritystä riittää cout << endl << " Luovutan!" << endl; return 1; while(alkm < 3); 771

18 C++ Ohjelmoijan käsikirja ifstream syottied; syottied.open(tiedostonimi); // Luodaan syöttötiedostovirta // Avataan tiedosto syöttövirraksi cout << endl; if(!syottied.fail()) do syottied >> viimaluku; cout << (lkm++ % 5 == 0? "\n" : "") << setw(10) << viimaluku; while(lkm < alkm &&!syottied.eof()); syottied.close(); syottied.clear(); // Tyhjennetään virheet try ofstream tultied; if(lkm == 0) tultied.open(tiedostonimi); // Avataan tiedosto luomista varten if(!tultied.is_open()) throw ios::failure(string("syöttötiedoston ") + string(tiedostonimi) + string(" avauksessa virhe main()-funktiossa")); tultied << " 2 3 5"; tultied.close(); cout << setw(10) << 2 << setw(10) << 3 << setw(10) << 5; viimaluku = 5; lkm = 3; while(lkm < alkm) viimaluku = seuraluku(viimaluku, tiedostonimi); tultied.open(tiedostonimi, ios::out ios::app); // Avataan tiedosto // tiedon lisäystä varten if(!tultied.is_open()) throw ios::failure(string("tulostustiedoston ") + string(tiedostonimi) + string(" avauksessa virhe main()-funktiossa")); tultied << " " << viimaluku; tultied.close(); cout << (lkm++ % 5 == 0? "\n" : "") << setw(10) << viimaluku; cout << endl; return 0; catch(exception& ex) cout << endl << typeid(ex).name() << ": " << ex.what(); return 1; 772

19 Syöttö- ja tulostusoperaatiot Tämä käyttää seuraluku()-funktiota, joka palauttaa ensimmäistä parametriä seuraavan alkuluvun. Toinen parametri on tiedoston nimi, joka sisältää tähän saakka löydetyt alkuluvut. Funktion määrittely on seuraava: // Etsitään parametriä seuraava alkuluku long seuraluku(long viimaluku, const char* tiedostonimi) bool onaluku = false; // Onkom meillä alkuluku? long aluku = 0; // Tallettaa tiedostosta luetun alkuluvun ifstream syottied; // paikallinen syöttövirran olio // Etsitään seuraava alkuluku for( ; ; ) viimaluku += 2; // Seuraava tarkistettava luku long raja = static_cast<long>(sqrt(viimaluku)); // Kokeillaan jakaa ehdokas kaikilla alkuluvuilla rajaan saakka do syottied >> aluku; while(aluku <= raja &&!syottied.eof() && (onaluku = viimaluku % aluku > 0)); syottied.close(); if(onaluku) return viimaluku; // Olemme löytäneet... //...ja palautetaan alkuluku Tämä ohjelma tulostaa pyytämäsi alkuluvut ja kirjoittaa ne tiedostoon aluvut.txt. Kuinka se toimii Ohjelman rakenne on nyt hieman erilainen. Koska säilytämme kaikkia alkulukuja tiedostossa, meidän ei enää tarvitse säilyttää niitä muistissa. Alkuluvut etsitään nyt seuraluku()-funktiolla, mutta ennen kuin tutkimme sitä, katsotaan, miten main()-funktion koodi toimii. Kun olemme lukeneet käyttäjältä haluttujen alkulukujen lukumäärän, avaamme aluvut.txttiedoston syöttövirraksi seuraavilla lauseilla: ifstream syottied; syottied.open(tiedostonimi); // Luodaan syöttötiedostovirta // Avataan tiedosto syöttövirraksi 773

20 C++ Ohjelmoijan käsikirja 774 ifstream-tyyppinen olio syottied luodaan oletusmuodostinfunktiolla. Oliota ei liitetä mihinkään tiedostoon tässä vaiheessa. Liitämme virtaolion aluvut.txt-tiedostoon kutsumalla open()-funktiota, jonka ensimmäisenä parametrinä on tiedoston nimi. Funktiolle voidaan välittää myös toinen parametri - avaustapa - mutta koska emme määrittele sitä, oletusarvoa ios::in käytetään. Voihan olla niin, että tiedostoa ei ole vielä olemassa, joten meidän tulee varmistaa, että tiedostovirta on hyväksyttävässä tilassa ennen kuin yritämme lukea siitä. Testaamme tiedostovirran olion fail()-funktion avulla: if(!syottied.fail()) do syottied >> viimaluku; cout << (lkm++ % 5 == 0? "\n" : "") << setw(10) << viimaluku; while(lkm < alkm &&!syottied.eof()); syottied.close(); Luemme tiedostoa ainoastaan silloin, jos fail() palauttaa arvon false. if-lohkossa luemme dowhile-silmukassa alkm-lukua. Tarkistamme tiedoston loppumisen silmukan ehtolausekkeessa kutsumalla syottied-olion eof()-funktiota. Palautetun bool-arvon vastaluku ja arvojen lkm ja alkm vertailu määrää, jatkuuko silmukan suoritus. Eli silmukan suoritus päättyy, kun olemme lukeneet tarvittavan määrän alkulukuja, tai kun tiedoston loppu on saavutettu. if-lauseen suorituksen jälkeen tiedostovirran olio on mahdollisesti virhetilassa - joko siksi, että tiedostoa ei ole olemassa, tai kun tiedoston loppu on saavutettu. Niitä ei palauteta sulkiessasi tiedoston, joten jos haluamme käyttää oliota uudelleen, meidän tulee palauttaa virheliput kutsumalla virtaolion clear()-funktiota: syottied.clear(); // Tyhjennetään virheet Käsittelemme clear()-funktion muita käyttötarkoituksia hieman myöhemmin tässä luvussa. Loput main()-funktion koodista on try-lohkossa, koska muodostamme poikkeuksia, jos tiedoston avauksessa ilmenee ongelmia. catch-lohko käsittelee kaikki poikkeukset, joiden kantaluokkana on exception. Näin voimme käsitellä samantyyppiset virheet samassa paikassa. Tässä kohtaa voimme käyttää lkm-muuttujan arvoa kertomaan, luettiinko tiedostosta alkulukuja. Jos ei luettu, voimme muodostaa tiedoston ja kirjoittaa sinne kolme ensimmäistä alkulukua. Tämä tehdään seuraavalla koodilla: ofstream tultied; if(lkm == 0) tultied.open(tiedostonimi); // Avataan tiedosto luomista varten if(!tultied.is_open()) throw ios::failure(string("syöttötiedoston ") + string(tiedostonimi) + string(" avauksessa virhe main()-funktiossa")); tultied << " 2 3 5"; tultied.close(); cout << setw(10) << 2 << setw(10) << 3 << setw(10) << 5; viimaluku = 5; lkm = 3;

21 Syöttö- ja tulostusoperaatiot Luomme tulostustiedostovirtaolion tultied ja kutsumme sen open()-funktiota avaamaan aluvut.txt-tiedoston. Tämä avaa tiedoston avaustavalla ios::out ios::trunc, joten kaikki tiedostossa ollut tieto tyhjennetään ja kirjoitamme tiedostoon alusta lähtien. Kutsumme if-lauseessa tultied-olion is_open()-funktiota varmistaaksemme, että tiedosto on auki ja valmiina kirjoitettavaksi. Jos mikään ei mennyt pieleen, kirjoitamme kolme ensimmäistä alkulukua tiedostoon ja suljemme sen. Tämän jälkeen tulostamme samat kolme alkulukua coutvirtaan ja asetamme viimaluku- ja lkm-muuttujien arvot. Jos emme jostain syystä saa tiedostoa auki kirjoitusta varten, muodostamme ios::failure-tyyppisen poikkeuksen. Tämä poikkeus on alunperin määritelty ios_base-luokassa ja näin ollen on peritty ios-luokkaan ja kaikkiin virtaluokkiin. Koska kyseessä on standardipoikkeus, sen kantaluokkana on exception-luokka. Muodostinfunktiolle voidan välittää string-tyyppinen parametri ja kaikki se, mitä muodostinfunktiolle välität, tulostetaan olion what()-jäsenfunktiolla, joten voit käyttää sitä kertomaan poikkeuksesta catch-lohkossa. Tässä kohtaa meidän saattaa olla tarpeen etsiä lisää alkulukuja. Näin on, jos tiedoston alkulukujen lukumäärä on pienempi kuin pyydettyjen alkulukujen lukumäärä. Tämä huomioidaan while-silmukassa, jonka suoritusta jatketaan kunnes lkm on yhtä suuri kuin alkm: while(lkm < alkm) viimaluku = seuraluku(viimaluku, tiedostonimi); tultied.open(tiedostonimi, ios::out ios::app); // Avataan tiedosto // tiedon lisäystä varten if(!tultied.is_open()) throw ios::failure(string("tulostustiedoston ") + string(tiedostonimi) + string(" avauksessa virhe main()-funktiossa")); tultied << " " << viimaluku; tultied.close(); cout << (lkm++ % 5 == 0? "\n" : "") << setw(10) << viimaluku; Funktio seuraluku() laskee ensimmäistä parametriään seuraavan alkuluvun. Toinen parametri määrittelee tiedostonimen, josta jo olemassa olevia alkulukuja etsittiin. Tämän jälkeen tiedosto avataan kirjoitusta varten, mutta tällä kertaa avaustapa on sellainen, että jos kirjoitamme tiedostoon, kirjoitamme aina tiedoston loppuun. Jos tiedoston avauksessa on ongelmia, muodostamme jälleen poikkeuksen. Kun olemme kirjoittaneet seuraluku()-funktion palauttaman alkuluvun, suljemme tiedoston. Tämä on tarpeen, koska silmukan seuraavalla kierroksella seuraluku()-funktion tulee avata tiedosto uudelleen. Jokaisella silmukan kierroksella, löydetty alkuluku tulostetaan myös coutvirtaan. Silmukan suoritusta jatketaan, kunnes alkm alkulukua on tulostettu. Silmukan suorituksen jälkeen tiedosto sisältää vähintään yhtä monta alkulukua kuin siinä oli aikaisemminkin, koska uudet alkuluvut lisätään siihen. Uuden alkuluvun etsimiseen seuraluku()-funktiossa kuuluu tiedostossa olevien alkulukujen käyttäminen jakajina, joten funktiossa luodaan paikallinen ifstream-olio. Seuraava alkuluku etsitään päättymättömässä for-silmukassa. Ensimmäinen tarkastettava arvo on viimaluku lisättynä kahdella: viimaluku += 2; // Seuraava tarkistettava luku 775

22 C++ Ohjelmoijan käsikirja Funktiolle välitetty viimaluku on viimeinen löydetty alkuluku, joten meidän ei tarvitse tarkistaa, että se on pariton. Tarkistamme, onko arvo alkuluku siten, että yritämme jakaa sen kaikilla sen neliöjuurta pienemmillä alkuluvuilla. Laskemme tämän kokonaislukurajan lauseella: long raja = static_cast<long>(sqrt(viimaluku)); Tässä käytetään standardikirjaston sqrt()-funktiota, joka on esitelty cmath-otsikkotiedostossa. Parametrin arvo muunnetaan automaattisesti double-tyyppiseksi ja muunnamme eksplisiittisesti sqrt()-funktion tuloksen double-tyyppiseksi. Seuraavilla lauseilla avaamme tiedostovirran ja tarkistamme, että avaus onnistui: ifstream syottied(tiedostonimi); // paikallinen syöttövirran olio if(!syottied.is_open()) throw ios::failure(string("syöttötiedoston ") + string(tiedostonimi) + string(" avauksessa virhe seuraluku()-funktiossa")); Jos tiedoston avaus epäonnistuu, muodostamme saman tyyppisen poikkeuksen kuin muodostimme main()-funktiossa. Tässä meillä on hieman erilainen muodostinfunktion parametrin arvo, jotta näemme, missä kohtaa ohjelmaa ongelma esiintyi. Poikkeuksen käsittelee main()-funktion catch-lohko, eli kaikki ongelmatilanteet käsitellään samassa paikassa. Syöttötiedostovirran avaamisen jälkeen alkulukukandidaatti tarkistetaan do-while-silmukassa: do syottied >> aluku; while(aluku <= raja &&!syottied.eof() && (onaluku = viimaluku % aluku > 0)); Alkuluku luetaan tiedostosta silmukassa, mutta kaikki muu tehdään silmukan ehtolausekkeessa. Siinä on AND:lla yhdistettynä kolme loogista lauseketta, eli jos yksikin niistä on false, silmukan suoritus päättyy. Ensimmäinen ehto on se, että jakaja on pienempi kuin raja, eli pienempi kuin kandidaatin neliöjuuri. Jos se ei ole, olemme testanneet kaikki jakajat rajaan asti, emmekä ole löytäneet jakajaa, joka jakaisi kandidaatin tasan. Toinen ehto on se, että emme ole saavuttaneet tiedoston loppua ja näin ei tulisi koskaan käydä. Jos näin käy, ohjelmassa tai tiedostossa on jossain vakava vika. Kolmas ehto tarkistaa jakojäännöksen jakolaskun jälkeen. Jos jakojäännös on nolla, olemme löytäneet luvun, joka jakaa kandidaatin tasan, joten viimaluku ei ole alkuluku ja meidän tulee yrittää uutta kandidaattia. Kun silmukan suoritus loppuu, suljemme tiedoston, jotta voimme avata sen uudelleen: syottied.close(); //...joten suljetaan tiedosto... Sen, olemmeko löytäneet alkuluvun, kertoo onaluku, joka asetetaan silmukan ehtolausekkeessa. Jos se on true, meillä on alkuluku ja voimme palauttaa sen arvon. Jos kyseessä ei ole alkuluku, siirrymme seuraavalle for-silmukan kierrokselle. 776 if(onaluku) return viimaluku; // Olemme löytäneet... //...ja palautetaan alkuluku