Lauseet ja lausekkeet imperatiivisissa ohjelmointikielissä Tässä dokumentissa käsitellään lauseiden ja lausekkeiden muodostamista sekä kontrollirakenteita imperatiivisissa ohjelmointikielissä. Esimerkeissä esiintyviä kieliä käsitellään yksityiskohtaisemmin mm. seuraavissa teoksissa: [Ker] (C-kieli), [Strou] (C++ -kieli), [Kor] (Pascal), [Kur] (Ada), [Arc] (C#), [Arn] (Java) ja [KLS] (FORTRAN). Maarit Harsu käsittelee vastaavia asioita kirjansa [Har] luvuissa 3 ja 5. 1. Lausekkeet Lausekkeet (expressions) ovat ohjelmointikielen peruselementtejä. Niiden avulla voidaan ohjata tietokoneen laskentaoperaatioita ohjelmointikielellä. Jokaisessa ohjelmointikielessä voidaan muodostaa lausekkeita yhdistelemällä operaattoreita ja operandeja. Lauseke palauttaa aina ohjelmaan jonkin arvon, joka saadaan evaluoimalla lauseke. Yleensä operaattorit ovat unaarisia (kohdistuvat yhteen operandiin) tai binäärisiä (kohdistuvat kahteen operandiin). Esimerkiksi operaattori - voi olla sekä unaarinen, jolloin -A vaihtaa muuttujan A arvon etumerkin, tai binäärinen, jolloin A-B palauttaa muuttujien A ja B arvojen erotuksen. Joissakin kielissä käytetään myös ternäärisiä, eli kolmeen operandiin kohdistuvia operaattoreita. Lausekkeen evaluoinnin ymmärtäminen on olennainen osa ohjelmointikielen tuntemusta. Lausekkeen operandit voivat olla vakioita, muuttujia tai funktiokutsuja. Lausekkeen evaluointi tarkoittaa sen arvon laskemista käyttäen lausekkeessa esiintyvien vakioiden ja muuttujien suoritushetkisiä arvoja. Aritmeettisten, matematiikasta peräisin olevien lausekkeiden automaattinen evaluointi oli jo ensimmäisten korkean tason ohjelmointikielten tavoitteena, onhan esimerkiksi FORTRAN lyhennys sanoista FORmula TRANslator (tai FORmula TRANslating system, [KLS] s. 6). Aritmeettisen lausekkeen evaluoinnin toteuttaminen vaatii operandien arvojen hakemisen ja operaatioiden soveltamisen näihin operandeihin. Tarvitaan luonnollisesti erilaisia sääntöjä, jotta lausekkeen arvo voidaan määrittää. Erityisesti pitää päättää operaattoreiden suoritusjärjestys, operaattoreiden assosiatiivisuus ja operandien arvojen evaluointijärjestys. Jotkin kielet, esimerkiksi C++ ([Strou], luku 11)
ja Ada ([Kur], kappale 5.2), sallivat ohjelmoijan uudelleenmääritellä (ylikuormittaa, overload) operaattoreita, ts. kirjoittaa oman operaationsa korvaamaan kielessä jo esiintyvä operaattori tai laajentaa sen sovellusaluetta. Java -kieleen ei tätä C++ -kielen ominaisuutta ole sisällytetty. Huolellisesti käytettynä operaattorin uudelleenmäärittely lisää koodin luettavuutta, mutta mikäli operaattori uudelleenmääritellään luonnottomasti, saattaa tulos olla päinvastainen. Funktion arvon evaluointi imperatiivisissa kielissä käyttää yleensä innokasta evaluointia (eager evaluation). Tämä tarkoittaa sitä, että funktion arvo evaluoidaan joka kerran sitä kutsuttaessa käyttämällä syöteargumenttien senhetkisiä arvoja. Funktionaalisissa kielissä saatetaan käyttää myös toisen tyyppistä periaatetta, laiskaa evaluointia (lazy evaluation). Funktion sivuvaikutuksiksi (side effects) sanotaan sen vaikutusta funktion parametreihin tai globaaleihin muuttujiin. Jos funktio muuttaa joko parametriensa tai globaalien muuttujien arvoja, on funktiolla sivuvaikutuksia. Erityisesti funktioiden sivuvaikutuksia samoissa lausekkeissa funktiokutsun kanssa esiintyviin muuttujiin on syytä varoa. Mitä tulostaa esimerkiksi seuraava C++ -ohjelma? int g_int; int main() { g_int = 0; int oddval = f(g_int) + g(g_int); printf("loppuarvo = %d g_int = %d\n", oddval, g_int); return 0; } int f(int y) { if(y < 10) g_int += 11; else g_int += 13; return g_int; } int g(int x) { if(x < 10) g_int = 15; else g_int = 5; return g_int; }
Lausekkeen evaluoinnissa käytettävien operaattoreiden suoritusjärjestys määräytyy kielen presedenssisääntöjen ja assosiaatiosääntöjen mukaan. Presedenssisäännöt säätelevät operaattoreiden keskinäistä suoritusjärjestystä (suoritetaanko kertolasku ennen yhteenlaskua jne.). Assosiaatiosäännöillä puolestaan määrätään, kumpi kahdesta presedenssiltään samanarvoisesta operaattorista suoritetaan ensin. Yleisesti presedenssisäännöt noudattavat matematiikasta tuttuja lakeja. Assosiaatiosääntönä on yleisimmin vasemmalta oikealle tapahtuva suorittaminen. Lähes kaikissa ohjelmointikielissä voidaan sulkumerkinnöillä vaikuttaa ohjelmallisesti suoritusjärjestykseen. Kaikissa ohjelmointikielissä on toteutettu aritmeettiset perusoperaattorit yhteenlasku (+), vähennyslasku (-), kertolasku (*) ja jakolasku (/). Joissakin kielissä on myös potenssiin korotukselle oma operaattorinsa, esimerkiksi FORTRANissa tämä on ** ([KLS], kappale 6.1.4). Pascal -kielessä on myös oma operaattorinsa div kokonaislukujen jakolaskulle, jonka tuloksena on kokonaisluku ([Kor], kappale 3.2). Yleisesti myös kokonaislukujen jakolaskussa syntyvälle jakojäännökselle on oma operaattorinsa, C, C++ ja Java -kielissä tämä on %, ja Pascalissa mod. Unaarisista operaattoreista mainittakoon vielä C, C++ ja Java -kielissä esiintyvien operaattoreiden ++ ja -- kaksi muotoa prefix ja postfix. Prefix-muodossa operaattori kirjoitetaan muuttujan eteen ja sitä sovelletaan muuttujaan ennen lausekkeen muuta evaluointia ja postfix-muodossa operaattori kirjoitetaan muuttujan jälkeen ja evaluointi tapahtuu vasta muun evaluoinnin jälkeen. Näin ollen esimerkiksi C-ohjelmassa int mytestvar = 0,myOtherVar = 1; mytestvar = myothervar++; muuttujan mytestvar arvoksi tulee 1 ja muuttujan myothervar arvoksi 2. Jos operaattori muutetaan prefix -muotoon int mytestvar = 0,myOtherVar = 1; mytestvar = ++myothervar; molempien muuttujien arvo on lauseen suorituksen jälkeen 2. Seuraavaan taulukkoon on koottu joidenkin kielien operaattoreiden presedenssisääntöjä:
Korkein postfix ++, -- Alhaisin C Java/C++ Ada FORTRAN Pascal prefix ++, -- unaarinen +, - *, /, % binäärinen +, - postfix ++, -- prefix ++, -- unaarinen +, - *, /, % binäärinen +, - Adan abs -operaattori on luvun itseisarvo. **, abs ** *, /, div, mod *, /, mod *, / (kaikki) +, - unaarinen +, - binäärinen +, - (kaikki) +, - Assosiaatiosäännöt samoille kielille ovat seuraavassa taulukossa: C Kieli C++/Java Pascal FORTRAN Ada Assosiaatiosääntö Oikealta prefix ++, --, unaarinen +, - Vasemmalta muut Oikealta ++, --, unaarinen +, - Vasemmalta muut Vasemmalta kaikki Oikealta ** Vasemmalta muut Vasemmalta kaikki paitsi ** ** on ei-assosiatiivinen Esimerkiksi potenssiinkorotuksen oikealta assosiatiivisuus tarkoittaa sitä, että FORTRANissa lauseke 2**3**2 saa arvon 512 (korotetaan ensin 3 potenssiin 2 = 9 ja
sitten 2 potenssiin 9). Jos tässä käytettäisiin vasemmalta assosiatiivisuutta, tuloksena oli 64 (2 potenssiin 3 on 8 ja 8 toiseen on 64). APL on sikäli erikoinen ohjelmointikieli, että siinä ei ole lainkaan operaattoreiden presedenssijärjestystä (ts. kaikki operaattorit ovat samanarvoisia) ja lausekkeen arvo määräytyy täysin assosiatiivisuussäännön nojalla. APL:ssä assosiatiivisuussääntö on oikealta vasemmalle kaikille operaattoreille. Joskus aritmeettisten lausekkeiden evaluoinnissa suoritetaan tyyppimuunnoksia, jotka voivat olla eksplisiittisiä (ohjelmoijan tekemiä) tai implisiittisiä (tapahtuvat automaattisesti). Aritmeettisia operaatioita voidaan suorittaa eri tietotyypeille, esimerkiksi kokonaisluku voidaan jakaa reaaliluvulla. Tällaisissa tapauksissa kielessä täytyy olla selkeät säännöt operaation tuloksen tyypistä ja siitä, minkä tyyppisinä operaatiossa esiintyviä operandeja käsitellään. Tällöin joudutaan usein tekemään pakotettuja tyypinmuunnoksia (coercion), koska yleensä binääriset operaatiot on määritelty vain saman tietotyypin operandeille. Joskus implisiittiset tyypinmuutokset voivat aiheuttaa yllätyksiä, esimerkiksi C -kielessä double osamaara; osamaara = 3/2; muuttujan osamäärä arvoksi tulee 1.0 eikä 1.5, kuten voisi kuvitella. Sama koskee C++ja Java-kieltä. Tämä johtuu siitä, että kääntäjä tulkitsee literaalit 3 ja 2 kokonaisluvuiksi ja suorittaa kokonaislukujen jakolaskun, jonka tulos on 1. Tämä sitten muunnetaan double-tyyppiseksi. Mikäli lauseke muutettaisiin muotoon osamaara = 3.0/2; kääntäjä tulkitsisi osoittajan liukuluvuksi, muuntaisi myös nimittäjän liukuluvuksi ja suorittaisi liukulukujen jakolaskun, jonka tuloksena olisi 1.5. Pascal -kielessä tällaiset ongelmat on vältetty niin, että jakolasku / tuottaa aina reaaliluvun ja kokonaislukujen jakolaskulle on oma operaattori div.
Useimmissa kielissä myös eksplisiittinen tyypinmuunnos on mahdollinen ja se tapahtuu erityisellä operaattorilla tai muistuttaa syntaksiltaan funktiokutsua. Esimerkiksi Java - kielessä voitaisiin varmistaa jakolaskun asianmukainen lopputulos int osoittaja = 3; int nimittaja = 2; double osamaara = (double)osoittaja/nimittaja; Myös C ja C++ -kielessä tyypinmuunnos tehdään samoin; C -pohjaisissa kielissä eksplisiittistä tyypinmuunnosta kutsutaan usein kastaukseksi (cast). C++-kielessä on myös neljä operaattoria (static_cast, dynamic_cast, reinterpret_cast, const_cast) eksplisiittistä tyypinmuunnosta varten. Näitä pitäisikin käyttää mieluummin kuin edellä mainittua tyyliä. Ada -kielessä eksplisiittinen tyypinmuunnos muistuttaa funktiokutsua: osamaara: FLOAT; osoittaja, nimittaja: INTEGER; BEGIN osoittaja := 3; nimittaja := 2; osamaara := FLOAT(osoittaja)/FLOAT(nimittaja); Eksplisiittinen tyypinmuunnos voi olla joko laajentava tai kaventava. Kaventava tyyppimuunnos on esimerkiksi muunnos double-tyypistä tyyppiin float Javassa. Laajentava olisi muunnos päinvastoin. Useimmiten tällaiset tyypinmuunnokset hyväksytään, joskus kääntäjä voi antaa kaventavasta tyypinmuunnoksesta varoituksen; kaventavia ja epäsovinnaisia tyypinmuunnoksia kannattaa käyttää harkiten koodissa.
Aritmeettisten lausekkeiden lisäksi ohjelmointikielissä voidaan muodostaa vertailulausekkeita ja loogisia lausekkeita. Vertailulauseke (relational expression) koostuu kahdesta operandista ja vertailuoperaattorista, joka vertaa operandien arvoja. Vertailulausekkeen arvo on looginen totuusarvo. Yleisimmissä kielissä käytettävät vertailuoperaattorit ovat Operaatio C, C++, Java Pascal FORTRAN Yhtäsuuri == =.EQ. Erisuuri!= <>.NE. Suurempi > >.GT. Pienempi < <.LT. Suurempi tai yhtäsuuri >= >=.GE. Pienempi tai yhtäsuuri <= <=.LE. Vertailuoperaattorien presedenssi on kaikissa kielissä alhaisempi kuin aritmeettisten operaattoreiden, joten aritmeettisten lausekkeiden vertailussa laskutoimitukset suoritetaan ensin, esimerkiksi jos a = 8 ja b= 4 lausekkeen a + 5 < 3*b; arvo on epätosi. Looginen lauseke eli totuusarvolauseke (Boolean expression) koostuu totuusarvotyypin muuttujista ja vakioista sekä vertailulausekkeista ja totuusarvooperaattoreista (Boolean operators). Loogiselle lausekkeelle lasketaan propositiologiikan mukaan totuusarvo, joko tosi tai epätosi.
Totuusarvo-operaattoreiden presedenssien suhde aritmeettisiin ja vertailuoperaattoreihin on yleisimmin seuraava: Looginen negaatio on korkeimmalla presedenssitasolla, Aritmeettiset operaattorit, Vertailuoperaattorit, Looginen XOR, Looginen JA, Looginen TAI. Negaatio-operaattori, looginen JA ja looginen TAI ovat useissa kielissä (esimerkiksi Pascalissa) NOT, AND ja OR. Java, C ja C++ -kielissä operaattorit ovat!,&& ja. Java ja C++ -kielissä on lisäksi operaattori ^ poissulkevalle taille (exclusive or). Pascal-kieli poikkeaa yllämainitusta operaattoreiden presedenssijärjestyksestä, sillä Pascalin vertailuoperaattorit ovat alemmalla tasolla kuin loogiset operaattorit, joista AND on samalla tasolla kertolaskuoperaattorin kanssa ja OR yhteenlaskuoperaattorin kanssa ([Kor], kappale 4.3). Näin ollen lauseke a < 10 OR b > 15; ei Pascalissa käänny, vaan se on esitettävä muodossa (a < 10) OR (b > 15); C-kieli on nykyisistä imperatiivisista ohjelmointikielistä sikäli erikoinen, että siitä puuttuu looginen tietotyyppi ja mikä tahansa numeerinen arvo voidaan tulkita totuusarvoksi tosi jos se on erisuuri kuin 0 ja totuusarvoksi epätosi jos se on 0. Tämä johtaa siihen, että kielellä voidaan kirjoittaa varsin kummallisen näköisiä vertailulausekkeita, esimerkiksi int x=2,y=1,z=0,u,v; u = y==z < x; v = x < y < z;
missä muuttujan u arvo sijoituksen jälkeen voi riippua kääntäjästä, mutta on yleisimmin 1. Muuttujan v arvoksi tulee aina 0. Ominaisuus heikentää kielen luettavuutta ja saattaa vaikuttaa myös luotettavuuteen. Lausekkeen oikosulkuevaluointi (short-circuit evaluation) tarkoittaa sen arvon määräämistä ennen kuin sen kaikkien operandien arvoja on määrätty. Esimerkiksi, jos muuttujalla x on arvo 11, lausekkeen (x-11) * (z + 1); ei riipu muuttujan z arvosta. Näin ollen oikosulkuevaluointia käyttämällä voitaisiin jättää laskematta lausekkeen z+1 arvo. Useissa kielissä oikosulkuevaluointia sovelletaan loogisiin lausekkeisiin, esimerkiksi - jos oikosulkuevaluointia käytetään - Pascal-kielinen lauseke (a < 25) AND (b > 10) saa aina totuusarvon epätosi, mikäli a on suurempi tai yhtäsuuri kuin 25. Tässä tapauksessa voidaan toinen vertailu jättää tekemättä. Oikosulkuevaluointia voidaan käyttää hyväksi yksinkertaistamaan koodia, esimerkiksi koodi a:=10;b:=0; IF (b<>0) AND (a/b > 2) THEN BEGIN writeln ('a = ',a, 'b = ', b, 'a/b =', a/b); END; tuottaa ilman oikosulkuevaluointia nollalla jakamisen, mikäli b = 0. Oikosulkuevaluointia käytettäessä jakolaskua a/b ei suoriteta jos b = 0. Tosin Pascal - kielen standardissa ei pakoteta käyttämään oikosulkuevaluointia; useissa toteutuksissa se kuitenkin on käytössä. Sen sijaan C, C++ ja Java -kielissä käytetään loogisten lausekkeiden evaluoinnissa aina tätä menetelmää ([Seb], kappale 7.6), samoin C#:ssa. Aritmeettisten lausekkeiden evaluoinnissa ei yleensä käytetä oikosulkumenetelmää.
2. Lauseet Ohjelman voidaan ajatella koostuvan primitiivisistä eli atomisista lauseista sekä näitä yhdistelemään tarkoitetusta ohjauslauseista (kontrollilauseista). Yhdessä peräkkäisyyden (kompositio) kanssa näiden avulla muodostetaan kaikki kielen ohjausrakenteet. Primitiivisiä lauseita ovat sijoituslause, aliohjelmakutsu ja tyhjä lause. Ohjelmointikielessä on jotenkin erotettava lauseet toisistaan. Yleisin nykyään käytetty tapa on käyttää erikoismerkkiä päättämään lause. Pascalissa erikoismerkkiä käytetään erottamaan lauseet (joten viimeinen lause ei tarvitse mitään erikoissymbolia loppuunsa) ja FORTRANissa rivinvaihto päättää lauseen samoin kuin Pythonissa. Lisäksi on joitakin kieliä (esimerkkinä CLU), joissa kielen syntaksi on suunniteltu niin, ettei lauseiden erotin- tai lopetusmerkkiä tarvita. Aliohjelmakutsuihin palataan myöhemmin, tyhjää lausetta käytetään tapauksissa, joissa kielen syntaksin takia on oltava lause, mutta ohjelmoija ei halua mitään toimintoa suoritettavaksi. Tässä käsitellään tarkemmin sijoituslausetta ja ohjauslauseita. Sijoituslause (assignment) on imperatiivisen ohjelmoinnin perusta, sijoituslauseella mallinnetaan von Neumannin koneen muistin manipulointia. Sijoituslauseen avulla ohjelmoija sitoo dynaamisesti muuttujan tunnisteen tietokoneen muistipaikassa olevaan arvoon. Useimmiten kielen sijoitusoperaattorina käytetään yhtäsuuruusmerkkiä =, Pascalissa ja Adassa yhdistelmää :=. Sekaannusten välttämiseksi kielten vertailuoperaattori eroaa sijoitusoperaattorista. PL/I -kielessä symbolit ovat samat, mitä ei voi pitää kielen luettavuuden ja luotettavuuden kannalta hyvänä ratkaisuna. Lisäksi PL/I salli sijoittaa useampaan muuttujaan saman arvon tyyliin EKA, TOKA = 0 Tämän jälkeen sekä muuttujan EKA että TOKA arvo on 0; tämäkin huonontaa kielen luettavuutta ja luotettavuutta. C-, C++- ja Java-kielissä voidaan käyttää kahta unaarista operaattoria sijoituslauseena, nimittäin ++ ja --. Ohjelmassa rivi luku++; (tai ++luku;) tarkoittaa sijoitusta
luku = luku+1; Operaattoreista on prefix- ja postfix-muodot, mikä tarkoittaa sitä, että postfix - muodossa lisäys tapahtuu vasta lausekkeen evaluoinnin jälkeen, mikäli operaattori esiintyy lausekkeessa ja prefix-muodossa ennen lausekkeen evaluointia. Siten prefix - muodossa int ekaluku, tokaluku = 3; ekaluku = --tokaluku; muuttujan ekaluku arvoksi tulee 2, mutta postfix -versiossa int ekaluku, tokaluku = 3; ekaluku = tokaluku--; muuttujan ekaluku arvoksi tulee 3. Lauseiden int tokaluku,luku = 3; tokaluku = luku++ + ++luku; jälkeen tokaluku saa arvon 8. Aina ALGOL68:sta lähtien moniin kieliin on sisällytetty yhdistettyjä sijoitusoperaattoreita, joita käyttäen samaan muuttujaan sijoitettava arvo voidaan kirjoittaa lyhemmin. Esimerkiksi C, C++ ja Java -kielissä voidaan muuttujalle tehdä binäärisiä operaatioita seuraavalla tavalla: Lause summa += luku; on lyhennysmerkintä lauseelle ja lause lauseelle summa = summa + luku; osamaara /= luku; osamaara = osamaara/luku;
C, C++, C# ja Java sallivat ehdollisten lausekkeiden käyttämisen. Ehdollinen lauseke on muotoa <boolean_expression>? <expression1> : <expression2> Lauseke saa lausekkeen <expression1> arvon, mikäli <boolean_expression> on tosi, muussa tapauksessa lausekkeen <expression2> arvon. Javassa ja C#:ssa lauseke ei toimi itsenäisenä lausekkeena, vaan sitä on käytettävä sijoituslauseessa, ts. z = x == 0? (y=1) : (y=100); on sallittu kaikissa neljässä kielessä, mutta x == 0? (y=1) : (y=100); ainoastaan C:ssä ja C++:ssa. Ainakin C-, C++-, C#- ja Java-kielissä sijoituslause on myös lauseke, ts. se palauttaa ohjelmaan arvon, joka on sama kuin kohdemuuttujaan sijoitettu arvo. Tästä syystä sijoituslause voi esiintyä myös operandina lausekkeessa, esimerkiksi int x,y,z = 5; x = y = z; sijoittaa muuttujan z arvon sekä muuttujaan x että y. Tämä mahdollistaa myös melko kompaktin koodin kirjoittamisen, esimerkiksi C-kielinen lause while( *a++ = *b++); kopioi merkkijonon b jonoon a. Kielen luettavuutta tällainen ohjelmointityyli ei ainakaan lisää. Yleensäkin sijoituslauseen käyttäminen operandina lisää lausekkeisiin sivuvaikutuksia, jotka heikentävät kielen luettavuutta. Luotettavuuskin heikkenee, etenkin C-kielessä, jossa ei tunneta loogista tietotyyppiä. Näin ollen esimerkiksi ehdollinen toiminto if(a == b) { jne
muuttuu helposti kirjoitusvirheen seurauksena muotoon if(a = b) { jne jolloin ohjelman merkitys muuttuu täysin, mutta on kuitenkin hyväksyttävää koodia. Ohjauslauseilla (control statements) toteutetaan kielen ohjausrakenteet. Periaatteessa ohjelmointikielessä tultaisiin toimeen hyvin vähillä ohjausrakenteilla: Muuttujien arvojen yhtäsuuruuden testaaminen ja while-toistorakenne riittävät minkä tahansa yleensä kirjoitettavissa olevan ohjelman kirjoittamiseen. Ohjelmoijan työn helpottamiseksi kuitenkin useimmissa kielissä on huomattavasti rikkaampi ohjauslauseiden joukko. Yleisesti käytetyt ohjausrakenteet ovat muotoutuneet 1960- ja 1970- lukujen taitteessa syntyneen rakenteisen ohjelmoinnin (structured programming) kehittymisen myötä. Tällöin nimittäin havaittiin, että ohjelmoinnin tarpeisiin sinänsä riittävät peräkkäisyys ja ehdollinen hyppykäsky johtivat suuremmissa ohjelmissa helposti lukukelvottomaan ja epäluotettavaan koodiin. Rakenteisen ohjelmoinnin ihanteiden mukaan ohjelma koostuu sisäkkäisistä rakenteista, joilla kullakin on yksi tulo- ja poistumiskohta. Tämä helpottaa koodin ymmärtämistä ja virheiden etsimistä mikäli sellaisia esiintyy. Jotta erilaiset rakenteet voidaan luontevasti toteuttaa, on ohjelmointikielessä syytä olla useammanlaisia valinta- ja toistolauseita. Useissa nykykielissä (esimerkiksi Java) hyppykäsky (goto) on jätetty kokonaan pois. Ohjausrakenteiden käytön helpottamiseksi on useimmissa kielissä mahdollista koota joukko (peräkkäisiä) lauseita yhdeksi kokonaisuudeksi. Tällaista kokonaisuutta kutsutaan yhdistetyksi lauseeksi (compound statement) mikäli sen sisällä ei sallita esitellä uusia muuttujia, tai lohkoksi (block) jos uusien muuttujien esittely sallitaan. Yhdistetyt lauseet esiintyivät ensimmäiseksi ALGOL 60:ssä, FORTRAN-kielessä tällaista mahdollisuutta ei alkujaan ollut. Pascalissa voidaan rakentaa yhdistettyjä lauseita mutta ei lohkoja, sen sijaan C-pohjaiset kielet sallivat lohkot. Yleinen piirre nykykielten ohjausrakenteissa on, että niiden säätelemän koodin suoritus alkaa aina ensimmäisestä lauseesta: katsotaan että useamman tulokohdan sallimisen riskit (luettavuuden heikkeneminen, monimutkaisuuden lisääntyminen) ovat huomattavasti suuremmat,
kuin se joustavuusetu mikä tällä saavutettaisiin. Sen sijaan ohjausrakenteen sisältä voidaan yleisesti poistua useammasta kohdasta. Valintalauseet (selection statements) voidaan jakaa kahden vaihtoehdon lauseisiin ja monivalintalauseisiin. Tähän väliin sijoittuu FORTRANin ensimmäisissä versioissa toteutettu aritmeettinen valintalause (ks. [KLS] kappale 13.1), joka oli muotoa IF (ARITMEETTINEN LAUSEKE) N1, N2, N3 Tässä N1, N2 ja N3 ovat viitteitä, joiden osoittamiin kohtiin hypätään lausekkeen arvon perusteella: Jos lauseke saa positiivisen arvon, hypätään kohtaan N1, nollalla kohtaan N2 ja negatiivisella arvolla kohtaan N3. Yleensä lausetta käytetään muodossa: IF (C) 10, 20, 30 10 GO TO 40 20 GO TO 40 30 40 Kuitenkin hyppykohdat voivat olla missä tahansa ohjelmassa, mikä on suuri ongelma ohjelman luettavuuden kannalta ja siten käytettynä myös altistaa virheille. Sittemmin FORTRANissa siirryttiin käyttämään yhden vaihtoehdon valintalausetta IF (LOOGINEN LAUSEKE) LAUSE missä LAUSE oli jokin yksittäinen ohjelmalause (yleensä hyppykäsky) eikä esimerkiksi toinen IF -lause. Myöhemmin FORTRAN -kielessä valintalausetta on edelleen modernisoitu, FORTAN 77:ssä voidaan käyttää niin sanottua lohko-if -rakennetta, jonka muoto on
IF (EHTO) THEN... [ELSE IF (EHTO2) THEN... ELSE IF (EHTO3) THEN...... ELSE...] END IF Useimpien nykykielten valintalause pohjautuu ALGOL 60 -kielen kahden vaihtoehdon valintalauseeseen: if (<looginen_lauseke>) then <lause1> [else <lause2>] Käyttämällä yhdistettyjä lauseita näin saadaan ohjelmoitua joustavia valintarakenteita. Useimmissa kielissä on myös sama syntaksiongelma, joka johtuu siitä, että if-lauseella ei ole loppulekseemiä. Koska else -osa on vapaaehtoinen, syntyy ns. roikkuvan elsen ongelma: sisäkkäisistä if - else -rakenteista ei voida varmuudella sanoa, mihin if - lauseeseen else kuuluu. Esimerkiksi C -kielessä (jossa if lauseessa samoin kuin C++:ssa ja Javassa then -sanasta ei käytetä) if(x < 0) if (y > 10) x = 10; else x = 20; Lauseen syntaksista sinänsä ei voida päätellä, onko sijoitus x = 20 tarkoitus tehdä, jos (x>= 0) vai jos (x < 0 ja y <= 10). Ongelma on ratkaistu määrittelemällä kielten semantiikka niin, että else liittyy aina lähimpään if -lauseeseen. Näin ollen ylläolevassa koodissa sijoitus x= 20 tehdään, jos (x < 0 ja y < = 10). Tämä ongelma altistaa tahattomille virheille: ongelma voidaan välttää käyttämällä aina yhdistettyjä lauseita if - rakenteissa. Pascal -kielessä on vastaava ongelma, mutta Pascal -kieleen pohjautuvasta Adasta ongelma on poistunut, koska Adassa if -lause päätetään end if -merkinnällä (ks. [Kur], kappale 3.5)). Adan valintalause on muotoa:
if ehto then lause; lause;... [else lause; lause;... ] end if; Näin ollen Adassa esimerkkikoodi olisi kirjoitettava joko tai if(x < 0) then if (y > 10) then x := 10; end if; else x := 20; end if; if(x < 0) then if (y > 10) then x := 10; else x := 20; end if; end if; ja kummassakin tapauksessa voidaan päätellä, kumpaan if -lauseeseen else -osa kuuluu. Yleisimmin nykyään käytetty monivalintarakenne pohjautuu alkuaan ALGOL-W -kieleen sisältyvään case -lauseeseen. Alkuperäinen muoto oli C.A.R. Hoaren esittämä case <kokonaisluku_lauseke> of begin <lause_1>; <lause_2>;... <lause_n> end
Lausekkeen arvon perusteella valitaan suoritettava lause, arvo 1 valitsee lauseen lause_1 jne. Suoritettavat lauseet voivat olla yhdistettyjä lauseita. Samankaltainen valintarakenne on käytössä useissa yleisissä kielissä - valintalausekkeena saa yleensä olla mikä tahansa lueteltavaa tyyppiä oleva lauseke. Pascal -kielen case -lause on muotoa case lauseke of const_list_1: <lause_1>; const_list_2: <lause_2>;... const_list_n: <lause_n> end missä lauseke on lueteltavaa tyyppiä ja lauseet voivat olla yhdistettyjä lauseita. Mikäli lausekkeen arvo on sama kuin jokin listoissa luetelluista vakioarvoista const_list_1, const_list_2 jne., vastaava lause suoritetaan ja tämän jälkeen kontrolli siirtyy case - lauseen jälkeiseen lauseeseen. Alkujaan Pascalissa ei lainkaan määritelty, mitä aiheutuu siitä, että lausekkeen arvo ei ole mikään luetelluista arvoista. Useimmat Pascal - toteutukset sallivat oletustoiminnon käyttämällä else -rakennetta, ts. case lauseke of const_list_1: <lause_1>; const_list_2: <lause_2>;... const_list_n: <lause_n> else <oletus_lause> end jolloin oletus_lause suoritetaan, mikäli lausekkeen arvoa ei löydy luetelluista arvoista. C-pohjaisissa kielissä monivalintalauseen muoto on switch(<lauseke>) { case vakio_1: <lause_1>; case vakio_2: <lause_2>; case vakio_n: <lause_n>; [default: <oletus_lause>] } Myös tässä tapauksessa lauseke saa olla mitä tahansa lueteltavaa tyyppiä. Lauseen semantiikka on seuraava: lausekkeen arvoa verrataan lueteltuihin vakioihin ja kun arvo löydetään, suoritetaan listan lauseita tästä lauseesta alkaen, kunnes kohdataan break -
lause tai kontrollirakenne loppuu. Kummassakin tapauksessa kontrolli siirtyy rakennetta seuraavaan lauseeseen. Tällainen break-lauseen käyttö lisää joustavuutta varsinkin, koska case-osissa ei voi luetella arvoja. Toisaalta se altistaa myös ohjelmointivirheille, joita voi olla vaikea havaita testauksessa. Jostakin case-osasta breakin unohtaminen voi johtaa ohjelmassa harvoin esiintyviin virhetilanteisiin. Tietokoneen todellinen voima on sen kyvyssä toistaa nopeasti operaatioita. Sen vuoksi toisto on tietokoneohjelmoinnin oleellisimpia rakenteita. Toisto voi perustua iteraatioon tai rekursioon; iteraatio on jonkin lausejoukon useamman kertaista toistamista, kun taas rekursio on aliohjelman sisäkkäistä kutsumista. Imperatiivisissa kielissä iteratiivinen toisto on yleisempää ja tehokkaampaa kuin rekursiivinen; toki myös rekursio on mahdollinen useimmissa imperatiivisissa kielissä. Funktionaalisessa ohjelmoinnissa taas rekursio on luonnollisempi toiston muoto. Tässä tutustutaan imperatiivisten kielten iteratiivisiin toistorakenteisiin. Toistorakenteet voidaan jakaa, hieman väljästi, määrättyihin ja määräämättömiin toistolauseisiin. Määrätyssä toistolauseessa jokin laskuri kontrolloi toistoa ja toistojen lukumäärä tiedetään etukäteen; määräämättömässä toistolauseessa puolestaan jokin looginen ehto kontrolloi toistoa ja toistojen lukumäärää ei välttämättä tiedetä ennalta. Toistorakenteen kontrolloimaa ohjelmalohkoa sanotaan usein silmukaksi (loop). Määrätyissä toistolauseissa silmukkalaskuri (silmukkamuuttuja,loop variable) kontrolloi silmukan päättymistä. Silmukkamuuttujan alkuarvo (initial value), loppuarvo (terminal value) ja askel (stepsize) ovat silmukkaparametreja (loop parameters), joiden arvot on silmukkaan tultaessa jotenkin asetettava. Määrättyä silmukkarakennetta suunniteltaessa on otettava monia seikkoja huomioon: Mikä on silmukkamuuttujan tyyppi ja näkyvyysalue? Mikä on silmukkamuuttujan arvo (jos yleensä on olemassa) silmukan päättymisen jälkeen? Saako silmukkamuuttujan arvoa muuttaa silmukan sisällä ja vaikuttaako muutos silmukan suorituksen lopettamiseen? Evaluoidaanko silmukkaparametrit ainoastaan kerran vai joka iteraatiokerralla?
FORTRANin varhemmissa versioissa toistorakenteen muoto oli DO <viite> <muuttuja> = <alkuarvo>,<loppuarvo> [,<askel>] Tässä silmukan rajaa viite, ts. esimerkiksi luvut 1,3,5,7 ja 9 tulostava silmukka voitaisiin kirjoittaa DO 100 I = 1,10,2 PRINT *,I 100 CONTINUE FORTRANissa yleensä aina kirjoitetaan silmukan viimeiseksi käskyksi CONTINUE, joka ei tee mitään operaatiota. FORTRANin versiossa 77 silmukkamuuttuja sai olla kokonaisluku- tai reaalilukutyyppiä, mutta kielen versiossa 90 silmukkamuuttujat rajattiin kokonaislukutyyppisiksi. Muutenkin tässä versiossa muutettiin DO-silmukan rakennetta hieman. Tässä tarkoitetaan varhaisempien versioiden toistorakenteita FORTRANista puhuttaessa. FORTRANissa ei saa muuttaa silmukkamuuttujan arvoa silmukan sisällä ja silmukkamuuttujan arvoksi jää sille viimeksi määritelty arvo. FORTRANissa silmukkaparametrit evaluoidaan kerran silmukkaan tultaessa ja näitä käyttäen lasketaan silmukan kierrosluku. FORTRANissa siis aina määrätään etukäteen silmukan suorituskerrat. ALGOL 60:ssä pyrittiin joustavuuteen for -silmukkaa määriteltäessä, tässä kielessä silmukan rakenne on seuraava: <for_stmt> ::= for var := <list_elemt> {, <list_elemt>} do <statement> <list_elemt> ::= <expression> <expression> step <expression> until <expression> <expression> while <Boolean_expr> ALGOL 60 siis yhdistää loogisen ja laskuriin perustuvan toistorakenteen. Tämä johtaa kuitenkin siihen, että on mahdollista kirjoittaa oikeaoppisia, mutta hyvin monimutkaisia silmukkaehtoja. Tällöin kielen luettavuus heikkenee. Esimerkiksi seuraavat ovat mahdollisia toistorakenteita ALGOL 60:ssä for laskuri := 1,3,5,7 do summa := summa + laskuri;
for laskuri := 1 step 2 until 7 do summa := summa + laskuri; Nämä ovat selkeitä ja niissä laskuri käy samat arvot läpi, mutta yhdistelemällä sallitusti ehtoja, voidaan kirjoittaa silmukka for laskuri := 1,15,9 step 2 until 17, 2 * laskuri while laskuri < 150, -5, 22 do summa := summa + laskuri; mitä ei voida pitää selkeän koodin malliesimerkkinä, sillä koodia joutuu tutkimaan hetken, ennen kuin selviää, että laskurin arvot 1,15,9,11,13,15,17,34,68,136,-5,22 käydään läpi silmukassa. Lisäksi ALGOLin kaikki silmukkaparametrit evaluoidaan jokaisella silmukan suorituskerralla: näin saataisiin vielä vaikeammin hallittavia silmukoita muuttamalla esimerkiksi askelta ja ylärajaa silmukan sisällä. Pascal -kielen for -lause on sen sijaan yksinkertainen: for var := alkuarvo (to downto) loppuarvo do <statement> Askel on aina kooltaan 1 ja se tehdään joko ylös- tai alaspäin. Silmukkamuuttujan on oltava lueteltavaa tyyppiä; muuttuja on normaali muuttuja, jonka näkyvyysalue määräytyy kuten muuttujien yleensäkin. Silmukkamuuttujan arvo silmukan päättyessä on epämääräinen. Alkuarvon ja loppuarvon evaluointi tapahtuu ainoastaan kerran, joten näiden muuttaminen (mikäli riippuvat muuttujista) silmukan sisällä ei vaikuta toistokertojen määrään. Silmukkalaskurin arvoa ei saisi muuttaa silmukan sisällä, yleensä Pascalissa ei kuitenkaan tarkisteta tätä ja voi olla mahdollista vaikuttaa silmukan suoritukseen muuttamalla laskurin arvoa kesken silmukan. Tämä ei kuitenkaan ole suositeltavaa, koska tulokset saattavat olla erilaisia eri järjestelmissä. C-pohjaisten kielten for -lause on erittäin joustava, se on nimittäin muotoa for(lauseke_1;lauseke_2;lauseke_3) lause; Tässä yhteydessä varsinaisesta silmukkamuuttujasta ei voida puhua. C-kielessä lause toimii seuraavasti: Lauseen ensimmäinen lauseke suoritetaan ainoastaan kerran, ennen
silmukan ensimmäistä suorittamista. Toinen lauseke kontrolloi silmukan päättymistä; lauseke_2 evaluoidaan ennen jokaista silmukan kierrosta ja mikäli tuloksena on nollasta poikkeava arvo, silmukan seuraava kierros suoritetaan. Huomaa, että lauseke voi olla useiden lausekkeiden muodostama lista (ks. [Ker], kappale 3.5), jolloin sen arvo on viimeisen lausekkeen arvo. Siis for(i = 12; x = 0, y = 1; i++) { printf("luuppi\n"); } määrittelee C-kielessä ikuisen silmukan. Kolmas lauseke (lauseke_3) evaluoidaan jokaisen kierroksen jälkeen. C++ -kielen for -lause eroaa C -kielen lauseesta kahdella tavalla: C++:ssa voidaan käyttää toisena lausekkeena myös loogisia lausekkeita (mikä ei varhaisemmassa C-kielessä onnistu, koska C ei tunne loogista tietotyyppiä) ja C++kielessä ja nykyään myös C-kielessä voidaan lisäksi esitellä muuttujia lausekkeissa. Näin ollen for(int i = 0; i < 12; i++) { // SILMUKKA } on sallittu C++ -kielessä, mutta ei C-kielessä ennen sen versiota C99. Javan for -lause on muuten samanlainen kuin C++ -kielen, mutta Javassa toisen lausekkeen on oltava looginen lauseke. Lisäksi Java ei salli lausekelistaa toisena lausekkeena kuten C++. Siis bool bb = true, ba = false; for(int i = 0; bb = true, ba = false ; i++) { // SILMUKKA } kelpaa C++ :ssa mutta boolean bb = true, ba = false; for(int i = 0; bb = true, ba = false ; i++) { // SILMUKKA }
ei käy Javassa. C# noudattaa samaa käytäntöä kuin Java. Kaikissa mainituissa C- pohjaisissa kielissä for -silmukan lausekkeet voivat olla tyhjiä, esimerkiksi for(;;) { // SILMUKKA } määrittelee ikuisen silmukan, koska tyhjänä toinen lauseke katsotaan todeksi. C- tyyppisessä for-lauseessa kaikkia silmukkaparametreja voidaan muuttaa silmukan sisällä. Kannattaa muistaa, että kolmas lauseke suoritetaan joka kerran silmukan suorittamisen jälkeen, joten esimerkiksi silmukan for(int i = 0; i <= 12; i++) { // SILMUKKA } jälkeen muuttujan i arvo on 13. C-kielessä, kuten myös C++ -kielessä, voidaan tehdä hyppykäsky keskelle silmukkaa, millä voi kuitenkin olla omituisia seurauksia, joten näin ei pitäisi koskaan menetellä. Python-kielen for-silmukka on muotoa for <target> in <object>: <lauseet> [else: <lauseet>] missä object on jonkinlaisen iteroitava olio, jonka arvoja muuttuja target saa yksi kerrallaan. Vapaaehtoisen else-osan lauseet suoritetaan silmukan lopuksi, ellei silmukassa suoriteta break-lausetta. Määräämättömissä toistolauseissa lopetusehtona toimii jokin looginen ehto, eikä toistokertoja välttämättä tiedetä ennakolta; useimmissa kielissä on toteutettu erilaisia rakenteita tällaisille toistoille. Itse asiassa ALGOL 60- kielen toistolausekin on tällainen rakenne. Sama koskee C-pohjaisia kieliä, vaikka C-kielen for-lauseen päätarkoitus saattaa ollakin laskurisilmukkana toimiminen. Määräämättömät toistolauseet ovat
rakenteeltaan yksinkertaisempia, joten niiden problematiikka on helpompi kuin toistolauseen. Tällaisen rakenteen suunnittelussa huomioon pitää ottaa lähinnä seuraavat kysymykset: Testataanko ehto ennen silmukan suorittamista (alkuehtoinen toisto, pretest) vai sen jälkeen (loppuehtoinen toisto, posttest)? Onko määräämätön toistolause määrätyn toistolauseen erikoistapaus vai erillinen lause? ALGOL 60:ssä kaikki toistorakenteet toteutetaan samalla for -lauseella, joka on rakenteeltaan monimuotoinen ja -mutkainen. FORTRANissa ei ole lainkaan loogista toistolausetta, toistolauseet on toteutettava DO -silmukkaa ja hyppykäskyjä käyttäen. Java, C, C++ ja C# sisältävät toistolauseet sekä alku- että loppuehtoiselle toistolle. Alkuehtoinen muoto on while(lauseke) lause; ja loppuehtoinen do lause; while(lauseke); Loppuehtoisen toiston lause suoritetaan ainakin kerran, vaikka lauseke olisikin aluksi epätosi. (C:ssä lauseke on jokin aritmeettinen lauseke tai lausekkeiden muodostama lista, Javassa lausekkeen on oltava looginen lauseke eikä listaa sallita). Myös Pascal -kielessä on sekä alkuehtoinen että loppuehtoinen toisto mahdollinen; Pascalissa alkuehtoinen toisto on WHILE ehto DO lause;
ja loppuehtoinen REPEAT Lause1; Lause2; UNTIL ehto; Pascalissa loppuehtoisen toiston lopetuslogiikka on käänteinen C-kieleen verrattuna, ts. lauseita toistetaan, kunnes ehto tulee todeksi. Toinen erikoinen seikka tässä toistorakenteessa on, että silmukassa sallitaan peräkkäisiä lauseita (ei tarvitse käyttää koottua lausetta), kun tämä yleensä ei ole mahdollista Pascalin muissa rakenteissa. Tämä heijastaa ortogonaalisuuden puutetta kielen suunnittelussa. Joissakin tapauksissa on ohjelmoijan kannalta mukavaa sallia toistorakenteesta poistuminen itse valitusta kohdasta. Monet kielet sallivat tällaisen toteutuksen. Esimerkiksi Ada -kielessä on rakenne silmukalle, joka on ikuinen, ellei ohjelmoija määrittele poistumiskohtaa seuraavasti loop if(toistoja > 10) then exit; end if; end loop; Tällöin silmukasta poistutaan exit -lauseen määräämästä kohdasta heti, kun annettu ehto toteutuu. Myös C-kieleen pohjautuvissa kielissä silmukasta voidaan poistua pakottavasti - tämän tekee break -käsky. Näin ollen yllä olevaa Ada -koodia vastaava C - kielinen koodi olisi for(;;) { if(toistoja > 10) break; }
Tässä for(;;) voitaisiin myös korvata lauseella while(1) (tai while(true) Javassa). Samassa silmukassa voi olla useita poistumiskohtia. Kovin monien poistumiskohtien käyttäminen haittaa kuitenkin koodin luettavuutta, joten niitä kannattaa käyttää harkiten. Rakenteisen ohjelmoinnin ihanteisiin kuuluu periaate, jonka mukaan jokaisella rakenteella on yksi tulo- ja poistumiskohta; tätä periaatetta voidaan rikkoa kirjoittamalla useita poistumiskohtia silmukkaan. Monien ohjelmointiongelmien kannalta on kuitenkin kätevää säilyttää myös pakotettu poistuminen silmukasta, joten useimmissa kielissä kyseinen ominaisuus on toteutettu. Pythonissa on, kuten sen forsilmukassakin while-rakenteessa vapaaehtoinen else-osa, joka suoritetaan silmukan lopuksi, ellei silmukasta poistuta break-lauseella. Lähteet [Arc] Archer, Tom. Inside C#. Edita, IT Press, 2001. [Arn] Arnold, Ken Gosling, James. The Java Programming Language, Second Edition, Addison-Wesley 1998 [Har] Harsu, Maarit. Ohjelmointikielet, Periaatteet, käsitteet, valintaperusteet, Talentum 2005. [Ker] Kernighan, Richie. The C Programming Language. Prentice Hall 1988. [KLS] Kortela, Larmela, Salmela. FORTRAN 77. OtaData 1985. [Kor] Kortela, Larmela, Planman. Pascal-ohjelmointikieli. OtaData 1980. [Kur] Kurki-Suonio Reino. Ada-kieli ja ohjelmointikielten yleiset perusteet. MODEEMI ry Tampere 1983. [Seb] Sebesta, Robert W. Concepts of Programming Languages 10th edition, Pearson 2013. [Strou] Stroustrup, Bjarne. The C++ Programming Language, 3rd edition, Murray Hill 1997.