1. C++ -pääohjelma. Olio-ohjelmointi Johdanto ohjelmointiin C++-kielellä

Transkriptio

1 Olio-ohjelmointi Johdanto ohjelmointiin C++-kielellä Tässä osassa tutustutaan C++ - ohjelmoinnin perusrakenteisiin ja siihen, kuinka käyttäjän kanssa kommunikoidaan käyttäen hyväksi konsoli-ikkunaa. Teksti perustuu pääasiallisesti opetusmonisteen [CppTut] ensimmäiseen lukuun. Lukijan oletetaan tuntevan C-kielen siinä määrin kuin se esitetään kurssilla Johdatus ohjelmointiin. C++ perustuu syntaksiltaan C- ohjelmointikieleen: Lähes mikä tahansa C-ohjelma on myös C++-ohjelma. Tällä kurssilla pyritään kuitenkin ohjelmoimaan C++:n luonteen mukaisesti, jolloin monien C-kielestä tuttujen toimintatapojen tilalle tulee uusia menetelmiä. 1. C++ -pääohjelma Ohjelman suoritus alkaa aina pääohjelmasta, joka on sekä C- että C++ - ohjelmissa nimeltään main. Pääohjelma on tavallinen C++ -ohjelman funktio, jota käyttöjärjestelmä kutsuu automaattisesti. Vaikka pääohjelma onkin normaali funktio, sitä erottavat tavallisista funktioista seuraavat seikat: 1. Sitä ei voi kutsua erikseen. 2. Sen osoitetta ei voi tallentaa osoitinmuuttujaan. 3. Sitä ei tarvitse esitellä ennen määritystä. 4. Sitä voi olla vain yksi kappale ohjelmassa. C++ -standardin mukaan pääohjelma voi olla kahta muotoa: (1a) (1b) int main(void) (2a) int main(int argc, char **argv) (2b) int main(int argc, char *[]argv) (2c) int main(int argc, char [][]argv) Näistä kaksi ensimmäistä ovat ns. parametrittomia ja kolme viimeistä ns. parametrillisia muotoja pääohjelmasta. Kaksi ensimmäistä muotoa ovat vaihtoehtoisia keskenään ja kolme viimeistä ovat vaihtoehtoisia keskenään. Yleensä C++ -ohjelmissa käytetään muotoa 1a silloin, kun ei tarvita käynnistysparametreja, ja muotoa 2a, kun tarvitaan syöttöparametreja. C++ -pääohjelman paluuarvon tyyppi on aina int. C++ -standardi ei määrittele paluuarvolle merkitystä; siinä ainoastaan luvataan arvon nolla merkitsevän, että ohjelman suoritus on loppunut onnistuneesti. Muut arvot ilmaisevat jonkinlaista virhetilannetta, jonka käyttöjärjestelmä tulkitsee. Paluuarvoa käytetään lähinnä ohjelmissa, jotka on tarkoitettu putkitettavaksi käyttöjärjestelmätasolla siten, että edellisen ohjelman tulostetieto on seuraavan ohjelman syöttötieto. Käyttöjärjestelmä päättää paluuarvon perusteella jatketaanko putken suorittamista vai keskeytetäänkö se. C++ -standardissa on määritelty kaksi symbolista vakiota, joita voi käyttää paluuarvoina. Nämä vakiot on määritelty otsikkotiedostossa <cstdlib>: 1. EXIT_FAILURE tarkoittaa, että ohjelman suoritus on tavalla tai toisella epäonnistunut ja 2. EXIT_SUCCESS tarkoittaa, että ohjelman suoritus on onnistunut. C++ -ohjelmalle voidaan välittää ohjelmaan käynnistämisen yhteydessä parametreja, kun käytetään aiemmin mainittua toista pääohjelman muotoa. Käyttöjärjestelmä välittää parametrit 1

2 C-tyyppisinä merkkijonoina, ts. merkkitaulukkoina, joiden viimeisenä merkkinä on nollamerkki. Ensimmäinen parametri ilmoittaa, kuinka monta parametria ohjelmalle välitettiin. Tämä arvo on aina suurempi kuin nolla, koska käyttöjärjestelmä välittää tavallisesti ohjelman nimen ensimmäisenä parametrina. Ellei ohjelman nimeä välitetä, parametritaulukon ensimmäisenä alkiona on tyhjä merkkijono ( ). Oletetaan, että ohjelma nimeltä echo on käynnistetty seuraavasti: echo hello Tällöin parametrien arvot ovat: argc muuttujan arvo on 2. Ensimmäisessä argv taulukon alkiossa (argv[0]) on osoitin merkkijonoon echo. Toisessa argv taulukon alkiossa (argv[1]) on osoitin merkkijonoon hello. Luonnollisesti parametrien nimet voivat olla mitä tahansa, mutta niiden tyyppien pitää olla em. eli int ja char** (tai char*[] tai char[][]). Yleisesti kuitenkin käytetään nimiä argc (eli argument count) ja argv (eli argument values). 2. Lukeminen ja tulostaminen C++-kielessä tulostamiseen käytetään operaattoria <<, jota kutsutaankin nykyään pääsääntöisesti tulostusoperaattoriksi. (Operaattorin toinen merkitys on kokonaislukujen bittien siirtäminen vasemmalle). Operaattori on määritelty standardikirjastossa jokaiselle C++ -kielen sisäiselle tyypille. Kirjaston yksi suunnitteluperiaate on se, että ohjelmoijan omien tyyppien tulostaminen ei eroa kielen sisäisten tyyppien tulostamisesta. Ohjelmoija voi siten määritellä tulostusoperaattorin omille tyypeilleen haluamallaan tavalla. Tähän asiaan tutustutaan kurssilla käsiteltäessä ylikuormittamista. C++ - standardikirjastossa on määritelty cout -niminen oliomuuttuja, joka huolehtii tulostamisesta konsoli-ikkunaan. Seuraava esimerkkiohjelma tulostaa tekstin Terve maailma! ja rivivaihdon. std::cout << Terve maailma! << std::endl; Huomioidaan ohjelmasta seuraavaa: Lähdekoodiin liitetään #include-direktiiveillä standardikirjaston otsikkotiedostoja, joissa esitettyjä tyyppejä ja funktioita ohjelmassa tarvitaan. Esimerkkiohjelmassa tällaisia ovat cout-oliomuuttujan ja operaattorin << esittelyt. Tulostettava teksti on ohjelmassa esitetty merkkijonovakiona. Tällaisesta ohjelmakoodissa esiintyvästä vakiosta käytetään myös nimitystä literaali. Literaali voi olla muunkin tyyppinen vakio kuin merkkijono. Merkintä std:: entiteettien cout ja endl edessä tarkoittaa sitä, että nämä entiteetit on määritelty standardikirjaston nimiavaruudessa std. Nimiavaruuksien avulla voidaan välttää samannimisten entiteettien esiintymiset ohjelmassa. Tällä kurssilla käytetään ainoastaan standardinimiavaruutta 2

3 std. Merkinnän käyttäminen voidaan tehdä tarpeettomaksi esimerkiksi käyttämällä usingdirektiiviä (using directive), jonka avulla nimiavaruudesta tuodaan kaikki entiteetit. Esimerkkiohjelma voidaan täten kirjoittaa myös muodossa: cout << Terve maailma! << endl; Voidaan myös käyttää using-esittelyä (using declaration), jolloin valitaan, mitkä entiteetit halutaan tuoda valitusta nimiavaruudesta. Esimerkkiohjelmasta tulisi tällöin: using std::cout; using std::endl; cout << Terve maailma! << endl; Siirrettävyyden ja ylläpidettävyyden vuoksi using-lauseiden näkyvyys tulisi rajata mahdollisimman suppeaksi. Yleensä ne tulisi sijoittaa funktioiden toteutuksiin. Edellisissä esimerkeissä ne on kirjoitettu main-funktioon. Esimerkkiohjelmasta huomataan myös, että tulostettavia arvoja voidaan ketjuttaa yhteen tulostuslauseeseen lisäämällä tulostettavien arvojen väliin operaattori <<. Tulostuksen muotoilu: minimileveys, täytemerkki ja tasaus C++-ohjelmassa voidaan tulostuksen muotoa muuttaa. C++:ssa tulostus on osittain kenttäpohjaista, toisin sanoen tulostettavalle arvolle voidaan määritellä kentän pituus. Tämä pituus on ainoastaan minimipituus: jos tulostettava arvo vie enemmän tilaa kuin kentän nykyinen leveys, kentän leveyttä kasvatetaan. Lisäksi kentän minimipituus asetetaan jokaisen arvon tulostamisen jälkeen nollaksi, mikä tarkoittaa sitä että jokaisen tulostettavan arvon kohdalla pitää, ohjelmoijan niin halutessa, määritellä kentän minimileveys. Kentän leveys voidaan määritellä ns. manipulaattorin avulla, joka asettaa tulostusvirran muotoilulippuun tietyn arvon. Standardimanipulaattorit on esitelty kahdessa otsikkotiedostossa: Otsikkotiedostossa <iostream> on esitelty ne manipulaattorit, jotka eivät ota parametreja, kuten endl. Otsikkotiedostossa <iomanip> on esitelty ne manipulaattorit, joilla on parametri, kuten minimileveyden asettamiseen käytettävä setw. Seuraavassa ohjelmassa käytetään manipulaattoreita setw, setfill, left ja right muotoilemaan tulostusta: 3

4 #include <iomanip> cout << C++ << << C++ << endl; cout << setw(5) << C++ << << C++ << endl; cout << setw(5) << setfill( * ) << C++ << << C++ << endl; cout << C++ << << C++ << endl; cout << setw(5) << setfill( * ) << left << C++ << << C++ << endl; cout << setw(5) << setfill( * ) << right << C++ << << setw(5) << C++ << endl; Ohjelma tulostaa samat kuusi riviä eri tavoin muotoiltuna seuraavasti: C++ C++ C++ C++ **C++ C++ C++ C++ C++** C++ **C++ **C++ Tulostuksesta ja koodista huomataan: 1. Oletusleveys on nolla merkkiä, joten tulostuskentät laajenevat automaattisesti. 2. Oletustasaus tehdään tulostuskentän oikeaan reunaan. 3. Asetettu tietokentän leveys nollataan jokaisen arvon tulostamisen jälkeen. 4. Täytemerkki ja tasaus säilyvät asettamisen jälkeen. Yhden sanan lukeminen ja lukuoperaattori Konsoli-ikkunasta lukeminen tapahtuu C++:n IOStream-kirjaston välityksellä, kuten konsoliikkunaan tulostaminenkin. Tässäkään tapauksessa ohjelmoijan omien tyyppien lukemisen ei tulisi erota C++ - kielen sisäisten tyyppien lukemisesta. Tätä varten on ylikuormitettu operaattori >>, joka tarkoittaa myös kokonaisluvun bittien siirtoa oikealle. Tätä operaattoria kutsutaankin nykyään pääsääntöisesti lukuoperaattoriksi. IOStream-kirjastossa on määritelty lukuoperaattorit kielen sisäisille tyypeille. Ko. kirjastossa on määritelty olio cin, jonka välityksellä konsolinäppäimistöltä syötettyjä tietoja luetaan. Lukuoperaattori lukee luettavan tiedon tyypin perusteella niin monta merkkiä kuin tyypin merkkiavaruuteen kuuluu, minkä jälkeen lukeminen loppuu ja merkit muutetaan ko. tyypin arvoksi. Lukeminen on oletusarvoisesti puskuroitua. Luettaessa poistetaan ensimmäiseksi alussa olevat valkomerkit (white space characters), joita ovat mm. rivinvaihto-, tabulaattori- ja välilyöntimerkit. Jäljellä olevat merkit jäävät seuraavan lukuoperaation luettavaksi. Lukeminen tapahtuu siis tietokentittäin. Jos lukemisen yhteydessä ei tallenneta yhtään merkkiä merkkijonoon, asetetaan virhelippu. Tilannetta käsitellään lyhyesti tuonnempana. Luettaessa merkkijonotyyppistä tietoa luettavien merkkien määrä voidaan rajata asettamalla tietokentän leveys samalla tavalla kuin tulostettaessa. Jos luettavien merkkien lukumäärää ei ole 4

5 asetettu, lopetetaan lukeminen ensimmäiseen valkomerkkiin, joka jää seuraavan lukutoimenpiteen käsiteltäväksi. Luettavien merkkien lukumäärä pitää aina asettaa kun luetaan merkkitaulukkoon tietoa, jotta lukuoperaatio ei kohdistuisi taulukon ulkopuolelle. Tarkastellaan seuraavaa ohjelmaa: #include <iomanip> const int TAULUKON_KOKO = 12; char hetu[taulukon_koko]; cout << Anna HETU: ; cin >> setw(taulukon_koko) >> hetu; cout << Syötit seuraavan HETU:n << hetu << endl; Jos esimerkissä ei olisi asetettu tietokentän leveyttä ja käyttäjä olisikin syöttänyt viisitoista merkkiä, niin kolme viimeistä merkkiä ja merkkijonon loppumisen ilmoittava nollamerkki olisi kirjoitettu taulukon ulkopuolelle, mahdollisesti jopa ohjelmakoodin päälle. Tätä tilannetta nimitetään puskurin ylivuodoksi (buffer overflow), joka on yksi yleisimmistä virusten ja muiden haittaohjelmien käyttämistä tietoturva-aukoista. Kun käytetään C++-standardikirjastossa määriteltyä merkkijonoluokkaa string, ei tarvitse välittää merkkijonon maksimipituudesta, jolloin edellä oleva esimerkki voidaan kirjoittaa muodossa: #include <string> cout << Anna HETU: ; string hetu; cin >> hetu; cout << Syötit seuraavan HETU:n << hetu << endl; C++:n merkkijonotyyppi varaa tarvittaessa automaattisesti lisää tilaa, kunnes merkkijonon maksimipituus täyttyy; tämä on yleensä sidoksissa int-tyypin kokoon, jolloin 32-bittissä järjestelmissä tämä maksimikoko on 2^32 1 eli merkkiä, ts. noin 4 gigatavua (olettaen että laitteistossa on niin paljon vapaata muistitilaa). Tämän vuoksi C++-ohjelmissa ei juurikaan käytetä C-tyyppisiä merkkijonoja eli merkkitaulukkoja; tämä karsii koodista yhden 5

6 mahdollisen virhepaikan. Haluttaessa voidaan luettavien merkkien lukumäärää rajoittaa myös string-oliota käytettäessä asettamalla tietokentän leveys manipulaattorin setw avulla. Syöttö- ja tulostusvirroilla (cin ja cout) on kolmesta lipusta (eli yksittäisestä bitistä) koostuva tila, joka kertoo, onko virta toimintakykyinen. Nämä bitit ovat eofbit, badbit ja failbit. Kun muuttujaa luettaessa ajaudutaan virhetilanteeseen, muuttujan sisältö on määrittelemätön ja cin-olion jokin virhelippu on asetettu. Tilaa voidaan lukea käyttämällä seuraavia metodeita, jotka kaikki palauttavat bool-tyyppisen arvon: Metodi good() fail() bad() eof() Selitys Palauttaa arvon true, jos kaikki on OK. Palauttaa arvon true, jos on tapahtunut lukuvirhe Palauttaa arvon true, jos virta on käyttökelvoton. Palauttaa arvon true, jos tiedoston loppumerkki on luettu. Lukemisen yhteydessä riittää usein tarkastella tietovuon virhetilaa good()-metodin avulla: #include <string> while (cin.good()) // Kutsutaan cin-olion metodia good() string sana; cout << Syötä tietoa: ; cin >> sana; cout << sana << endl; Edellä oleva ohjelma lukee näppäimistöä, kunnes tapahtuu virhetilanne. Näppäimistöä käytettäessä ainoa virhetilanne on se, että yritetään lukea ohi tiedoston loppumerkin, joka saadaan aikaan Windows/DOS-ympäristössä painamalla yhtä aikaa ctrl ja Z ja Unix/Linuxympäristöissä painamalla yhtä aikaa ctrl ja D. Jos virheellisessä tilanteessa yritetään lukea lisää tietoa, ei lukutoiminto johda mihinkään vaan se epäonnistuu automaattisesti. Täten ennen jokaista lukutoimenpidettä tulisi tarkistaa ja korjata virhetilanne poistamalla virhelippu kutsumalla tietovuon metodia clear. 6

7 Numeerisen arvon lukeminen, tulostaminen ja tulostamisen muotoilu Numeerisen arvon lukemiseen pätevät samat periaatteet kuin yhden sanan lukemiseen, paitsi että asetettua tietokentän leveyttä ei huomioida eikä sitä nollata. Seuraavissa esimerkeissä oletetaan että luettava tieto on kokonaislukutyyppi int. Syöte Luettu arvo % Määrittelemätön Taulukon toisessa tilanteessa lukutoiminto onnistuu, mutta tätä seuraava numeerisen tiedon lukuyritys epäonnistuu, koska % - merkki ei ole minkään numeron osa, muuten se olisikin luettu jo ensimmäisellä kerralla. Neljännessä tilanteessa lukeminen loppuu pistemerkkiin, koska se ei osa merkistöä, joita käytetään kokonaislukujen yhteydessä. Viimeisessä tilanteessa tapahtuu ylivuoto, koska syötettä ei voida esittää tyypin int avulla. Tällöin asetetaan cin-olion virhetilalippu. Kokonaislukujen tulkintaa voidaan ohjata myös kolmella manipulaattorilla: hex, jolloin lukujen kantalukuna on 16 ja käytettävä merkistö on abcdefABCDEFxX oct, jolloin lukujen kantalukuna on 8 ja käytettävä merkistö on dec, jolloin lukujen kantalukuna on 10 ja käytettävä merkistö on Jotta heksadesimaalimuodossa olevissa luvuissa voitaisiin käyttää x-kirjainta, sen edellä pitää olla numero 0. Esimerkiksi 0x12 hyväksytään, mutta muotoa x12 ei hyväksytä. Yhdistelmä 0x saa esiintyä vain kerran. Jos syötetty luku ei ala 0x, se tulkitaan alkavan sillä eli syöte 12 tulkitaan syötteeksi 0x12. Oktaalilukujen alussa olevat numerot 0 tulkitaan yhdeksi nollaksi. Esimerkiksi tulkitaan sen olevan 012. Jos syötetty luku ei ala numerolla 0, sen tulkitaan olevan kuitenkin alussa eli syöte 12 tulkitaan syötteeksi 012. Kun luetaan reaalilukua, sallitut merkit ovat eE. Piste ja e-merkit voivat esiintyä peräkkäin. Mikäli luvussa esiintyy E tai e-kirjain, luvussa täytyy esiintyä jokin numero sekä ennen että jälkeen kirjaimen. Kirjainta seuraavan numeron edessä voi olla myös etumerkki. Seuraavassa on esimerkkejä hyväksytyistä reaaliluvuista: e5 1.e e

8 Seuraavassa ohjelmassa kysytään käyttäjältä reaalilukuna lämpötila Celsius-asteina ja ohjelma tulostaa lämpötilan Fahrenheit-asteikolla. double celsius; cout << Anna lämpötila celsius-asteina: ; cin >> celsius; if (!cin.good()) cout << Luku ei kelpaa << endl; cin.clear(); else double farenheit = 1.8 * celsius + 32; cout << celsius << Celsius-astetta on Fahrenheit-asteikolla << farenheit << endl; Ohjelma havaitsee virheellisen syötteen, mutta ei pyydä uutta arvoa. Tällaisen rakenteen toteuttamiseksi tulisi syöttövirrasta poistaa edellinen virheellinen syöte, kuten myöhemmin näytetään. Numeeriset arvot tulostetaan täsmälleen samoin kuin merkkijonot eli käyttämällä tulostusoperaattoria, kuten edellä olevassa esimerkissä näytettiin. Kun ohjelmassa käytetään reaalilukuja, niin usein halutaan muotoilla lukujen tulostusta esimerkiksi rajoittamalla tulostettavien desimaalien määrää. Lukujen muotoilua varten otsikkotiedostoissa <ios> ja <iomanip> on määritelty mm. seuraavat manipulaattorit: Manipulaattori Tarkoitus showpos Positiivisten lukujen yhteyteen tulostetaan + merkki noshowpos Positiivisten lukujen yhteydessä ei tulosteta merkkiä (oletus) left Tasataan luku vasempaan reunaan tulostuskenttää right Tasataan luku oikeaan reunaan tulostuskenttää (oletus) setw(leveys) Asetetaan tulostuskentän minimileveys (oletuksena 0) fixed Käytetään reaalilukujen yhteydessä desimaalimuotoa scientific Käytetään reaalilukujen yhteydessä tieteellistä muotoa (E) setprecision(luku) Reaaliluvun merkitsevien numeroiden lukumäärä showpoint Tulostetaan aina reaalilukujen yhteydessä desimaalipiste Muut manipulaattorit löytää esimerkiksi Cppreference-sivustolta osoitteesta 8

9 Seuraavassa taulukossa on esimerkkejä reaaliluvun muotoilulippujen vaikutuksesta: setprecision() normaali e showpoint e fixed scientific e e e e-02 Ainoastaan tulostuskentän leveys nollataan jokaisen luvun yhteydessä, muut muotoilulippujen asetukset säilyvät ensimmäisen asetuksen jälkeen. Yhden rivin lukeminen Edellä esitetyt lukutoimenpiteet olivat kaikki ns. muotoiltuja lukutoimenpiteitä, joissa lukemiseen vaikuttavat muotoiluliput kuten esimerkiksi tietokentän leveys. Muotoiltujen lukutoimintojen lisäksi IOStream-kirjasto määrittelee metodeja ja funktioita, joiden avulla voidaan lukea merkkityyppistä tietoa raakadatana, ilman että siihen kohdistetaan mitään muotoilutoimenpiteitä. Käytetyin muotoilemattoman lukemisen funktion on luokalle string määritelty funktio getline, jonka prototyyppi on seuraava: std::istream& getline(std::istream& is, std::string& str, char delim = \n ); Funktio palauttaa ensimmäisen parametrin. Kolmas parametri voidaan jättää pois, jolloin lopettamismerkkinä on rivinvaihtomerkki ( \n ). Funktio toimii seuraavasti: 1. Tyhjennetään parametrina annettu merkkijono. 2. Luetaan silmukassa annetusta vuosta merkkejä ja lisätään ne merkkijonoon, kunnes tapahtuu jokin seuraavista: a. Luetaan tiedoston loppumerkki, jolloin eof-metodi palauttaa arvon true, b. Luettu merkki oli annettu lopetusmerkki (delim), joka poistetaan vuosta mutta ei lisätä merkkijonoon, tai c. Merkkijonon maksimipituus on saavutettu, jolloin fail-metodi palauttaa arvon true. Jos yhtään merkkiä ei luettu, asetetaan lippu fail, jolloin tietovuon metodi fail() palauttaa arvon true. Funktiota käytetään seuraavasti: 9

10 #include <string> cout << Anna etunimesi välilyönnillä erotettuna: ; string etunimet; getline(cin, etunimet); Kun toteutetaan konsolipohjaista käyttöliittymää getline-funktiota käyttämällä, niin ennen funktion kutsua pitää poistaa lukuoperaattorin mahdollisesti jäljelle jättämä rivinvaihtomerkki. Tämä tapahtuu kutsumalla istream-luokan metodia ignore, jolla on seuraavat muodot: std::istream& ignore(); std::istream& ignore(int lkm); std::istream& ignore(int lkm, int delim); Näistä ensimmäinen poistaa yhden merkin merkkipuskurista. Toinen poistaa annetun lukumäärän verran merkkejä merkkipuskurista ja kolmas poistaa annettuun lopetusmerkkiin saakka korkeintaan annetun lukumäärän verran merkkejä. Jos lukumäärä on yhtä suuri kuin suurin mahdollinen kokonaisluku 1, niin silloin poistetaan kaikki merkit kunnes luetaan annettu lopetusmerkki tai tiedoston loppumerkki. Jos puskuri tyhjenee täysin, jäädään odottamaan lisää merkkejä tuhottavaksi. Konsolipohjaisessa käyttöliittymässä kannattaa käyttää seuraavaa rakennetta: int luku; cin >> luku; cin.clear(); cin.ignore(numeric_limits<int>::max(), \n ); string rivi; getline(cin, rivi); 1 saadaan kutsumalla funktiota std::numeric_limits<int>::max(), joka on määritelty otsikkotiedostossa <limits> 10

11 3. Merkkijonon muuttaminen numeeriseksi arvoksi ja päinvastoin Kuten edellä on tullut ilmi, lukujen lukeminen virheettömästi käyttämällä konsolipohjaista käyttöliittymää on varsin hankalaa. Yksi tapa tämän hankaluuden voittamiseksi on lukea kaikki tiedot konsolilta merkkijonoina ja muuttaa ne tarvittaessa luvuiksi käyttäen hyväksi muotoiltua lukutoimenpiteitä merkkijonoon. Tämä onnistuu käyttämällä vuota std::stringstream, joka on määritelty otsikkotiedostossa <sstream>. Seuraavassa esimerkissä vuota käytetään lukemaan kaksi kokonaislukua: #include <iomanip> #include <string> #include <sstream> int luku1 = 0; int luku2 = 0; cout << Anna ensimmäinen luku: ; string luku; getline(cin, luku); if (cin.good()) stringtream strm1(luku); strm1 >> luku1; cout << Anna toinen luku: ; getline(cin, luku); if (cin.good()) stringstream strm2(luku); strm2 >> luku2; double keskiarvo = (luku1 + luku2) / 2.0; cout << Lukujen keskiarvo on << setprecision(2) << showpoint << keskiarvo; 11

12 Tätä merkkijonovuota voidaan myös käyttää muuttamaan numeerinen tieto merkkijonoksi: #include <iomanip> #include <string> #include <sstream> int luku1 = 0; int luku2 = 0; cout << Anna ensimmäinen luku: ; string luku; getline(cin, luku); if (cin.good()) stringtream strm1(luku); strm1 >> luku1; cout << Anna toinen luku: ; getline(cin, luku); if (cin.good()) stringtream strm2(luku); strm2 >> luku2; double keskiarvo = (luku1 + luku2) / 2.0; stringstream strm3; strm3 << setprecision(2) << showpoint << keskiarvo; string str = strm3.str(); cout << Lukujen keskiarvo on << str; 4. Funktiot C++:ssa aliohjelmaa ja funktiota ei eroteta toisistaan; aliohjelmana voidaan pitää funktiota, jonka paluutyyppi on void, ts. kyseessä on funktio, joka ei palauta mitään. Jotta funktiota voidaan käyttää hyväksi eli kutsua, sen muodon on oltava selvillä siinä ohjelman kohdassa, jossa funktiota kutsutaan. Tätä muodon selvittämistä kutsutaan funktion esittelyksi ja funktion esittelylausetta funktion prototyypiksi. Esittelylauseet voivat olla missä ohjelmakoodin kohdassa tahansa; esittelyt ovat voimassa esittelylauseesta lähtien esittelylauseen sisältävän näkyvyysalueen loppuun asti. Yleensä esittelylauseet kerätään yhteen, joko C++ tiedoston alkuun #include-lauseiden jälkeen tai 12

13 otsikkotiedostoihin. Otsikkotiedostoja on käytettävä silloin, kun funktiota on tarkoitus kutsua useasta eri tiedostosta. Esittelyssä funktion nimeen liitetään sen palauttaman arvon tyyppi ja sen tarvitsemat parametrien tyypit ja mahdollisesti parametrien oletusarvot. C++ -ohjelmassa saa olla samannimisiä funktioita, kunhan niiden parametriluettelot poikkeavat toisistaan. Tätä sanotaan funktion ylikuormittamiseksi. Esittelylauseessa annetaan aina funktion paluuarvon tyyppi, funktion nimi ja sulkeissa oleva parametriluettelo. Esittelylause päättyy puolipisteeseen. Parametriluettelossa on lueteltu funktion tarvitsemat parametrit pilkulla erotettuna toisistaan. Jos funktiolla ei ole yhtään parametria, parametriluettelo on tyhjä. Parametrista ilmoitetaan tyyppi ja mahdollisesti parametrin nimi. Lisäksi parametrilla voi olla oletusarvo. Esittelyssä riittää siis parametrien yhteydessä vain niiden tyyppi, mutta koska esittelylause on ainoa kohta, jossa funktion käyttäjä voi saada tietoa funktiosta, kannattaa parametri nimetä sen tarkoituksen mukaisesti ja sisällyttää nimi esittelylauseeseen. Parametreille voidaan antaa oletusarvoja parametriluettelon lopusta lähtien, jolloin annettuja arvoja käytetään, ellei funktion kutsussa parametria käytetä. Oletusparametrien avulla voidaan vähentää funktioiden kuormittamisen tarvetta. Seuraavat kaksi esimerkkifunktiota palauttavat double-tyyppisen arvon ja niillä on yksi doubletyyppinen parametri: double converttocelsius(double farenheit); double converttofarenheit(double celsius); Seuraavassa esittelylausessa esitellään funktio nimeltään calculatedistance, joka palauttaa double tyyppisen arvon. Funktiolla on kuusi double tyyppistä parametria, joista kolmella viimeisellä on oletusarvo: double calculatedistance(double x1, double y1, double z1, double x0 = 0, double y0 = 0, double z0 = 0); Mikäli funktiota kutsutaan vain kolmella parametrilla, käytetään funktiossa muuttujien x0, y0 ja z0 arvoina nollaa. Jotta funktio suorittaisi halutut toiminnot, se pitää määritellä. Samalla funktiolla saa olla vain yksi määrittely, sen sijaan esittelylauseita voi olla useita. Kahden funktion katsotaan olevan samoja jos niiden nimet ovat samoja ja parametriluettelo on sama. Kaksi samannimistä funktiota, joilla on eri parametriluettelo, tulkitaan eri funktioiksi, jotka molemmat on määriteltävä erikseen. Määrittelylause alkaa funktion esittelylauseella ilman lopettavaa puolipistettä, jonka tilalle tulee funktion toiminnat toteuttava määrittelylohko. Määrittelylauseet sijoitetaan aina johonkin C++kooditiedostoon. Määrittelylauseen parametriluettelossa pitää olla kaikilla käytettävillä parametreilla nimi. Määrittelyn yhteydessä parametreille ei saa antaa oletusarvoa. 13

14 Seuraavassa esimerkissä määritellään edellä esitellyt kolme funktiota: #include <cmath> // sqrt funktio double converttocelsius(double farenheit) return 5 * ( farenheit 32 ) / 9; double converttofarenheit(double celsius) return * celsius / 5; double calculatedistance(double x1, double y1, double z1, double x0, double y0, double z0) using std::sqrt; double distance = (x1 x0) * (x1 x0); distance += (y1 y0) * (y1 y0); distance += (z1 z0) * (z1 z0); distance = sqrt(distance); return distance; Lisäksi on mahdollista määritellä funktioita, joilla voi olla vaihtuva määrä parametreja, mutta koska C++:ssa on mahdollista kuormittaa funktion nimeä eri parametriluetteloilla, niin tällaisia funktioita ei enää C++:ssa juuri käytetä. Tekniikka on kääntäjäriippuvainen mutta rajapinnat on standardoitu otsikkotiedostossa <cstdarg>. Tärkeimpiä asioita funktioiden toiminnan ymmärtämisessä ja toteuttamisessa on mieltää, miten funktiolle välitetään sen tarvitsemat parametrit. C++-kielessä parametrit voidaan välittää joko arvo- tai viittausparametreina. Funktion arvoparametrit Arvotyyppisessä parametrien välityksessä parametriksi annettu muuttujan arvo kopioidaan määrityksen yhteydessä olevaan muuttujaan. Tämä on parametrinvälityksen oletusmuoto C++:ssa. Tällöin siis alkuperäisen muuttujan arvo ei muutu, vaikka funktiolle annettua arvoa muutetaan funktiossa. Seuraavassa esimerkissä funktiossa muutetaan annettua parametria, joka on sille annettu käyttäen arvoparametria: 14

15 void muuta(int arvo); int a = 10; cout << a ( << hex << &a << ) = << dec << a << endl; muuta(a); cout << a ( << hex << &a << ) = << dec << a << endl; void muuta(int arvo) cout << arvo ( << hex << &arvo << ) = << dec << arvo << endl; arvo = 123; cout << arvo ( << hex << &arvo << ) = << dec << arvo << endl; Ohjelma voi tulostaa esimerkiksi seuraavaa (muuttujien muistiosoitteet voivat vaihtua): a (0xfedc3823) = 10 arvo (0xfedc3900) = 10 arvo (0xfedc3900)= 123 a (0xfedc3823)= 10 Tulostuksesta nähdään että pääohjelman muuttujan arvo ei muutu ja että parametrimuuttujan muistiosoite on eri kuin pääohjelman muuttujan. Funktion viiteparametrit Jos halutaan että funktiossa muutettu arvo päivittyy myös parametrina annettuun muuttujaan, tieto on syytä välittää käyttäen viitetyypistä parametrin välitystä. Tällöin ei välitetä funktiolle muuttujan arvoa vaan sen osoite, jota kautta kutsuva funktio ja kutsuttava funktio jakavat saman muistialueen ja jommassakummassa funktiossa tapahtuva muutos näkyy molemmissa funktioissa. Kun käytetään viiteparametria, niin ei kopioida parametrina annettua muuttujaa toiseen muuttujaan, mikä on tärkeää varsinkin silloin kun välitetään suuria olioita. Tästä syystä C++:ssa on tapana välittää olioparametrit käyttäen viiteparametria, koska olioiden kopioiminen voi olla erittäin paljon resursseja vievä toimenpide. Arvoparametrina välittäminen ei aina ole edes mahdollista. Kun käytetään viittaustyyppistä viiteparametria, ei tarvitse välittää eksplisiittisesti muuttujien osoitteita, vaan osoitteiden välittämisen hoitaa kääntäjä. Viittaustyyppisiä muuttujia käytetään täsmälleen samoin kuin normaaleja muuttujia. Viittaustyyppinen parametri merkitään 15

16 parametriluettelossa parametrin tyypin yhteydessä olevalla & -merkillä. Seuraavassa esimerkissä käytetään viittaustyyppistä parametrien välitystä: void muuta(int& arvo); int a = 10; cout << a ( << hex << &a << ) = << dec << a << endl; muuta(a); cout << a ( << hex << &a << ) = << dec << a << endl; void muuta(int& arvo) cout << arvo ( << hex << &arvo << ) = << dec << arvo << endl; arvo = 123; cout << arvo ( << hex << &arvo << ) = << dec << arvo << endl; Ohjelman tulostus on seuraavan kaltainen (ainoastaan muistiosoitteet voivat vaihtua): a (0xfedc3823) = 10 arvo (0xfedc3823) = 10 arvo (0xfedc3823)= 123 a (0xfedc3823)= 123 Usein halutaan, varsinkin olioita parametreina välitettäessä, välttää parametrin kopiointi, vaikka parametrimuuttujaa ei haluttaisikaan muuttaa funktiossa. Tällöin käytetään viiteparametreja. Jotta muuttujaa ei vahingossa muutettaisi funktiossa, voidaan funktiolta evätä oikeus muuttaa parametrin arvoa välittämällä parametri vakioviittauksen avulla, kuten seuraavassa esimerkissä: 16

17 #include <string> std::ostream& print(const std::string& merkkijono); std::ostream& printnl(const std::string& merkkijono); printnl( Terve maailma\n ); std::ostream& print(const std::string& str) return std::cout << str; std::ostream& printnl(const std::string& str) return print(str) << std::endl; Jos jommassakummassa funktiossa yritettäisiin muuttaa str-parametrin arvoa, kääntäjä antaisi virheilmoituksen. Parametri välitetään siis vakiomuotoisena viiteparametrina eikä arvoparametrina tehokkuussyistä, koska tällöin ei muodosteta str-muuttujaan kopiota tulostettavasta merkkijonosta. Osoittimet funktion parametreina Kun funktion parametrina on osoitin, se välitetään käyttäen arvovälitystä. Osoitin viittaa kuitenkin johonkin muistiosoitteeseen, joten sen kautta voidaan vaikuttaa samaan osoitteeseen kuin alkuperäinen osoitinmuuttuja. Näin ollen osoittimia käyttämällä saa aikaan vaikutukseltaan samantapaisen funktion kuin viiteparametreilla. Näissä kummassakin tapauksessa voidaan puhua muuttujaparametreista, kuten teoksessa [Hie], s Kun parametri välitetään muuttujaparametrina käyttäen osoitinta parametrina, ei funktiolle annetakaan muuttujan arvoa vaan osoite, jossa muuttuja sijaitsee tietokoneen muistissa. Jokaisella muuttujalla paitsi literaalilla on muistiosoite, myös vakiomuuttujilla. Muuttujan osoite saadaan selville osoiteoperaattorin & avulla. Toinen osoitinmuuttujien yhteydessä käytettävä operaattori on sisältöoperaattori *. Muistipaikan sisältöön viittaamista tämän operaattorin avulla kutsutaan myös dereferenssiksi. Parametrien välityksessä osoiteoperaattoria käytetään funktiokutsun yhteydessä, ja sisältöoperaattoria käytetään kutsuttavan funktion määrittelyssä, kun halutaan lukea tai kirjoittaa parametrin arvoa. Parametriluettelossa osoitintyyppinen parametri ilmaistaan liittämällä tarkoitetyyppiin * - merkki. Seuraavassa esimerkissä on toteutettu edellisen esimerkin kanssa samalla tavoin toimiva ohjelma käyttäen osoitintyyppistä muuttujaparametria: 17

18 void muuta(int* arvo); int a = 10; cout << a ( << hex << &a << ) = << dec << a << endl; muuta(&a); // Parametriksi muuttujan a muistiosoite cout << a ( << hex << &a << ) = << dec << a << endl; void muuta(int* arvo) cout << arvo ( << hex << arvo << ) = << dec << *arvo << endl; *arvo = 123; cout << arvo ( << hex << arvo << ) = << dec << *arvo << endl; Ohjelman tulostus on seuraava (jälleen ainoastaan muistiosoitteet voivat vaihtua): a (0xfedc3823) = 10 arvo (0xfedc3823) = 10 arvo (0xfedc3823)= 123 a (0xfedc3823)= 123 Kumpaa muuttujaparametrien välitystapaa käyttää, on lähes puhtaasti tyylikysymys, mutta osoitemuuttujat ja viittausmuuttujat eroavat toisistaan seuraavasti: Viittausmuuttujaa käytettäessä pitää olla olemassa jokin muuttuja, johon viittausmuuttuja kiinnitetään lopullisesti. Viittausmuuttujan kohdetta ei voi vaihtaa määrityksen jälkeen. Osoitinmuuttujan määrityksen yhteydessä osoittimen arvon voi asettaa nollaksi, toisin sanoen osoitettavaa muuttujaa ei tarvitse olla olemassa. Osoitinmuuttuja voidaan muuttaa osoittamaan toiseen muuttujaan myös määrityksen jälkeen. Funktion paluuarvo Funktion paluuarvo voi olla jokin seuraavista: void-tyyppi, jolloin funktio ei palauta mitään (funktio on aliohjelma), tavallinen tyyppi, jolloin paluuarvo kopioidaan, osoitintyyppi, jolloin välitetään palautettavan arvon sisältämän muuttujan osoite viittaustyyppi, jolloin välitetään muodostettu viittausmuuttuja, joka viittaa palautettavan arvon sisältämän muuttujaan. 18

19 Kahdessa viimeisessä tavassa on yksi C++-kielen Akilleen kantapäistä. Se muuttuja, johon viitataan, on voitu tuhota, kun funktiosta palataan sitä kutsuvaan funktioon. Tällainen tilanne voi syntyä varsinkin, kun palautettava viite on viittaus parametrimuuttujaan tai paikalliseen muuttujaan. Nykyaikaiset kääntäjät antavat kyseisissä tilanteissa varoituksia ja virheilmoituksia, joten kannattaa tulkita tarkoin myös kääntäjän antamat varoitukset, nämäkin voivat johdattaa ohjelmointivirheen jäljille. Taulukkotyypin käyttö parametrina ja paluuarvon tyyppinä C++:ssa on mahdollista käyttää ohjelmissa C-kielen mukanaan tuomaan taulukkotyyppiä, jonka koko määritellään käännösaikana eikä sitä voida ohjelmallisesti muuttaa. Taulukon alkioiden tyyppi voi olla mikä tahansa C++:n tyyppi, jolle on määritelty oletusmuodostin, myös taulukkotyyppi, jolloin voidaan rakentaa moniulotteisia taulukoita. Oletusmuodostimen käsitteeseen palataan perehdyttäessä oliopohjaiseen ohjelmointiin. Taulukkomuuttuja määritellään muuttujan perään lisättävillä hakasulkeilla, joiden sisällä ilmaistaan taulukon koko. Tätä kokoa ei ole mahdollista ohjelmallisesti selvittää, joten taulukon koko on aina välitettävä taulukkoa käyttäville funktioille. Taulukon nimi on samalla osoitin ensimmäiseen alkioon. Taulukko välitetään funktioille osoittimena taulukon ensimmäiseen alkioon. Vastaavasti, haluttaessa palauttaa taulukko, paluutyypin arvona on osoitin taulukon ensimmäiseen alkioon. Seuraavassa on esitelty funktiot, joiden ensimmäisenä parametrina on taulukkotyyppi ja toisena tyyppinä taulukon alkioiden lukumäärä. Ensimmäinen funktio palauttaa luettujen alkioiden lukumäärän ja toinen funktio ei palauta mitään. int luelampotilat(double * lampotilat, int koko); void tulostalampotilat(double * lampotilat, int elementit); 19

20 Niiden toteutukset voivat olla esimerkiksi: int luelampotilat(double * lampotilat, int koko) cin.clear(); int count = 0; while (cin.good() && count < koko) cout << Anna lämpötila: ; double arvo; cin >> arvo; if (cin.good()) // jos lukeminen onnistui lampotilat[count] = arvo; ++count; if (!cin.good()) return -1; return count; void tulostalampotilat(double * lampotilat, int elementit) for (int i = 0; i < elementit; ++i) cout << i + 1. kuukausi: << lampotilat[i] << endl; Funktioita voitaisiin käyttää pääohjelmassa esimerkiksi seuraavasti: const int TAULU_KOKO = 12; double taulu[taulu_koko]; int lkm = luelampotilat(taulu, TAULU_KOKO); tulostalampotilat(taulu, lkm); Olioita sisältäviin taulukoihin palataan myöhemmin. Lähteet [CppTut] Juustila, A. Kettunen, H. Kilpi, T. Räisänen, T. Vesanen A.: C++ -tutoriaali (Opetusmoniste) 2004, Saatavana [Hie] Hietanen, P.: C++ ja olio-ohjelmointi, 3. laitos, Docendo