Ohjelmointi funktioiden avulla

Transkriptio

1 Ohjelmointi funktioiden avulla 8 Ohjelmointi funktioiden avulla Ohjelman jakaminen hallittaviin osiin on idea, joka on perustana kaikille ohjelmointikielille. Funktio on kaikkien C++-ohjelmien perusosa. Tähän mennessä olemme käyttäneet joitakin standardikirjaston funktioita, mutta itse olemme kirjoittaneet vasta main()-funktioita. Tässä luvussa käsitellään omien funktioiden määrittelyä. Luvun aiheita ovat: Mikä on funktio ja miksi ohjelma tulisi jakaa funktioihin Miten funktioita esitellään ja määritellään Miten parametrejä välitetään funktiolle ja kuinka funktio palauttaa paluuarvon Mitä ovat arvoparametrit Mitä parametrin määritteleminen osoittimeksi vaikuttaa parametrinvälitykseen Mitä const-avainsanan käyttäminen parametrin tyypin yhteydessä vaikuttaa funktion toimintaan Mitä ovat viittausparametrit ja miten viittaukset määritellään ohjelmassa Miten funktiosta palautetaan paluuarvo Mitä tarkoittaa avoin funktio Mitä vaikutusta on funktion muuttujan esittelyllä static-avainsanalla Ohjelman jakaminen osiin Kaikki tähän saakka kirjoittamamme ohjelmat ovat koostuneet vain yhdestä funktiosta, main()- funktiosta. Kuten tiedät, kaikissa C++-ohjelmissa tulee olla main()-funktio - ohjelman suoritus alkaa siitä. C++ sallii kuitenkin haluamasi määrän funktioita ohjelmassa ja olemmekin jo käyttäneet useita standardikirjaston funktioita esimerkeissämme. Omien funktioiden määrittely ja käyttäminen on yhtä helppoa. Kuvitteellisen ohjelman jakaantuminen funktioihin on esitetty seuraavassa kaaviossa: 277

2 C++ Ohjelmoijan käsikirja int main()... teetama();... teetuo();... return 0; kutsu paluu kutsu paluu void teetama()... y = lasketama();... m = lasketuo();... return ; void teetuo()... n = lasketuo();... t = lasketoinen();... return ; paluu kutsu paluu kutsu kutsu paluu kutsu paluu double lasketama()... return arvo; long lasketuo()... return kokonaisluku; double lasketoinen()... return z; Yleisesti ottaen, kun kutsut ohjelmassasi olevaa funktiota, funktion sisältämä koodi suoritetaan; kun se on suoritettu, ohjelman suoritus jatkuu funktion kutsukohtaa seuraavalta riviltä. Mikä tahansa funktio voi kutsua mitä tahansa toista funktiota (tätähän main()-funktiokin tekee), joka saattaa edelleen kutsua uutta funktiota, joten yhden funktion kutsu saattaa saada aikaan useamman funktion suorituksen. Kun funktio kutsuu toista funktiota, joka puolestaan kutsuu uutta funktiota ja niin edelleen, ohjelmasi on tilanteessa, jossa on useampi funktio aktiivisina ja jokainen funktio odottaa paluuta kutsumastaan funktiosta. Yllä olevassa kaaviossa main() kutsuu teetama()-funktiota, joka kutsuu lasketama()-funktiota, joten kaikki kolme ovat aktiivisina yhtä aikaa. Kun lasketama() on suorituksessa, funktio teetama() odottaa paluuta ja main() odottaa teetama()-funktion paluuta. Jotta funktio voidaan suorittaa, sen koodin tulee sijaita jossain kohtaa muistissa. Tässä on helppo sanoa, että yksi funktio odottaa toisen funktion paluuta, mutta jotta tämä kaikki toimii, jonkun täytyy pitää kirjaa, mistä kohdasta muistia kutsu tehtiin ja mihin funktion tulee palata. Nämä tiedot talletetaan ja niitä ylläpidetään kutsupinossa. Kutsupino sisältää kaikki tiettynä hetkenä aktiivisina olevat funktion kutsut sekä kullekin funktiolle välitetyt parametrit. Useimpien C++kehitysympäristöjen mukana tulevissa debuggereissa on mahdollista seurata kutsupinoa ohjelman suorituksen aikana. 278 Miksi ohjelmat tulee jakaa osiin Ohjelmien jakamiseksi on useita syitä. Ensiksikin se tekee ohjelmien lukemisen ja hallinnan helpommaksi. On helppo kuvitella, että main()-funktio saattaisi tulla hallitsemattoman kokoiseksi. Useat nykypäivän ohjelmista sisältävät useista sadoista tuhansista koodiriveistä aina miljooniin riveihin saakka. Voit vain kuvitella, kuinka main()-funktiota ylläpidettäisiin, jos siinä olisi riviä koodia! Ohjelman logiikan selvittäminen saattaisi jo olla lähes mahdotonta, puhumattakaan virheen etsimisestä. Tällaisen ohjelman jakaminen osiin on aivan välttämätöntä.

3 Ohjelmointi funktioiden avulla Toiseksi, funktioita voidaan käyttää uudelleen. Saatat esimerkiksi kirjoittaa yhteen ohjelmaan funktion, joka lajittelee merkkijonoja. Voit myöhemmin käyttää samaa funktiota muissa ohjelmissa. Standardikirjasto on hyvä esimerkki funktioiden uudelleenkäytöstä. Standardikirjaston ohjelmointiin ja testaukseen on käytetty tuhansia tunteja, mutta sinulla on kaikki sen toiminnot heti käytettävissä. Kolmanneksi, ohjelman jakaminen useisiin funktioihin voi vähentää ohjelman suorittamiseksi tarvittavaa muistia. Useimmat sovellukset sisältävät laskentaa, joka suoritetaan toistuvasti. Jos laskennan suorittava koodi sijoitetaan funktioon, jota kutsutaan aina tarvittaessa, koodi kirjoitetaan vain kerran. Ilman funktioita koodi pitäisi toistaa aina tarvittaessa; eli käännetty ohjelma olisi suurempi. Funktioiden perusteet Olemme tähän saakka kirjoittaneet varsin yksinkertaisia main()-funktioita, joten sinulla pitäisi olla jo varsin hyvä kuva funktioista, mutta käymme läpi perusideat, jotta kaikki olisi aivan selvää. Katsotaan ensiksi funktioiden toiminnan perusteita: Funktio on itsenäinen, tiettyä tehtävää varten tehty koodilohko. Tästä on suorana seurauksena se, että sinulla tulee olla suhteellisen kirkas ajatus ohjelmasi jakamisesta toiminnallisiin osiin. C++:ssa tähän sisältyy muutakin, mutta ohitamme tämän, kunnes käsittelemme tietotyyppien määrittelyä luvussa 11. Huomaat, että tällä on syvällinen vaikutus siihen, miten suunnittelet ohjelmasi rakenteen. Katsotaan nyt, miten funktio rakennetaan. Jatkossa on hyvä pitää seuraava esimerkki mielessä: Funktion paluuarvon tyyppi Funktion nimi Parametrit määrittelevät funktiolle välitettävien arvojen tyypit ja ne ovat parametrien tunnisteet funktion rungossa Funktion runko on aaltosulkeiden välissä double potenssi( double x, int n) double tulos = 1.0; if(n >= 0) for(int i = 1 ; i <= n ; i++) tulos *= x; else for(int i = 1 ; i <= -n ; i++) tulos /= x; return tulos; Funktio tunnistetaan yksikäsitteisesti sen nimen ja parametrien perusteella 279

4 C++ Ohjelmoijan käsikirja Funktion määrittely Funktion toiminta määritellään funktion määrittelyssä. Äskeisessä kaaviossa on funktion koko määrittely. Määrittelyssä on kaksi osaa: funktion otsikko, joka on määrittelyn ensimmäinen rivi ennen ensimmäistä aaltosulkua sekä funktion runko, joka on aaltosulkeiden sisällä. Kuten tiedät main()-funktion käyttökokemuksesta, funktion runko sisältää koodin, joka suoritetaan, kun funktiota kutsutaan. Funktion otsikko Käsitellään ensiksi esimerkkifunktion otsikkoa. Seuraavassa on funktion ensimmäinen rivi: double potenssi(double x, int n); Se koostuu kolmesta osasta: paluuarvon tietotyyppi (joka on double tässä tapauksessa); funktion nimi, potenssi ja sulkeiden sisällä oleva funktion parametriluettelo. Parametrien nimet ovat tässä x ja n ja näitä nimiä käytetään funktion lauseissa. Ne vastaavat funktiolle kutsussa välitettyjä parametrejä. Parametri x on double-tyyppinen ja n on int-tyyppinen, joten funktiota kutsuttaessa sille tulee välittää tämän tyyppiset parametrit. Huomaa, että funktion otsikon perässä ei ole puolipistettä. Funktion otsikon yleinen muoto Funktion otsikon yleinen muoto voidaan kirjoittaa seuraavasti: paluuarvon_tyyppi FunktionNimi(parametriluettelo) FunktionNimi on nimi, jota käytetään funktiota kutsuttaessa. On hyvä tapa antaa kaikille ohjelman funktioille oma nimi, mutta kuten näit joidenkin standardikirjaston funktioiden yhteydessä, useilla funktioilla voi olla sama nimi, kunhan niillä on erilaiset parametriluettelot. Funktion nimiin pätee samat säännöt kuin muuttujien nimiinkin. Eli funktion nimi muodostuu kirjaimista ja numeroista, ensimmäisen merkin tulee olla kirjain ja alaviiva vastaa kirjainta. Funktion nimen tulisi vastata jotenkin sen suorittamaa tehtävää, joten funktion, joka laskee papujen määrää, nimi voisi olla vaikka LaskePavut(). Funktion, joka laskee luvun potenssin, nimi voisi olla potenssi(). Paluuarvon_tyyppi on funktion palauttaman arvon tietotyyppi. Se voi olla mikä tahansa tietotyyppi - mukaan lukien kaikki itse luomasi tietotyypit. Jos funktio ei palauta mitään paluuarvoa, paluuarvon tyyppi määritellään avainsanalla void. Parametriluettelo kertoo, mitä tietoja funktiolle voidaan välittää kutsuvasta funktiosta. Se määrittelee kunkin parametrin nimen ja tyypin. Parametrin nimeä käytetään funktion rungossa viittaamaan kutsuvasta funktiosta tuotuun tietoon. Funktiolla ei tarvitse olla yhtään parametriä. Tätä kuvataan tyhjällä parametriluettelolla tai avainsanalla void. Funktion, jolla ei ole parametrejä eikä palauta mitään paluuarvoja, otsikko on siis: 280

5 Ohjelmointi funktioiden avulla void OmaFunktio() Tai vaihtoehtoisesti: void OmaFunktio(void) Huomaa, että parametrin tyyppi ei voi olla void. Koska funktio, jonka paluuarvon tyyppi on void, ei palauta arvoa, sitä ei voi kutsua lausekkeesta. Funktion arvona ei ole mitään, joten sen arvon vertaamisella tai sijoittamisella ei ole mitään merkitystä. Tällaisen funktion käyttäminen tällaisessa yhteydessä saa aikaan kääntäjän virheilmoituksen. Funktion runko Funktio suorittaa tehtävänsä suorittamalla sen rungossa olevat lauseet. Esimerkissämme funktion rungon ensimmäisellä rivillä esitellään double-tyyppinen muuttuja tulos, jonka alkuarvoksi asetetaan 1.0. tulos on automaattinen muuttuja: se on määritelty paikalliseksi funktiossa ja se on olemassa vain funktion rungossa. Tämä tarkoittaa sitä, että tulos häviää funktion suorituksen jälkeen. Laskenta suoritetaan jommassa kummassa for-silmukassa, riippuen n:n arvosta. Jos n on suurempi tai yhtä suuri kuin nolla, ensimmäinen for-silmukka suoritetaan. Jos n:n arvo on nolla, silmukkaa ei suoriteta kertaakaan, koska silmukan ehtolausekkeen arvo on heti false. Tällöin tuloksen arvoksi jää 1.0. Muutoin silmukan kontrollimuuttuja i saa arvot 1 - n ja muuttuja tulos kerrotaan x:llä jokaisella silmukan kierroksella, jolloin tuloksena on haluamamme arvo. Jos n on negatiivinen, toinen for-silmukka suoritetaan, jolloin tulos jaetaan x:llä jokaisella silmukan kierroksella. Muista aina, että funktion rungossa esitellyt muuttujat ja funktion parametrit ovat paikallisia kyseisessä funktiossa. Muuttujien ja parametrien nimiä voi käyttää toisissa funktioissa halutessasi erilaisiinkin tarkoituksiin. Funktiossa esiteltyjen muuttujien näkyvyysalue määritellään samaan tapaan kuin olemme jo nähneet: muuttuja luodaan siinä kohdassa, jossa se määritellään ja se häviää määrittelyn sisältävän lohkon päättyessä. Ainoana poikkeuksena tähän on static-avainsanalla määritellyt muuttujat. Käsittelemme niitä myöhemmin tässä luvussa. Ennen kuin käsittelemme parametrejä ja paluuarvoja syvällisemmin, sijoitetaan funktiomme potenssi() ohjelmaan. Kokeile itse - Funktion käyttö Seuraavassa esimerkissä käytetään potenssi()-funktiota: // Esimerkki Luvun potenssin laskenta #include <iostream> #include <iomanip> using namespace std; 281

6 C++ Ohjelmoijan käsikirja // Funktio laskee x potenssiin n double potenssi(double x, int n) double tulos = 1.0; if(n >= 0) for(int i = 0 ; i < n ; i++) tulos *= x; else for(int i = 0 ; i < -n ; i++) tulos /= x; return tulos; int main() cout << endl; // Lasketaan 8 potenssit for(int i = -3 ; i <= 3 ; i++) cout << setw(10) << potenssi(8.0, i); cout << endl; return 0; Ohjelman tulostus näyttää seuraavalta: Kuinka se toimii Kaikki toiminta tapahtuu main()-funktion for-silmukassa: for(int i = -3 ; i <= 3 ; i++) cout << setw(10) << potenssi(8.0, i); Funktiota potenssi() kutsutaan seitsemän kertaa. Niissä jokaisessa on ensimmäisenä parametrinä luku 8.0, mutta toisena parametrinä on i:n arvot Näin ollen seitsemän arvoa tulostetaan, eli arvot 8-3, 8-2, 8-1, 8 0, 8 1, 8 2 ja 8 3. Parametrit Funktiolle välitetään tietoa parametreissä, jotka määrittelet funktiota kutsuessasi. Ne sijoitetaan funktion nimen perässä olevien sulkeiden sisään, kuten edellisessä esimerkissä: cout << setw(10) << potenssi(8.0, i); Kutsussa käytetyt parametrit korvaavat funktion määrittelyssä käytetyt parametrit. Funktio suoritetaan aivan kuin se olisi kirjoitettu siten, että syötteenä saadut arvot olisivat funktion parametreissä. Funktion kutsussa käytettyjen parametrien ja funktion määrittelyssä käytettyjen parametrien välistä suhdetta kuvaa seuraava kaavio: 282

7 Ohjelmointi funktioiden avulla cout << potenssi( 3.0, 2 ); Funktion kutsun parametrit vastaavata funktion määrittelyn parametrejä Arvo 9.0 palautetaan, kun funktion suoritys päättyy double potenssi( double x, int n) double tulos = 1.0; if(n >= 0) for(int i = 1 ; i <= n ; i++) tulos *= x; else for(int i = 1 ; i <= -n ; i++) tulos /= x; return tulos; Funktion rungon koodi suoritetaan aivan kuin parametreissä olisi funktion kutsussa välitetyt arvot Funktion kutsun parametrien ja funktion määrittelyn parametrien välillä oleva ero on hyvin pieni. Funktion määrittelyn parametri esiintyy funktion määrittelyssä ja määrittelee funktion odottaman tietotyypin. Funktion kutsun parametri on se todellinen arvo, joka välitetään funktiolle sitä kutsuttaessa. Funktion kutsun parametrien järjestyksen tulee olla sama kuin funktion määrittelyn parametrien. On myös hyvä idea varmistaa, että kutsun parametrit ovat samaa tyyppiä kuin määrittelyn parametrit vaativat: kääntäjä ei välttämättä ilmoita, jos sen täytyy käyttää automaattista tyypinmuunnosta, jolloin saatat menettää tietoa. C++ sallii samassa ohjelmassa määriteltävän monta funktiota samalla nimellä. Saman nimisillä funktioilla tulee olla parametriluettelo. Funktion nimeä ja parametriluetteloa kutsutaan yhdessä funktion allekirjoitukseksi. Jos ohjelmassa on useita saman nimisiä funktiota, kääntäjä käyttää funktion allekirjoitusta päätellessään, mitä funktiota on kutsuttu. Tästäkin syystä on hyvä varmistaa, että kutsun ja määrittelyn parametrit vastaavat toisiaan. Paluuarvot Yleisesti ottaen funktion, jonka paluuarvon tyyppi on jokin muu kuin void, tulee palauttaa yksi paluuarvo, jonka tyyppi on määritelty funktion otsikossa. Paluuarvo lasketaan funktion rungossa ja palautetaan, kun funktion suoritus päättyy. Eli kun funktiota potenssi() kutsutaan lausekkeessa, potenssi() toimii double-tyyppisenä arvona. Paluuarvon palauttamaa funktiota ei kuitenkaan tarvitse kutsua lausekkeesta. Voit kutsua myös pelkkää funktiota: potenssi(10.5, 2); Tässä funktio suoritetaan normaalisti, mutta paluuarvoa ei käytetä mihinkään. Funktion potenssi() kutsuminen tällä tavalla ei ole järkevää, mutta monien muiden funktioiden kohdalla näin saattaisi ollakin. Sinulla voi olla esimerkiksi funktio, joka kopioi tiedoston ja paluuarvo vain välittää lisätietoa funktion suorituksesta (esimerkiksi onnistumisesta tai epäonnistumisesta), jota et ehkä aina tarvitse. Samaan tapaan kutsutaan tietysti funktioita, joiden paluuarvon tyyppi on void. 283

8 C++ Ohjelmoijan käsikirja Se, että funktio voi palauttaa vain yhden paluuarvon, saattaa nyt tuntua rajoitteelta, mutta näin ei ole. Palautettava arvo voi olla osoitin mihin tahansa: taulukkoon tai jopa osoitintaulukkoon. Tietty funktio palauttaa aina tietyntyyppisen paluuarvon. return-lause Esimerkkimme return-lause palauttaa muuttujan tulos arvon. Saatat nyt hieman ihmetellä, sillä väitimmehän juuri, että muuttuja tulos häviää funktion suorituksen päättyessä, eli mitä oikein palautetaan? Vastaus on, että palautettavasta arvosta tehdään automaattisesti kopio, joka on käytettävissä funktion kutsukohdassa. return-lauseen rakenne on: return lauseke; Tässä lausekkeen arvon tulee vastata funktion otsikossa määriteltyä funktion paluuarvon tyyppiä. Lauseke voi olla vaikka kuinka monimutkainen, kunhan tuloksena on palautettava tyyppi. Se voi sisältää funktion kutsuja ja se voi sisältää myös kutsun samaan funktioon, jossa tämä return-lause on. Tällaiseen tilanteeseen palaamme seuraavassa luvussa. Jos paluuarvon tyypiksi on määritelty void, return-lauseessa ei voi olla lauseketta. Eli se täytyy kirjoittaa seuraavasti: return; Jos funktion rungon päättävä aaltosulku kohdataan suorituksen aikana, se vastaa return-lauseen kutsumista ilman lauseketta. Itse asiassa, jos funktion paluuarvon tyyppi on void, tämä on suositeltava tapa toimia. Jos funktion paluuarvon tyyppi on eri kuin void, tämä olisi tietysti virhe, eikä funktio kääntyisi. Funktion esittely Edellinen esimerkkimme, esimerkki 8.1, toimi aivan hyvin, mutta yritetään nyt muuttaa koodia siten, että main()-funktio on potenssi()-funktion edellä. Ohjelman koodi näyttäisi seuraavalta: // Esimerkki Luvun potenssin laskenta - uusi järjestys #include <iostream> #include <iomanip> using namespace std; int main() cout << endl; // Lasketaan 8 potenssit for(int i = -3 ; i <= 3 ; i++) cout << setw(10) << potenssi(8.0, i); cout << endl; return 0; 284

9 Ohjelmointi funktioiden avulla // Funktio laskee x potenssiin n double potenssi(double x, int n) double tulos = 1.0; if(n >= 0) for(int i = 0 ; i < n ; i++) tulos *= x; else for(int i = 0 ; i < -n ; i++) tulos /= x; return tulos; Jos yrität kääntää tämän version, se ei onnistu. Kääntäjällä on ongelma, koska funktiota potenssi() ei ole määritelty kääntäjän käsitellessä funktiota main(). Voimme tietysti hylätä tämän version ja käyttää aina edellistä versiota, mutta sehän ei ratkaise ongelmaamme. Tähän liittyy kaksi asiaa. Ensinnäkin, ohjelma saattaa koostua useammista lähdetekstitiedostoista, kuten näemme myöhemmin. Tällöin saattaa olla, että kutsuttava funktio ei ole kutsuvan funktion edellä - se voi olla jopa aivan eri tiedostossakin. Toiseksi, oletetaan, että meillä on funktio A(), joka kutsuu funktiota B(), joka puolestaan kutsuu funktiota A() uudelleen. Jos nyt sijoitamme funktion A() ennen funktiota B(), ohjelma ei käänny, koska A() kutsuu funktiota B(); sama ongelma esiintyy, jos ensiksi määritellään B(), koska se kutsuu funktiota A(). Kuten arvata saattaa, tällaiseen tilanteeseen on ratkaisu. Voimme esitellä funktion ennen kuin käytämme sitä tai määrittelemme sen. Tämä tapahtuu funktion prototyypin avulla. Funktion prototyyppi Funktion prototyyppi on lause, joka kuvaa funktion riittävän tarkasti, jotta kääntäjä voi kääntää sen kutsut. Se esittelee funktion nimen, paluuarvon tyypin ja parametrien tyypit. Funktion prototyyppiä kutsutaan usein funktion esittelyksi ja on samanlainen kuin muuttujan esittelykin - funktiota ei voida kutsua lähdetekstitiedostossa, ellei kutsun edellä ole funktion esittelyä. Funktion määrittely on myös funktion esittely, joten emme tarvitse funktion prototyyppiä funktiosta potenssi() esimerkissä 8.1. Voimme kirjoittaa funktion potenssi() prototyypin seuraavasti: double potenssi(double x, int n); Jos sijoitat funktion prototyypin sen lähdetekstitiedoston alkuun, jossa funktiota kutsutaan, kääntäjä pystyy kääntämään koodin riippumatta, missä funktion määrittely on. Jotta esimerkki 8.2 kääntyisi, sijoitamme funktion potenssi() prototyypin ennen main()-funktiota: // Esimerkki Luvun potenssin laskenta - uusi järjestys #include <iostream> #include <iomanip> using namespace std; double potenssi(double x, int n); 285

10 C++ Ohjelmoijan käsikirja int main() //main()-funktio kuten ennenkin double potenssi(double x, int n) //potenssi()-funktio kuten ennenkin Tässä funktion prototyyppi on sama kuin funktion otsikko lisättynä puolipisteellä. Funktion prototyyppi päättyy aina puolipisteeseen, mutta yleisesti ottaen sen ei tarvitse olla samanlainen kuin funktion otsikko. Voit käyttää parametreissä eri nimiä (mutta ei eri tyyppejä) kuin funktion otsikossa. Esimerkiksi: double potenssi(double arvo, int eksponentti); Tämä toimii aivan yhtä hyvin. Näiden nimien käytön hyöty on minimaalinen, mutta selventää, että usein on hyödyllistä käyttää pidempiä nimiä parametreistä funktion prototyypissä. Koska kääntäjän tarvitsee tietää vain parametrien tyyppi, voit jättää parametrien nimet funktion prototyypistä kokonaan pois, kuten seuraavassa: double potenssi(double, int); Funktion protyypin kirjoittamisesta tällä tavalla ei ole mitään hyötyä ja se on vähemmän informatiivinen kuin parametrien nimien käyttö. Jos molemmat parametrit ovat samaa tyyppiä, tällainen protyyppi ei kerro mitään siitä, mikä parametri on mikäkin. Suosittelen, että käytät parametrien nimiä aina funktion prototyypeissä. Funktion prototyypin käyttö Kannattaa ottaa tavaksi kirjoittaa lähdetekstitiedoston alkuun kaikkien tiedostossa olevien funktioiden prototyyppi - poislukien main()-funktio, joka ei koskaan tarvitse prototyyppiä. Näin vältetään kääntäjän virheilmoitukset siitä, että funktioiden kutsujärjestys ei ole sallittu. Lisäksi muut ohjelmoijat saavat näin paremmin kuvan ohjelmasi toiminnasta. Olemme käyttäneet kirjastofunktiota varsin usein, mutta missä ovat näiden funktioiden prototyypit? Ne ovat itse asiassa standardiotsikkotiedostoissa, jotka olemme sisällyttäneet ohjelmiimme. Otsikkotiedostojen yksi tärkeimmistä tehtävistä on koota yhteen sopiva joukko funktioiden prototyyppejä. Käsittelemme lisää tätä aihetta luvussa

11 Parametrien välitys funktiolle Ohjelmointi funktioiden avulla On erittäin tärkeää ymmärtää, miten funktiolle välitetään parametrejä, koska se vaikuttaa siihen, miten kirjoitat funktioitasi ja viimekädessä niiden toimintaan. Lisäksi olemassa on useita sudenkuoppia, joita tulee välttää. Kuten olemme jo nähneet, funktion kutsussa olevien parametrien tyyppien tulee yleensä vastata funktion määrittelyssä oleviin parametreihin. Näin ei kuitenkaan aina tarvitse olla. Jos funktion kutsussa oleva parametrin tyyppi ei vastaa funktion esittelyssä olevaa parametrin tyyppiä, kääntäjä suorittaa (jos mahdollista) automaattisen tyypinmuunnoksen. Tämän automaattisen tyypinmuunnoksen säännöt ovat samat kuin luvussa 3 käsittelemämme sijoituslauseenkin yhteydessä. Jos automaattinen tyypinmuunnos ei ole mahdollista, saat kääntäjän virheilmoituksen. C++:ssa on kaksi mekanismia parametrien välittämisessä funktioille. Ensimmäinen on parametrien välittäminen arvoparametreinä ja toinen on parametrien välittäminen viittausparametreinä. Tutustumme ensin arvoparametreihin ja myöhemmin viittausparametreihin. Arvoparametrit Tässä mekanismissa funktion parametreinä olevia muuttujia tai vakioita ei itse asiassa välitetä funktiolle lainkaan. Parametreistä muodostetaan kopiot, samaan tapaan kuin paluuarvonkin yhteydessä, ja nämä kopiot välitetään funktiolle. Tätä havainnollistetaan seuraavassa kaaviossa, jossa asia esitetään potenssi()-funktiollamme: double arvo = 20.0; int indeksi = 3; double tulos = potenssi(arvo, indeksi); indeksi arvo Indeksin kopio 3 Arvon kopio 20.0 double potenssi( double x, int n) Tämä koodi ei pääse... käsiksi muuttujien indeksi ja arvo alkuperäisiin arvoihin Joka kerta, kun kutsut potenssi()-funktiota, kääntäjä muodostaa parametreistä väliaikaiset kopiot aikaisemmin tässä luvussa mainitsemaani pinoon. Funktion suorituksen aikana kaikki viittaukset parametreihin yhdistetään näihin parametrien väliaikaisiin kopioihin. Kun funktion suoritus päättyy, parametrien kopiot hävitetään. 287

12 C++ Ohjelmoijan käsikirja Voimme havainnollistaa vaikutuksia yksinkertaisella esimerkillä. Kokeile itse - Parametrien välitys funktiolle Voimme kirjoittaa funktion, joka yrittää muuttaa parametrinsä arvoa, mutta epäonnistuu surkeasti: // Esimerkki Alkuperäisen parametrin muuttaminen ei onnistu #include <iostream> #include <iomanip> using namespace std; double muutase(double se); // Funktion prototyyppi int main() double se = 5.0; double tulos = muutase(se); cout << "Funktion suorituksen jälkeen, se = " << se << endl << "Palautettu arvo on " << tulos << endl; return 0; // Funktio yrittää muuttaa alkuperäistä parametriä double muutase(double se) se += 10.0; // Tämä muuttaa alkuperäisen kopiota cout << endl << "Funktiossa, se = " << se << endl; return se; Esimerkin tulostus näyttää seuraavalta: Funktiossa, se = 15 Funktion suorituksen jälkeen, se = 5 Palautettu arvo on 15 Kuinka se toimii Tulostuksesta voit huomata, että luvun 10 lisäämisellä funktiossa muutase() muuttujaan se ei ole vaikutusta funktion main() muuttujaan se. Muuttuja se on paikallinen funktiossa muutase() ja viittaa funktiota kutsuttaessa käytetyn parametrin kopioon. 288

13 Ohjelmointi funktioiden avulla Muuttuja se funktiossa main() 5 Kopio muodostetaan, kun funktiota kutsutaan se:n kopio 5 double tulos = muutase(se); Funktiossa main() käytetään paluuarvon kopiota. Funktion muutase() muuttuja se on hävitetty eikä ole enää olemassa. Tämä lisää kopion arvoon luvun 10. se vaiittaa aina parametrin kopioon. double muutase(double se) it += 10.0; cout << endl << "Funktiossa, se = " << se << endl; return se; Palautettavasta arvosta tehdään kopio 15 Muuttujan se arvo on 15, kun kopio tehdään Koska muuttujan se paikallinen arvo funktiossa muutase() palautetaan, kopio tehdään se:n senhetkisestä arvosta, joka sitten palautetaan kutsuvalle ohjelmalle. Arvoparametrien käyttö on varsin turvallista kutsuvalle ohjelmalle, mutta mitä jos haluaisimme muuttaa alkuperäisiä arvoja? Voimmeko tehdä sen? Totta kai voimme - yksi tapa tehdä se on käyttää osoittimia. Osoittimen välitys funktiolle Kun käytät osoitinta parametrinä, parametrin välitys arvoparametrinä toimii aivan samaan tapaan kuin edelläkin. Osoitin sisältää kuitenkin toisen muuttujan osoitteen ja osoittimen kopio osoittaa tähän samaan muuttujaan. Voimme muuttaa muutase()-funktiomme määrittelyä siten, että sille voidaan välittää double*- tyyppinen parametri. Funktiossa main() voimme sitten välittää kutsussa muuttujan se osoitteen. Tietysti myös funktion muutase() koodia tulee muuttaa, jotta se käsittelee osoittimen osoittamaa arvoa. Tämä toimii seuraavalla tavalla: Muutujan se osoite funktiossa main() 64FDEC Kopio muodostetaan, kun funktiota kutsutaan se:n kopio 64FDEC 5 Tämä kasvattaa se:n alkuperäistä arvoa luvulla 10. double tulos = muutase(&se); Muuttujan se arvo on 15, kun kopio muodostetaan Funktiossa main() käytetään paluuarvon kopiota. Funktion muutase() muuttuja se on hävitetty eikä ole enää olemassa. double muutase(double *pse) *pse += 10.0; cout << endl << "Funktiossa, *pse = " << *pse << endl; return *pse; Palautettavasta arvosta tehdään kopio

14 C++ Ohjelmoijan käsikirja Koska funktiolla muutase() on nyt alkuperäisen muuttujan se osoite, se voi muuttaa muuttujan arvoa suoraan. Katsotaan kuinka tämä toimii. Kokeile itse - Osoittimen välitys Voimme muuttaa edellistä esimerkkiä käyttämään osoittimia: // Esimerkki Parametrin alkuperäisen arvon muuttaminen #include <iostream> #include <iomanip> using namespace std; double muutase(double* se_osoitin); // Funktion prototyyppi int main() double se = 5.0; double tulos = muutase(&se); // Nyt välitetään osoite cout << "Funktion suorituksen jälkeen, se = " << se << endl << "Palautettu arvo on " << tulos << endl; return 0; // Funktio muuttaa parametriä ja palauttaa sen double muutase(double* pse) *pse += 10.0; // Tämä muuttaa alkuperäistä cout << endl << "Funktiossa, *pse = " << *pse << endl; return *pse; Tämän esimerkin tulostus näyttää seuraavalta: Funktiossa, *pse = 15 Funktion suorituksen jälkeen, se = 15 Palautettu arvo on 15 Kuinka se toimii Koska parametrin tyyppi on muutettu funktion muutase() määrittelyssä, olemme muuttaneet myös funktion prototyyppiä: double muutase(double* se_osoitin); // Funktion prototyyppi 290 Olemme myöskin käyttäneet eri parametrin nimeä kuin funktion määrittelyssä - ihan vain todistaaksemme, että voimme näin tehdä! Funktiossa main(), muuttujan se esittelyn ja alustuksen jälkeen, funktiolle muutase() välitetään kutsussa muuttujan osoite: double tulos = muutase(&se); // Nyt välitetään osoite

15 Ohjelmointi funktioiden avulla Emme tarvitse osoitinmuuttujaa muuttujan se osoitetta varten. Koska tarvitsemme osoitetta vain funktion parametrinä, voimme käyttää osoite-operaattoria funktion kutsussa. Funktion muutase() uusi versio käyttää osoitus-operaattoria lisätessään luvun 10 funktiossa main() määritellyn muuttujan se sisältöön: *pse += 10.0; // Tämä muuttaa alkuperäistä Funktio palauttaa muutetun arvon myös lauseella: return *pse; Palautettavasta arvosta tehdään nytkin kopio; se tapahtuu aina automaattisesti funktiosta palautettavan arvon yhteydessä. Funktion muutase() tämä versio vain havainnollisti, kuinka osoitinparametrin avulla voidaan muuttaa kutsuvan funktion muuttujia - se ei ole malli siitä, miten funktioita tulee kirjoittaa. Koska muutamme se:n arvoa suoraan, sen palauttaminen on aivan turhaa. Taulukoiden välitys funktiolle Koska taulukon nimeä voidaan käsitellä osoitteena, voit välittää myös taulukon funktiolle käyttämällä taulukon nimeä. Tällöin taulukon osoite kopioidaan ja välitetään funktiolle. Tästä on useita etuja. Ensinnäkin, taulukon osoitteen välittäminen on tehokkaampaa kuin taulukon arvojen välitys, koska suurten taulukoiden kopiointi voi olla hyvinkin hidasta. Itse asiassa taulukoita ei voi välittää arvoina. Toiseksi, ja vielä tärkeämpänä etuna on se, että koska funktio ei käsittele alkuperäistä osoitetta vaan sen kopiota, funktio voi käyttää osoitetta tehokkaasti - mukaan lukien osoitteen muuttaminen. Katsotaan ensin kaikkein suoraviivaisinta esimerkkiä. Kokeile itse - Taulukon välitys funktion parametrinä Voimme havainnollistaa tätä kirjoittamalla funktion, joka laskee sille välitetyn taulukon alkioiden keskiarvon: // Esimerkki Taulukon välitys #include <iostream> using namespace std; double keskiarvo(double taulukko[], int lkm); // Funktion prototyyppi int main() double arvot[] = 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0; cout << endl << "Keskiarvo = " << keskiarvo(arvot, (sizeof arvot) / (sizeof arvot[0])) << endl; 291

16 C++ Ohjelmoijan käsikirja return 0; // Funktio, joka laskee keskiarvon double keskiarvo(double taulukko[], int lkm) double summa = 0.0; // Tähän lasketaan summa for(int i = 0 ; i < lkm ; i++) summa += taulukko[i]; // Summataan taulukon alkiot return summa / lkm; // Palautetaan keskiarvo Esimerkin tulostus on varsin lyhyt: Keskiarvo = 5.5 Kuinka se toimii Funktio keskiarvo() toimii minkä kokoisen taulukon kanssa tahansa. Kuten prototyypistä näet, sille välitetään kaksi parametriä: taulukko ja taulukon alkioiden lukumäärä: double keskiarvo(double taulukko[], int lkm); // Funktion prototyyppi Ensimmäinen parametri on taulukko, jonka alkiot ovat double-tyyppisiä. Taulukon kokoa ei voi tässä määritellä hakasulkeiden sisällä. Taulukon koon kirjoittamisella ei ole tässä mitään merkitystä, koska taulukon ensimmäinen ulottuvuus ei ole osa taulukon tyyppiä (muistat samankaltaisen tilanteen, kun käsittelimme osoittimia moniulotteisiin taulukoihin). Itse asiassa voit välittää tälle funktiolle minkä kokoisen yksiulotteisen taulukon tahansa. Funktio luottaa toisena parametrinä saamaansa arvoon lkm, joka kertoo taulukon alkioiden lukumäärän. Funktion keskiarvo() rungossa laskenta suoritetaan tavalliseen tapaan: double keskiarvo(double taulukko[], int lkm) double summa = 0.0; // Tähän lasketaan summa for(int i = 0 ; i < lkm ; i++) summa += taulukko[i]; // Summataan taulukon alkiot return summa / lkm; // Palautetaan keskiarvo Tällä funktiolla ei ole mitään merkittävää eroa siihen nähden, että olisimme kirjoittaneet laskennan suoraan main()-funktioon. Funktiolla ei ole mitään mahdollisuuksia tarkistaa, että taulukossa on lkm alkiota ja se käsittelee tyytyväisenä alkuperäisen alkion ulkopuolellakin olevia muistiosoitteita, jos lkm on suurempi kuin taulukon alkioiden lukumäärä. Meidän vastuullamme on, että näin ei tapahdu! 292

17 Ohjelmointi funktioiden avulla Funktiota kutsutaan main()-funktion tulostuslauseessa: cout << endl << "Keskiarvo = " << keskiarvo(arvot, (sizeof arvot) / (sizeof arvot[0])) << endl; Tässä ensimmäinen parametri keskiarvo()-funktiolle on taulukon nimi, arvot, ja toinen parametri on lauseke, jonka arvo on taulukon alkioiden lukumäärä. Tässä esimerkissä funktiolle keskiarvo() välitetyn taulukon alkioita käsiteltiin normaalissa indeksimuodossa. Kuten sanottua, voimme käsitellä funktiolle välitettyä taulukkoa myös osoittimena ja käyttää osoitinta laskennassa. Kokeillaan nyt tätä. Kokeile itse - Osoitinmuodon käyttö taulukon välityksessä Voimme muuttaa esimerkin 8.5 funktiota siten, että se käyttää osoitinmuotoa, vaikka käytämme taulukkoa. Muutamme funktion prototyyppiä ja otsikkoa osoitinmuodon (indeksimuodon sijaan) käyttöä varten ensimmäisen parametrin osalta, vaikka se ei olekaan aivan välttämätöntä. Voisit käyttää osoitinmuotoa funktion rungossa, vaikka ensimmäinen parametri olisikin määritelty taulukkona. Tässä on uusi versio ohjelmasta: // Esimerkki Taulukkoparametrin käsittely osoittimena #include <iostream> using namespace std; double keskiarvo(double* taulukko, int lkm); // Funktion prototyyppi int main() double arvot[] = 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0; cout << endl << "Keskiarvo = " << keskiarvo(arvot, (sizeof arvot) / (sizeof arvot[0])) << endl; return 0; // Funktio, joka laskee keskiarvon double keskiarvo(double* taulukko, int lkm) double summa = 0.0; // Tähän lasketaan summa for(int i = 0 ; i < lkm ; i++) summa += *taulukko++; // Summataan taulukon alkiot return summa / lkm; // Palautetaan keskiarvo Tämän esimerkin tulostus on aivan sama kuin edellisenkin esimerkin. 293

18 C++ Ohjelmoijan käsikirja Kuinka se toimii Kuten huomaat ohjelmaan ei ole tarvinnut tehdä suuriakaan muutoksia, jotta se toimisi siten, että taulukkoa käytetään osoittimena. Funktion prototyyppi ja otsikko ovat muuttuneet, vaikkakaan kumpkiaan näistä muutoksista ei ole välttämätön. (Kokeile muuttaa tämän esimerkin funktion prototyyppi ja otsikko esimerkin 8.5 mukaiseksi, mutta jätä funktion runko osoitinmuotoiseksi. Huomaat, että se toimii yhtä hyvin myös nyt.) Tämän version kaikkein kiinnostavin osa on for-silmukkassa oleva lause: summa += *taulukko++; // Summataan taulukon alkiot Näyttäisi siltä, että rikomme tässä sääntöämme emme saa muuttaa taulukon nimen osoitetta, koska kasvatamme muuttujaan taulukko talletettua osoitetta. Oikeastaan emme riko tätä sääntöä lainkaan. Palauta mieleen, että arvoparametrin yhteydessä alkuperäisen taulukon osoitteesta tehdään kopio, joka sitten välitetään funktiolle. Eli muutamme tässä kopion sisältöä ja alkuperäisen taulukon osoite säilyy muuttumattomana. Yleisesti ottaen, aina kun välitämme funktiolle yksiulotteisen taulukon, voimme käyttää välitettyä osoitetta vapaasti haluamallamme tavalla. const-tyyppiset parametrit Joskus saattaa olla tarpeen varmistaa, että funktio ei vahingossa muuta sille välitetyn taulukon alkioita. Tällöin tulee käyttää const-avainsanaa parametrin tyypin yhteydessä. Jos esimerkiksi haluaisimme, että keskiarvo()-funktio ei muuttaisi ensimmäisen parametrinsä alkioita, voisimme kirjoittaa funktion seuraavasti: double keskiarvo(const double* taulukko, int lkm) double summa = 0.0; // Tähän lasketaan summa for(int i = 0 ; i < lkm ; i++) summa += *taulukko++; // Summataan taulukon alkiot return summa / lkm; // Palautetaan keskiarvo Nyt kääntäjä varmistaa, että taulukon alkioita ei muokata funktion rungossa. Luonnollisesti sinun tulee muuttaa myös funktion prototyyppiä vastaamaan uutta ensimmäisen parametrin tyyppiä; muista, että const-tyypit ovat aivan eri kuin muut kuin const-tyypit. Kun esittelet osoitinparametrin const-tyyppiseksi, kerrot kääntäjälle, että Kun tätä funktiota kutsutaan, se mihin osoitinparametri osoittaa, tulee käsitellä vakiona. Tästä on kaksi seurausta: kääntäjä varmistaa, että funktion rungon koodissa noudatetaan käskyäsi ja että et yritä muuttaa osoittimen osoittamaa tietoa. Se sallii myöskin funktiota kutsuttavan parametrillä, joka osoittaa vakioon. Huomaa, että ei ole mitään tarvetta esitellä tavallisen tyyppistä (kuten int) parametriä consttyyppiseksi. Koska arvoparametrien yhteydessä alkuperäisestä parametristä tehdään kopio funktiota kutsuttaessa, et pysty muuttamaan alkuperäistä arvoa funktion rungossa. 294

19 Moniulotteisen taulukon välittäminen funktiolle Ohjelmointi funktioiden avulla Edellä oleva huomioiden, moniulotteisen taulukon välittäminen funktiolle on varsin suoraviivaista. Jos olemme esitelleet kaksiulotteisen taulukon seuraavasti: double pavut[2][4]; Voisimme nyt kirjoittaa kuvitteellisen funktion tuotanto() prototyypin seuraavasti: double tuotanto(double pavut[2][4]); Olemme tässä eksplisiittisesti määritelleet taulukon kummatkin ulottuvuudet, mutta meillä ei ole mitään keinoa tarkistaa, että ensimmäisen ulottuvuuden koko on 2. Taulukkojen ensimmäisen ulottuvuuden koko ei ole osa taulukon tyyppiä, joten pavut-taulukon tyyppi on itse asiassa double[][4]. Kaikki taulukot, joiden toisen ulottuvuuden koko on 4, voidaan välittää tälle funktiolle parametrinä.! Miten kääntäjä tietää, että tämä rivi määrittelee parametrissä olevan kokoisen taulukon, eikä vain yksittäistä alkiota? Vastaus on yksinkertainen: et voi kirjoittaa taulukon yksittäistä alkiota parametriksi funktion otsikossa tai prototyypissä, mutta luonnollisestikin voit välittää funktiolle yksittäisen alkion. Funktio, jolle voidaan välittää parametrinä taulukon yksittäinen alkio, parametrin tyypin tulee olla sama kuin tämän alkion tyyppi. Taulukkomuotoa ei voi käyttää. Kun määrittelet funktion parametriksi moniulotteisen taulukon, sinun tulisi jättää ensimmäisen ulottuvuuden koko pois (ellet halua informoida, että funktion on tarkoitus toimia kiinteän kokoisen taulukon yhteydessä.). Funktio tarvitsee tällöinkin tiedon ensimmäisen ulottuvuuden koosta. Tähän voit käyttää samaa tapaa kuin aikaisemminkin: lisää toinen parametri, joka kertoo ensimmäisen ulottuvuuden koon: double tuotanto(double pavut[][4], int indeksi); Jos mietit voisitko korvata tämän lisäparametrin käyttämällä funktiossa sizeof()-funktiota taulukon koon selville saamiseksi, voin kertoa, että et voi niin tehdä. Funktion sizeof() käyttö funktion rungossa palauttaa sen osoittimen koon, jota taulukon nimi vastaa. Kokeillaan nyt kaksiulotteisen taulukon välittämistä funktiolle esimerkin avulla. Kokeile itse - Moniulotteisen taulukon välittäminen funktiolle Voimme toteuttaa tuotanto()-funktion, joka laskee sille välitetyn taulukon alkioiden summan: // Esimerkki Kaksiulotteisen taulukon välittäminen funktiolle #include <iostream> using namespace std; 295

20 C++ Ohjelmoijan käsikirja double tuotanto(double arvot[][4], int n); int main() double pavut[3][4] = 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ; cout << endl << "Tuotanto = " << tuotanto(pavut, sizeof pavut / sizeof pavut[0]) << endl; return 0; // Funktio, joka laskee kokonaistuotannon double tuotanto(double taulukko[][4], int lkm) double summa = 0.0; for(int i = 0 ; i < lkm ; i++) // Käydään läpi rivit for(int j = 0 ; j < 4 ; j++) // Käydään läpi rivin alkiot summa += taulukko[i][j]; return summa; Ohjelman tulostus on: Tuotanto = 78 Kuinka se toimii Funktion tuotanto() ensimmäinen parametri on taulukko, jossa on mielivaltainen määrä rivejä, joissa jokaisessa on neljä alkiota. Kun kutsumme funktiota, ensimmäinen parametri on taulukko pavut, jossa on kolme riviä. Toinen parametri saadaan jakamalla taulukon koko pituus (tavuissa) ensimmäisen rivin koolla. Tämä tietysti tarkoittaa taulukon rivien lukumäärää. Funktion laskenta suoritetaan yksinkertaisesti sisäkkäisissä for-silmukoissa, joista sisempi laskee yhden rivin alkiot ja ulompi toistaa sitä kullekin riville. Sellaisen funktion yhteydessä, jolla on parametrinä moniulotteinen taulukko, ei oikein ole järkevää käyttää osoitinmuotoista taulukon käsittelyä. Edellisessä esimerkissä, kun taulukko välitetään, välitetään osoite, joka osoittaa taulukkoon, jossa on neljä alkiota (rivi). Tämä ei johda helppoon osoittimen käsittelyyn ja silmukoiden sisällä oleva lause tulisikin muuttaa varsin monimutkaiseen muotoon: summa += *(*(taulukko+i)+j); Olen varma, että taulukkomuotoinen esitystapa on havainnollisempi ja yksinkertaisempi! 296

21 Viittausparametrit Ohjelmointi funktioiden avulla Viittaus on yksinkertaisesti toisen muuttujan peitenimi (alias). Kun määrittelet funktion parametrin viittaustyyppiseksi, funktiosi käyttää viittausmekanismia parametrin välityksessä. Kun funktiota kutsutaan, viittausparametriä ei kopioida, koska parametrin nimestä tulee alkuperäisen parametrin peitenimi. Aina kun parametrin nimeä käytetään funktion rungossa, käsitellään itse asiassa kutsuvan funktion alkuperäistä parametrin arvoa. Määritelläksesi parametristä viittausparametrin, kirjoitat & tyypin nimen perään. Esimerkiksi, jos haluat määritellä viittauksen int-tyyppiin, kirjoitat int&. Seuraava kaavio selventää, miten funktion kutsu viittausparametreillä toimii: Kutsuva funktio Funktio, jossa on viittausparametri int main() int numero = 20;... cout << muutase(numero);... return 0; Viittausparametri arvo alustetaan muuttujan numero arvolla, joten arvo:sta tulee numero:n peitenimi.. tämä viittaa numeroon suoraan Paluuarvon tyyppi on int, joten kopio, eli tässä tapauksessa numero:n kopio palautetaan kutsuvalle funktiolle. int muutase(int& arvo) arvo += 10; return arvo; Aina kun funktiota muutase() kutsutaan, viittausparametri, arvo, alustetaan alkuperäisellä parametrillä. Eli kun funktio muutase() on suorituksessa, arvo on peitenimi muuttujalle, joka sille välitettiin parametrinä, eli muuttujalle numero. Jos kutsut funktiota uudelleen eri muuttujalla, parametristä arvo tulee tämän muuttujan peitenimi. Funktion parametrin määrittelyllä viittaukseksi on kaksi pääseurausta. Ensinnäkin, alkuperäistä parametriä ei kopioida, joten sitä voidaan käsitellä funktiossa suoraan. Toiseksi, koska kopiointia ei suoriteta, funktion kutsu tapahtuu nopeammin. Nämä, sekä muutamat muut, ovat päällimmäiset asiat, joita meidän tulee miettiä, kun välitämme olioita funktiolle. Käsitellään nyt kuitenkin viittausparametrejä ensin tarkemmin. Lisätehokkuuden huumassa tietysti ryntäät määrittelemään kaikki funktiosi parametrit viittausparametreiksi. Tällöin on kuitenkin helppo unohtaa niiden toiminnan eräs asia: voit muokata alkuperäistä muuttujaa funktiossa ja viittauksen syntaksi tekee siitä vähemmän havainnollisen kuin jos käyttäisit osoittimia. Tässä piilee suuri virheiden vaara. Voit vahingossa muuttaa alkuperäisen muuttujan arvoa. Käytössä on turvallisempiakin tapoja muuttaa alkuperäisen muuttujan arvoa funktiossa. 297

22 C++ Ohjelmoijan käsikirja Funktio, jossa parametrinä osoitin Funktio, jossa viittauparametri int muutase(int* arvo) *arvo += 10; return *arvo; Funktiolle välitetään osoite, mikä selvästi kertoo, että funktiossa saatetaan muuttaa muuttujan arvoa. int muutase(int& arvo) arvo += 10; return arvo; Arvo välitetään funktiolle viittauksena; tämä ei mitenkään kerro, että muuttujan arvoa saatetaan muuttaa funktiossa. int numero = 20; cout << muutase(&numero); int numero = 20; cout << muutase(numero); Jos määrittelet parametrin, jonka sisältöä ajattelet muokata, osoittimeksi, funktiolle tulee välittää osoite ja kutsuvassa ohjelmassa on selvempää, että funktiossa saatetaan muuttaa muuttujan arvoa. Viittausparametrinä välitetty muuttuja on vain kyseisen muuttujan peitenimi, eikä muuttamisen mahdollisuus näy niin selvästi. Yllä oleva kaavio selventää näiden kahden tilanteen eroja. Kuinka sitten hyödynnämme tämän tehokkuuden ilman, että heikennämme parametrien turvallisuutta? Vastaus on const-tyyppisten viittausten käyttö. Tarkastellaan tätä seuraavalla esimerkillä. Kokeile itse - Viittausparametrit Kokeillaan yksinkertaista ohjelmaa, jossa käytetään funktiota suurempi(), joka palauttaa suuremman kahdesta luvusta. Käytämme tätä funktiota eri muodoissa, joilla havainnollistamme, kuinka viittausparametrien käyttö voi vaikuttaa funktion toimintaan. Tässä on ensimmäinen versio: // Esimerkki Viittausparametrien käyttö #include <iostream> using namespace std; int suurempi(int& m, int& n); int main() int arvo1 = 10; int arvo2 = 20; cout << endl << suurempi(arvo1, arvo2) << endl; return 0; // Funktio, joka palauttaa suuremman kahdesta kokonaisluvusta 298

23 Ohjelmointi funktioiden avulla int suurempi(int& m, int& n) return m > n? m : n; // Palauttaa suuremman arvon Tämän esimerkin tulostus on vain luku 20, kuten varmasti odotitkin. Kuinka se toimii Koska funktion suurempi() parametrit ovat viittausparametrejä, se käyttää muuttujien arvo1 ja arvo2 alkuperäisiä arvoja, kun sitä kutsutaan main()-funktiosta lauseella: cout << endl << suurempi(arvo1, arvo2) << endl; Jos et oikein usko tätä, niin kokeile lisätä funktion suurempi() runkoon seuraava lause, joka muuttaa toisen parametrin arvoa: int suurempi(int& m, int& n) n = 30; return m > n? m : n; // Palauttaa suuremman arvon Jos nyt tulostat muuttujan arvo2 arvon suurempi()-funktion kutsun jälkeen, huomaat, että sen arvo on muuttunut. Oletetaan, että olisimme halunneet verrata arvo1:tä vakioarvoon, esimerkiksi arvoon 15 ja sitten palauttaa suuremman arvon. Voisimme kokeilla lisätä seuraavan lauseen main()-funktioon: int main() int arvo1 = 10; int arvo2 = 20; cout << endl << suurempi(arvo1, arvo2) << endl; cout << endl << suurempi(arvo1, 15) << endl; return 0; Nyt ohjelma ei enää käänny. Kääntäjä ei salli viittauksen muodostusta vakioon 15, koska se tietää, että kutsuttavalla funktiolla on suora pääsy muuttujaan ja funktio saattaa muuttaa sitä. Tästä voimme muodostaa seuraavan päätelmän: Et voi välittää funktiolle parametrinä vakiota, jos kyseinen parametri on määritelty eiconst-tyyppisenä viittauksena. const-viittausten käyttö Pääsemme eroon edellä olleesta ongelmatilanteesta, jos määrittelemme funktion suurempi() parametrit const-viittauksiksi. Funktion prototyyppi olisi nyt: 299

24 C++ Ohjelmoijan käsikirja int suurempi(const int& m, const int& n); Nyt funktio toimii muuttujien ja vakioiden yhteydessä. Jos tarkoituksenasi ei ole muuttaa parametrinä välitettyä arvoa, voit aina määritellä parametrin const-viittaukseksi. Näin voimme suoraan käyttää alkuperäistä muuttujaa (eli vältämme kopioinnin), kääntäjä tarkistaa, ettemme yritä muuttaa niiden arvoa ja funktio toimii sekä muuttujien että vakioiden yhteydessä. Käyttämällä const-viittausta voimme yhdistää viittausparametrien paremman tehokkuuden arvoparametrien turvallisuuteen. Viittaukset vs. osoittimet Useimmissa tapauksissa viittausparametrien käyttö on suositeltavampaa kuin osoittimien käyttö. Viittausparametrit tulisi määritellä const-viittauksiksi aina kun mahdollista, koska tämä takaa alkuperäisten muuttujien turvallisuuden. Tietysti, jos tarkoituksenasi on muuttaa alkuperäisen muuttujan arvoa, et voi määritellä parametriä const-viittaukseksi, mutta kannattaa miettiä, olisiko osoitinparametri parempi ratkaisu. Kutsuvalle funktiolle on näin aina selvää, milloin funktio voi muuttaa muuttujia suoraan. Tärkeä ero osoittimen ja viittauksen välillä on se, että osoitin voi olla null, mutta viittauksen täytyy aina viitata johonkin. Jos parametri voi olla null, ainoa mahdollisuus on osoitinparametri. Luvussa 12 huomaamme, että viittausparametreillä on tiettyjä lisäominaisuuksia luokkien yhteydessä ja joissakin tapauksissa niillä voidaan saada aikaan tuloksia, jotka muuten olisivat mahdottomia. Viittausten esittely Viittauksia ei esiinny pelkästään funktion parametreissä. Viittaus voi olla olemassa myös sellaisenaan, toisen muuttujan peitenimenä. Oletetaan, että esittelemme muuttujan seuraavasti: long numero = 0; Voimme nyt esitellä viittauksen tämän muuttujaan seuraavalla esittelylauseella: long& rnumero = numero; //Esitellään viittaus muuttujaan numero Tyypin perässä oleva & ilmaisee, että esitellään viittausta, ja yhtäsuuruusmerkkien oikealla puolella olevaa muuttujaa numero käytetään alkuarvona. Täten rnumero on tyyppiä viittaus tyyppiin long. Aivan samoin kuin osoittimienkin kohdalla, voit sijoittaa &-merkin myös muuttujan nimen yhteyteen, joten voisimme kirjoittaa edellisen lauseen seuraavasti: long &rnumero = numero; //Esitellään viittaus muuttujaan numero Kääntäjä ei valita kumpaa näistä käytätkin; tässä kirjassa käytämme ensimmäistä muotoa. &-merkin käyttö viittauksen esittelyssä saattaa aluksi tuntua hieman hämmentävältä. Sen käyttö viittausten yhteydessä näyttää samanlaiselta kuin olemme nähneet aikaisemmin muuttujan osoitteen lukemisessa. Pienellä harjoituksella kuitenkin erotat nämä kaksi tilannetta. 300 Kun esittelet viittauksen, se tulee aina alustaa sen muuttujan nimellä, jonka peitenimi se on. Viittausta ei voi luoda alustamatta sitä. Lisärajoituksena on, että viittaus on kiinteä - et voi muuttaa viittausta, kun se kerran on esitelty; se on aina saman muuttujan peitenimi. Syy, miksi

25 Ohjelmointi funktioiden avulla funktion viittausparametri voi aina viitata eri muuttujaan, on se, että viittausparametri luodaan uudelleen ja alustetaan uudelleen jokaisella tämän funktion kutsulla. Viittausta voidaan aina käyttää alkuperäisen muuttujan nimen tilalla. Esimerkiksi: rnumero += 10; Tämä lause lisää muuttujan numero arvoon luvun 10, koska rnumero on viittaus siihen. Jotta varmasti huomaat eron, verrataan viittausta rnumero osoittimeen pnumero, joka on esitelty lauseella: long* pnumero = &numero; //Alustetaan osoitin osoitteella Tämä esittelee osoittimen pnumero ja alustaa sen muuttujan numero osoitteella. Muuttujan arvoa voidaan nyt kasvattaa esim. seuraavalla lauseella: *pnumero += 10; //Kasvatetaan arvoa osoittimella Tässä on merkittävä ero osoittimen ja viittauksen käytön välillä: osoittimen yhteydessä täytyy käyttää *-operaattoria, jotta osoitetun muuttujan sisältöön päästään käsiksi. Viittauksen kohdalla *-operaattoria ei tarvita. Viittaus on aivan kuin osoitin, jolle on jo sovellettu *-operaattoria, vaikka sitä ei voidakaan muuttaa viittaamaan toiseen muuttujaan. Viittaus on täydellinen vastine muuttujasta, johon se viittaa. Tässä oli kaikki, mitä meidän täytyy nyt käsitellä viittauksista. Aihe ei kuitenkaan pääty vielä tähän. Käytämme viittauksia runsaasti, kun aloitamme luokkien käsittelyn luvusta 12. main()-funktion parametrit Voit määritellä myös funktiolle main() parametrejä, jotka sitten syötetään komentoriville suorittaessasi ohjelmaa. Parametrien tyypit on standardisoitu: voit määritellä funktion main() joko ilman parametrejä, kuten olemme tähän saakka tehneet, tai voit määritellä main()-funktion muodossa: int main(int argc, char* argv[]) //main()-funktion koodi Ensimmäinen parametri, argc, on komentoriville syötettyjen merkkijonojen lukumäärä. Toinen parametri, argv, on taulukko, joka sisältää osoittimet jokaiseen komentorivillä syötettyyn merkkijonoon, mukaan lukien itse ohjelman nimi. Taulukon argv viimeinen alkio (eli argv[argc]) on aina 0 ja taulukon argv alkioiden lukumäärä on argc + 1. Katsotaan muutamaa esimerkkiä. Oletetaan, että suorittaaksesi ohjelman kirjoitat seuraavaa komentoriville: Omaohjelma Tässä tapauksessa argc on 1 ja argv[] sisältää kaksi alkiota. Ensimmäinen alkio sisältää merkkijonon Omaohjelma ja toinen alkio on