C-ohjelmointikieli vs. muut kielet

Transkriptio

1 C-ohjelmointikieli vs. muut kielet C-kieli ohjelmointikielten "sukupuussa" (C++ -kielen kehittäjää Bjarne Stroustrupia mukaillen): 1

2 C vs. Java ("stereotyyppisesti") Käytännön eroja (tyypillisesti): Java: kääntäjä tuottaa tavukoodia, jota ajetaan virtuaalikoneessa. Vanha mainoslause: "Write once, run everywhere". Voi ajaa kaikissa järjestelmissä, joissa on Java-virtuaalikone. Virtuaalikone koodin suoritus hieman hidasta? C: ohjelma käännetään suoraan konekielelle. Pitää kääntää eri järjestelmille erikseen. ANSI C käytännössä "Write once, compile everywhere"? Ongelmana kuitenkin itse koodin järjestelmäriippuvuus... Optimoitu konekielikoodi koodin suoritus jokseenkin niin tehokasta, kuin mahdollista! Java: valtavan laaja yhdenmukaisesti standardoitu luokkakirjasto. Käytä valmiita apuluokkia, tee vähemmän itse. C: hyvin suppea standardikirjasto. Tee-se-itse (tai käytä ulkopuolisia apukirjastoja). 2

3 Java-ohjelman korkean tason rakenne Ohjelma koostuu virtuaalikoneen hallinnoimista luokista. 3

4 C-ohjelman korkean tason rakenne Ohjelma koostuu käännöksen loppuvaiheessa yhteen linkitettävistä käännösyksiköistä (yhtenäinen ohjelma). 4

5 C-ohjelman kääntämisen vaiheet 5

6 C vs. Java ("stereotyyppisesti")... Merkittäviä itse ohjelmointikielten eroja: Ominaisuuksia, joita C-kielessä ei ole (mutta Javassa on): Luokat. Viitemuuttujat. Automaattinen dynaamisen muistin vapautus. Poikkeukset. Ominaisuuksia, jotka C-kielessä on (mutta Javassa ei ole): Osoitinmuuttujat. Tarkka dynaamisen muistin hallinta (vapautus itse). Javan syntaksi pohjautuu C-kieleen paljon kooditason yhtäläisyyksiä: for, while, switch, if/else, return yms. rakenteet samankaltaisia. Osittain samanlaiset primitiivityypit: char, int, float ja double. Perusoperaattorit (asetus, vertailut, aritmetiikka,...). Sulkeiden käyttö, funktion parametrien välitys. Sinänsä "helppo" siirtyä Javasta C-kieleen tai päinvastoin? 6

7 C vs. Java: Hello World Java (tiedostossa "HelloWorld.java"): class HelloWorld { public static void main(string [] args) { System.out.print("Hei maailma!\n"); } } Kääntö: javac HelloWorld.java Suoritus virtuaalikoneella: java HelloWorld C (esim. tiedostossa "hello.c"): #include <stdio.h> int main(void) { printf("hei maailma!\n"); return 0; } Kääntö (ilman erillistä nimeä): gcc hello.c Suoritus:./a.out (Linux/OS X), a tai a.exe (Windows) 7

8 C-ohjelman rakenteesta Ohjelman suoritus alkaa funktiosta main, jolla kaksi vaihtoehtoista muotoa: int main(void){ /* Ei käytetä komentoriviparametreja. */... return kokonaisluku; /* Palautusarvo: ohjelman "tulos". */ } int main(int argc, char *argv[]){/* Komentoriviparametrit. */... return kokonaisluku; /* Palautusarvo: ohjelman "tulos". */ } Tyypillisesti main palauttaa arvon 0, jos ohjelman ajo sujui ongelmitta. Main-funktion parametrit argc ja argv: argc: komentoriviparametrien lukumäärä. argv: komentoriviparametrit sisältävä merkkijonotaulukko. argv[0]: ohjelman kutsunimi. argv[i], i = 1...argc-1: varsinaiset komentoriviparametrit. 8

9 C-ohjelman rakenteesta... /* #include:lla voi lukea tiedostoon mukaan muita tiedostoja. Standardikirjaston tiedoston nimi annetaan kulmasulkeiden sisällä, oman tiedoston nimi heittomerkeissä. */ #include <math.h> #include "oma_koodi.h" /* Tiedoston runko on ns. globaali näkyvyysalue, joka koostuu globaaleista muuttujien ja funktioiden esittelyistä ja määrittelyistä. Funktioita voi määrittää vain globaaleina. Globaali määritys näkyy sen alapuoliseen tiedoston osaan. */ int x = 0; /* Globaali muuttuja. Saa alustaa vain vakiolla. */ /* Palauttaa double-arvon. Ottaa kaksi int-parametria. */ double funktio1(int a, int b) { /* Funktioiden sisällä: lokaali/paikallinen näkyvyysalue. */ double y = sqrt(10); /* Paikallinen muuttuja. Ei näy ulos. */ return y; } // Tämä on laiton kommentti: ANSI C ei salli //-kommentteja! int main(int argc, char *argv[]) {/* Ohjelman suoritus alkaa main-funktion alusta. */ return kokonaisluku; } 9

10 Muuttujan määrityksestä Muuttujan määritys: johtaa muuttujan konkreettiseen luontiin. Tavallisen muuttujan määritys muotoa: [lisämääreitä] tyyppi nimi; [lisämääreitä] tyyppi nimi = alustusarvo; Erikoisrajoite: globaalin muuttujan saa alustaa vain vakioarvolla! Esim. muotoa int x = apu(); tai int y = x; oleva alustus on laiton. Ellei määrityksessä anneta alustusarvoa (eikä kyseessä pelkkä esittely): Globaali muuttuja: alustetaan arvolla 0. Paikallinen muuttuja: jätetään kokonaan alustamatta! Arvo satunnainen (mitä muuttujan muistikohdassa jo sattuu olemaan). Tyypillinen bugilähde pyri antamaan aina alustusarvo! void tee_jotain(int lkm){ int h; /* Ei alustusarvoa: h jää alustamatta! */ while(h++ < lkm){ /* h "satunnainen": silmukka suoritetaan */... /* tuntematon kertaa. Tämä lienee bugi. */ 10

11 Muuttujan määrityksestä... ANSI C: paikalliset muuttujat määritettävä oman lohkonsa alussa! Lohkojen muoto: ensin muuttujien määrittelyt, vasta sitten lauseet. Muuttujaa ei voi määritellä esim. for-silmukan otsakkeessa. for-silmukan silmukkamuuttuja(t) määritettävä ennen for-silmukkaa. void tee_jotain(int par1, int par2) { int h = par1*par2; /* Määrittely. Alustuskin on osa sitä. */ int i = 0; /* OK: edellä vain määrittely. */ h = par1*par2; /* Sijoituslause. */ int j = 0; /* Laiton määrittely: lohkossa oli jo lause. */ for(int i = 0; i < h; ++i) /* Laiton muuttujan i määritys. */ { } for(i = 0; i < h; ++i) /* OK: i määritetty jo ylempänä. */ { int x = 0; /* OK: x määritetään oman lohkonsa alussa. */... 11

12 Esittely, määrittely ja näkyvyys Jotta muuttujaan tai funktioon voi viitata, pitää sen määrittelyn (tai esittelyn) olla näkyvissä viittauskohdassa Muuttujien/funktioiden näkyvyys käännösyksikön sisällä: Globaalit ("funktioiden ulkopuoliset") määritykset: näkyvät esittely- tai määrittelykohdasta alkaen saman käännösyksikön loppuun asti. int j = 5; void tee_jotain(void) { int h = apu(j); /* VIRHE: funktio apu ei vielä näkyvissä. */ } int apu(int x) { int i = j*x; /* OK: globaali j näkyvissä. */ return k + i; /* VIRHE: k ei vielä näkyvissä. */ } int k = 100; 12

13 Esittely, määrittely ja näkyvyys... Muuttujien/funktioiden näkyvyys saman käännösyksikön sisällä: Paikalliset ("koodilohkon, kuten funktion, sisäiset"): näkyvät esittely tai määrittelykohdasta alkaen saman lohkon loppuun asti. Huom! C sallii muuttujan kanssa samannimisen toisen muuttujan määrittelyn sisemmässä lohkossa! Sisempi muuttuja peittää ulomman pois näkyvistä. { { int i = 10; { int x = i; /* OK: i = 10 näkyy sisempäänkin lohkoon. */ int i = 20; /* OK: Nyt i = 20 peittää arvon i = 10. */ x = i; /* OK: nyt x = 20, koska i = 20 näkyvissä. */ } int j = k; /* VIRHE: k ei vielä näkyvissä. */ int k = i; /* OK: paikallinen i = 10 näkyvissä. */ } int h = i+k; /* VIRHE: i ja k eivät näy lohkostaan ulos. */ } 13

14 Esittely, määrittely ja näkyvyys... Esittely: kertoo, että tietynlainen muuttuja/funktio on olemassa (eli määritetty jossain muualla). Muuttujan esittely mahdollista kahdella tavalla: 1) Globaali muuttuja: annetaan määrittely ilman alustusarvoa. Ns. alustava määrittely: muuttuu määrittelyksi, joka alustetaan arvolla 0, jos kääntäjä ei löydä myöhemmin muuta määrittelyä. 2) Globaali tai paikallinen muuttuja: määritys ilman alustusarvoa ja edessä lisämääre extern. (tästä kohta lisää) Funktion esittely: funktion otsake ilman runkoa. Parametrien nimiä ei ole pakko antaa (tyypit riittää). Parametrit voi jopa jättää pois (mutta älä jätä!). int i; /* Muuttujan i alustava määrittely. Voi saada arvon 0. */ extern int j; /* Muuttujan j esittely. Määrittely muualla. */ int apu(int); /* Esitellään funktio apu. */ int tee_jotain(int par){ /* Funktion tee_jotain määrittely. */ return apu(par*j); /* Viittaukset OK: apu ja j on esitelty. */ }/* Linkitys epäonnistuu, ellei apu ja j määritelty muualla. */ 14

15 Muuttujan ja funktion linkittyvyys Muuttujan/funktion linkittyvyys: globaalin muuttujan/funktion nimen näkyvyys käännösyksikössä tai käännösyksiköiden välillä. Ulkoisesti linkittyvä: nimi näkyy ulos eli siihen voidaan viitata oman käännösyksikön ulkopuolelta. (myös muista käännösyksiköistä) Määritys/esittely ulkoisesti linkittyväksi: eteen lisämääre extern. Globaalit ovat oletusarvoisesti ulkoisesti linkittyviä. extern siis turha? Ei: extern estää esittelyn tulkitsemisen alustavaksi määrittelyksi. Toisessa käännösyksikössä määritellyn muuttujan esittely. koodi1.c int x = 99; extern int y; int apu(int par) { int z = apu2(); x = z + y; koodi2.c int y = 5; extern int x; int apu2(void) { int i = apu(x);... 15

16 Muuttujan ja funktion linkittyvyys... Sisäisesti linkittyvä: nimeen voidaan viitata oman käännösyksikön sisällä eri funktioista. (eikä muista käännösyksiköistä) Käytännössä: globaali, joka ei näy käännösyksikön ulkopuolelle. Globaalin määritys sisäisesti linkittyväksi: eteen lisämääre static. Määreen merkitys globaalissa yhteydessä aivan eri kuin paikallisessa! koodi.c static int x = 99; koodi2.c static int apu(int x) { int y = x*x;... } extern int x; int apu3(void) { int i = apu(5);... void apu2(void) { int z = apu(); int i = x; 16

17 Muuttujan ja funktion linkittyvyys... Ei linkittyvä: ei näkyvissä käännösyksikkötasolla (globaalisti). Nimeen voidaan viitata ainoastaan sen omassa määrittelylohkossa. Käytännössä: paikalliset muuttujat. koodi1.c int apu(int par) { int x = 100; } koodi2.c extern int x; int apu3(void) { int i = apu(x);... int apu2(int par) { int y = x; } 17

18 gcc-kääntäjän käytöstä Lähdekooditiedostojen koodi1.c,, koodix.c kääntäminen ja linkitys ohjelmaksi: gcc koodi1.c koodi2.c koodix.c Linux / OS X: ohjelman nimeksi tulee oletuksena a.out. Windows: ohjelman nimeksi tulee oletuksena a.exe. Kääntäjän toimintaa voidaan ohjata valitsimilla. gcc tarjoaa paljon valitsimia. Esimerkiksi muutamia hyödyllisiä: -o nimi: Määritä käännöksen lopputuloksen nimi. Esim. gcc -o ohjelma koodi1.c koodi2.c koodi3.c -ansi: Käytä C90-standardia (ns. ANSI C). -pedantic: Sovella standardin sääntöjä tarkasti. -Wall: Tulosta varoituksia epäilyttävistä (vaikkakin periaatteessa laillisista) koodin osista. 18

19 gcc-kääntäjän käytöstä... -Wextra: Tulosta varoituksia vieläkin laajemmin (monet turhia). -E: Ainoastaan esiprosessoi. Ei käännä koodia. -S: Käännä koodi symboliseksi konekieleksi ("assembly"). Tuottaa käännösyksiköistä assembly-kieliset tiedostot. -c: Käännä, mutta älä linkitä. Tuottaa käännösyksiköistä objektikooditiedostot. -g: Käännä ohjelma debuggausta varten. Kirjataan tietoa käännetyn ohjelman ja lähdekoodin suhteista (helpottaa virheiden hakua ns. debuggerin avulla). -On: Käännöksen optimointitaso n, arvo välillä Mitä suurempi n on, sitä enemmän kääntäjä yrittää optimoida koodia. -O0: älä optimoi lainkaan, -O3: optimoi mahdollisimman paljon. Optimointi ei oletusarvoisesti päällä (hidastaa käännöstä). Käyttöön otettava ohjelma kannattaa kääntää optimoiden (-O3). 19

20 Esittelyt ja määrittelyt / toteutus- ja otsaketiedostot Tyypillinen jako: Käännösyksikön "julkiset" eli muidenkin yksiköiden käyttöön tarjoamat osat esitellään ns. otsaketiedostossa. Otsaketiedoston rooli: kyseisen käännösyksikön "rajapinta". Vallitseva tapa: otsaketiedoston tiedostopääte on ".h". Toteutukset varsinaisessa toteutustiedostossa. Vallitseva tapa: toteutustiedoston tiedostopääte on ".c". Jos esim. otsaketiedosto koodi.h ja toteutustiedosto koodi.c, niin: Tiedoston koodi.c tulisi sisällyttää myös itseensä otsake koodi.h. Eli käytännössä: sisältää rivi #include "koodi.h". Hyöty: kääntäjä voi havaita, jos toteutus poikkeaa rajapinnasta. Tiedoston koodi.c tarjoamia osia käyttävät käännösyksiköt: Sisällyttävät itseensä otsaketiedoston koodi.h. Käännetään/linkitetään yhdessä toteutustiedoston koodi.c kanssa. 20

21 Esittelyt ja määrittelyt / toteutus- ja otsaketiedostot... Esimerkiksi Hello World -koodin voisi jakaa vaikkapa seuraavasti: Toteutustiedosto hello.c: viestin tulostava funktio heimaailma. #include <stdio.h> #include "hello.h" /* Sisällytetään tiedoston oma otsake. */ void heimaailma(void) { printf("hei maailma!\n"); } Otsaketiedosto hello.h: "rajapinta" eli funktion heimaailma esittely. void heimaailma(void); Lisäksi suoritettava ohjelma tarvitsee main-funktion. Tämä voisi olla vaikkapa tiedostossa main.c. Kääntö tapaan gcc hello.c main.c. #include "hello.h" /* Sisällytetään heimaailma:n otsake. */ int main(void){ heimaailma(); /* Kutsuu hello.c:n funktiota heimaailma. */ return 0; /* Ohjelma loppui ok, palautetaan arvo 0. */ } 21

22 C-kielen perustyypit: kokonaisluvut Neljä perustyyppiä, jotka lueteltu alla tyyppiin mahtuvien arvojen suuruusjärjestyksessä: signed char short int int long int Koot voivat vaihdella järjestelmästä riippuen! C-standardi kuitenkin takaa vähintään seuraavat lukuvälit: signed char: -(2 7-1) = short int: -(2 15-1) = int: -(2 15-1) = long int: -(2 31-1) = Kolme viimeistä tyyppiä on mahdollista ilmaista usealla eri tavalla: short int == short == signed short == signed short int int == signed == signed int long int == long == signed long == signed long int int on C-kielen totuusarvotyyppi: 0 on epätosi ja!= 0 on tosi. 22

23 C-kielen perustyypit: etumerkittömät kokonaisluvut C-kielessä on lisäksi myös etumerkittömät kokonaislukutyypit! Tallettavat vain ei-negatiivisia kokonaislukuja. Määritys: annetaan kokonaislukutyypille lisämääre unsigned. C-standardi takaa unsigned-tyypeille vähintään seuraavat lukuvälit: unsigned char: = unsigned short int: = unsigned int: = unsigned long int: = Myös unsigned-tyypeillä on samankaltaiset vaihtoehtoiset nimet. Ei kuitenkaan voi olla samanaikaisesti sekä signed että unsigned. Esim.: unsigned short int == unsigned short Lisäksi pätee: unsigned int == unsigned 23

24 C-kielen perustyypit: liukuluvut Kolme liukulukutyyppiä: Suuruus/tarkkuusjärjestyksessä: float, double ja long double Myös liukulukutyyppien ominaisuudet järjestelmäriippuvaisia. C-standardi takaa vähintään seuraavat suuruusluokat ja tarkkuudet: float: Arvoalue vähintään Ainakin 6 merkitsevän numeron tarkkuus. double: Arvoalue vähintään Ainakin 10 merkitsevän numeron tarkkuus. long double: Arvoalue vähintään Ainakin 10 merkitsevän numeron tarkkuus. 24

25 Tyyppien järjestelmäkohtaiset ominaisuudet Otsaketiedosto <limits.h> tarjoaa tietoa järjestelmäkohtaisista rajoista: Kohdejärjestelmän kokonaislukutyyppien arvojen ylärajat: char: SCHAR_MAX, UCHAR_MAX, CHAR_MAX short: SHRT_MAX, USHRT_MAX int: INT_MAX, UINT_MAX long: LONG_MAX, ULONG_MAX Tyyppien alarajat: samat kuin edellä, mutta korvaa "MAX" "MIN". Alarajoja ei ole annettu unsigned-tyypeille. Tunnetaaan muutenkin: aina 0. Otsaketiedosto <float.h> tarjoaa vastaavat tiedot liukulukutyypeille float, double ja long double: Ylärajat: FLT_MAX, DBL_MAX ja LDBL_MAX Alarajat: FLT_MIN, DBL_MIN ja LDBL_MIN 25

26 C-kielen taulukot n-alkioisen taulukon määritys: muuten samoin kuin yksittäinen muuttuja, mutta muuttujan nimen perään taulukon koko hakasulkeissa: Määrityksen perusmuoto on tyyppi nimi[n];. Esim. 10-alkioinen int-taulu itaulu määritetään tapaan int itaulu[10]; Taulukon koon oltava käännösaikainen vakio! Esim. int itaulu[x]; on laiton määritys, jos x on muuttuja. Toinen tärkeä ero verrattuna Javaan: määritys johtaa samalla taulukon luontiin (sen alkiot ovat olemassa määrityksen jälkeen): int taulu[5]; /* Määritetään 5-alkioinen int-taulukko. */ int i = 0; int lkmt[uchar_max+1]; /* OK: UCHAR_MAX jne. ovat vakioita! */ for(i = 0; i < 5; ++i) { taulu[i] = i*i; /* Asetus on OK: taulukko on jo luotu. */ } lkmt[(unsigned char) 'a'] = 5; /* OK: mikä tahansa char-arvo */ /* etumerkittömänä on välillä 0...UCHAR_MAX eli ei ylivuotoa */ 26

27 C-kielen taulukot... Taulukon arvojen alustuminen määrityksen yhteydessä? Samat säännöt kuin yksittäisellä muuttujalla: Globaali taulukko: arvot alustuvat nollaksi. Paikallinen taulukko: arvoja ei alusteta (ovat mitä muistissa jo oli)! Taulukon määrityksen yhteydessä mahdollista antaa alustusarvoja: Annetaan aaltosuluissa, pilkuilla eroteltuina. Jos ei anna kaikkia arvoja: puuttuvat alustetaan arvolla 0. Pari esimerkkiä: int taulu[5] = {2, 7, 3, 5, 4}; on taulukko, jossa esim. taulu[1] == 7. int taulu[5] = {1}; on sama kuin int taulu[5] = {1, 0, 0, 0, 0}; Alustusarvoja käytettäessä taulukon koon saa jättää pois: Kääntäjä päättelee: taulukon koko = alustusarvojen lukumäärä. int taulu[] = {4, 2, 9}; on sama kuin int taulu[3] = {4, 2, 9}; 27

28 C-kielen taulukot... Huom.! C-kielen taulukko ei tiedä kokoaan. Eräs asiaa sivuava tyypillinen tapaus: taulukko funktion parametrina. Taulukkoparametri voidaan määrittää ilman kokomääritystä. Jos tarvitaan koko: annetaan se erikseen esim. parametrina. int suurin(int koko, int taulu[]){/* Kävisi myös ns. osoitin, */ int i = 0; /* muodossa int *taulu. */ int suurin = 0; for(i = 0; i < koko; ++i){ suurin = (i == 0 taulu[i] > suurin)? taulu[i] : suurin; } return suurin; } int taulu[6] = {6, 2, 7, 4, 9, 2}; void tee_jotain(void){ /* printf korvaa määreen %d parametrin s arvolla (sivu 35). */ int s = suurin(6, taulu); /* Asettaa s = 9. */ printf("suurin arvo: %d", s); /* Tulostaa "Suurin arvo: 9". */ } 28

29 C-kielen taulukot... C-kielessä ei turvamekanismia taulukon indeksin laillisuuden suhteen. Laiton indeksi? Ohjelma mahdollisesti kaatuu. Riippuu tilanteesta. Tyypillinen virhe: mennään taulukon lopusta yli. (ns. "ylivuoto") void tee_jotain(void) { int t[6] = {0, 1, 2, 3, 4, 5}; int i = 0; for(i = 0; i <= 6; ++i) { t[i] = t[i] + 2; /* Taulukon ylivuoto, kun i = 6. */... Edellä yritetään lukea ja kirjoittaa laittomaan kohtaan t[6]. Ohjelma voi kaatua, jos käyttöjärjestelmä havaitsee laittoman muistiosoituksen. Jos ohjelma ei kaadu: manipuloidaan vahingossa jotain väärää arvoa. Esim. muuttuja i voisi olla talletettuna heti taulukon t perässä! 29

30 C-kielen merkkijonot C-kielen merkkijono char-taulukko. Määritelmä: merkkijonon merkit kuvaava char-taulukko, jonka lopussa lisäksi ylimääräinen lopetusmerkki '\0'. Lopetusmerkki '\0': char-tyyppiä oleva kokonaislukuarvo 0. Tyypillinen bugi: unohdetaan merkkijonon lopetusmerkki! Esimerkiksi merkkijonon eli char-taulukon mjono voi määrittää ja alustaa merkkijonoksi "kevät" mm. seuraavilla tavoilla: char mjono[6] = {'k', 'e', 'v', 'ä', 't', '\0'}; char mjono[6] = {'k', 'e', 'v', 'ä', 't', 0}; char mjono[] = {'k', 'e', 'v', 'ä', 't', '\0'}; char mjono[] = "kevät"; Huom! Myös alustus char mjono[5] = "kevät"; on sinänsä laillinen, mutta se vastaa alustusta char mjono[5] = {'k', 'e', 'v', 'ä', 't'}; Lopetusmerkki puuttuu tuloksena ei ole laillinen C-merkkijono! 30

31 C-kielen merkkijonot... C-merkkijono on taulukko ei varsinaisesti tiedä omaa pituuttaan. Mutta: voidaan laskea tutkimalla, milloin kohdataan lopetusmerkki '\0': int main(int argc, char *argv[]) { int pit = 0; while(argv[0][pit]!= '\0') /* Oliko loppumerkki? */ { ++pit; /* Ei ollut: kasvatetaan pituutta. */ } printf("ohjelman kutsunimen pituus oli %d.\n", pit); return 0; } Toinen esimerkki: erillinen funktio pituuden laskuun. int pituus(char *mjono) /* Kävisi myös char mjono[]. */ { int pit = -1; /* Kikkailun makua kalvotilan */ while(mjono[++pit]!= '\0')/* säästämiseksi. Tämä toimii */ ; /* Käytännössä kuten ylempi. */ return pit; } 31

32 C-kielen merkkijonot... Tyypillinen virhe: unohdetaan lopetusmerkki. int pituus(char *mjono) /* Edellisellä sivulla ollut */ { /* funktio, joka laskee */ int pit = -1; /* merkkijonon pituuden. */ while(mjono[++pit]!= '\0') ; return pit; } void tee_jotain(void) { char mj[] = "virhe?"; /* Luodaan merkkijono "virhe?". */ char kopio[100]; /* char-taulu, johon kopioidaan. */ int i = 0; int p = pituus(mj); /* Merkkijonon "virhe?" pituus = 6. */ for(i = 0; i < p; ++i) /* Silmukka kopioi 6 merkkiä eli */ { /* lopetusmerkki jää pois! */ kopio[i] = mj[i]; } p = pituus(kopio); /* Funktio pituus voi toimia väärin: */... /* se ei löydäkään lopetusmerkkiä? */ 32

33 printf: monipuolinen tulostusfunktio C-kielen paljon käytetty tulostusfunktio: int printf(const char *mj, ) Parametri mj: tulostettava merkkijono. printf lupaa olla muuttamatta sitä. (määreestä const sivulla 66) Palautusarvo: tulostettujen merkkien lukumäärä. Funktion printf erityisvahvuus: tulostettavan merkkijonon mj sisään voi näppärästi sisällyttää tulostettavia arvoja. Asetetaan merkkijonon mj sisään, arvojen haluttuihin tulostuskohtiin, muotoa %määre olevat tulostusmääreet. Varsinaiset arvot annetaan funktiolle printf parametreina merkkijonon mj jälkeen. (samassa järjestyksessä kuin määreet sisällytettiin) Usein käytettyjä tulostusmääreitä: Merkin tulostus: c printf("kirjain %c", 'k') tulostaa kirjain k (<stdio.h>) printf("väl%cin", 'i') tulostaa väliin 33

34 printf: monipuolinen tulostusfunktio... (<stdio.h>) int-arvon tulostus: d tai i Jos i = 100, niin printf("luku %d", i) tulostaa luku 100 printf("%d.%i.%d", 18, 3, 2013) tulostaa unsigned int-arvon tulostus: u printf("pituus %u", 180) tulostaa pituus 180 double-arvon tulostus: f printf("1/3 = %f", 1.0/3) tulostaa 1/3 = Merkkijonon tulostus: s Jos merkkijono mj on "maalis", printf("%skuu", mj) tulostaa maaliskuu Erikoistapaus: merkin '%' tulostus? Se annetaan muodossa "%%": printf("20%%") tulostaa 20% 34

35 printf: monipuolinen tulostusfunktio... Tulostusmääreiden eteen voi antaa lisämääreitä. Säätävät (lähinnä) tulostuksen muotoilua. (<stdio.h>) Tulostusmääritys voi yleisemmin ottaen olla muotoa %[valitsimia][leveys][.tarkkuus][koko]t T on tyypin ilmaiseva määre (esim. c, i, d, f tai s). Kukin edellä hakasulkeilla merkitty osa on valinnainen. Leveys: tulostettavien merkkien vähimmäismäärä. Jos arvo vie vähemmän merkkejä, lisätään eteen tyhjää. printf("luku %10d", i) tulostaa luku 100 Leveyden tilalla voi antaa '*', jolloin leveys luetaankin parametrista: printf("luku %*d", 10, i) tulostaa luku

36 printf: monipuolinen tulostusfunktio... Tarkkuuden määritys annetaan muodossa.d, missä D kokonaisluku. Tulkinta riippuu tyypistä: double: tulostus D desimaalin tarkkuudella. printf("pii: %.3f", ) tulostaa pii: int: tulostetaan vähintään D numeroa. Eteen etunollia, jos arvossa alle D numeroa. printf("james Bond %.3d", 7) tulostaa James Bond 007 Merkkijono: tulostetaan korkeintaan D merkkiä. printf("%.5s", "Hannu Hanhi") tulostaa Hannu Myös tarkkuuden D:n tilalla voi antaa '*', jolloin tarkkuus luetaankin erillisestä parametrista: printf("pii: %*.*f", 6, 2, ) tulostaa Pii: 3.14 (<stdio.h>) 36

37 printf: monipuolinen tulostusfunktio... Koko: lukutyypin koon tai muunnoksen ilmaiseva lisämääre. h: tyyppimuunna saatu int-parametri short-arvoksi. Huom! printf oikeasti saa char- ja short-parametrit int-arvoina! Ns. "oletusmuunnos": int on kokonaisluvun perustyyppi. l: parametrin kokonaislukutyyppi on long. Pakko käyttää, jos parametri oikeasti on long! Miten niin pakko? Koska muuten ohjelma voi kaatua! L: parametrin liukulukutyyppi on long double. Pakko käyttää, jos parametri oikeasti on long double! Koon määrittävä lisämääre asetetaan tyyppimääreen eteen: Esimerkiksi long double -arvon x tulostus 20 merkin levyisenä ja 4 desimaalin tarkkuudella: printf("%20.4lf", x) (<stdio.h>) 37

38 C-kielen perustyypit: vakioarvon tyyppi Tavallisen kokonaislukuvakion, kuten esim. -13 tai , tyypiksi määrittyy int, jos int kykenee esittämään arvon, ja muuten long int. Kokonaislukuvakion tyypin määräytymiseen voi vaikuttaa lisäämällä sen perään kirjaimen U tai/ja L. Kummastakin käy myös pieni versio u tai l. U tai u: kokonaislukuvakion tyyppi on unsigned int. L tai l: kokonaislukuvakion tyyppi on long. U tai u ja L tai l: kokonaislukuvakion tyyppi on unsigned long. Liukulukuvakion, kuten 3.14, oletusarvoinen tyyppi on aina double. Liukulukuvakion tyypin määräytymiseen voi vaikuttaa lisäämällä sen perään kirjaimen F tai L (tai f tai l). F tai f: liukulukuvakion tyyppi on float. L tai l: liukulukuvakion tyyppi on long double. printf("%lu", 10); /* Väärä määre %lu: 10 on int-arvo. */ printf("%lu", 10UL); /* Ok: 10UL on unsigned long -arvo 10. */ printf("%lf", L); /* Ok: L long double. */ printf("%ld", L); /* Ok: L on long int. */ 38

39 Muuttujan elinikä, tyypin lisämääre static Globaalin muuttujan elinikä on aina "staattinen". Luodaan ja alustetaan ennen main-funktion suoritusta. Tuhotaan, kun ohjelman suoritus päättyy. Alustus sallittu ainoastaan käännösaikaisella vakioarvolla! Paikallisen muuttujan eliniän voi määrittää lisämääreellä auto tai static: auto: muuttujan elinikä on "automaattinen". Luodaan, kun ohjelman suoritus saapuu määrityksen kohdalle. Tuhotaan, kun ohjelman suoritus poistuu muuttujan lohkosta. Turha määre: paikalliset ovat joka tapauksessa oletusarvoisesti auto. static: muuttujan elinikä on "staattinen". Luodaan ja alustetaan ennen main-funktion suoritusta. Tuhotaan, kun ohjelman suoritus päättyy. Alustus ainoastaan käännöksenaikaisella vakioarvolla. Käytännössä: paikallinen muuttuja, joka säilyttää arvonsa oman lohkonsa eri suorituskertojenkin välillä. 39

40 Muuttujan elinikä, tyypin lisämääre static... int x = 100; /* x alustuu ennen mainin alkua. */ double y = sqrt(x); /* Virhe: globaali alustettava vakiolla! */ void tee_jotain(void) { static int x = 0; /* x alustuu kerran: ennen mainin alkua. */ int y = 0; /* y alustuu aina kun funktio suoritetaan. */ x += 1; /* Kasvatetaan arvoa x. */ y += 1; /* Kasvatetaan arvoa y. */ printf("%d ja %d\n", x, y); /* Tulostetaan x ja y. */ } int main(int argc, char *argv[]) { int i = 0; for(i = 0; i < x; ++i) /* Ok, x on jo alustunut ja on 100. */ { /* Funktio tee_jotain tulostaa ruudulle "1 ja 1", */ /* "2 ja 1", "3 ja 1", "4 ja 1",..., "99 ja 1". Eli x */ /* ylläpitää oman arvonsa mutta y alustuu aina arvoon 0. */ tee_jotain(); } return 0; } 40

41 Tyyppialias / typedef-määrittely C-kielessä voi määrittää tyypeille aliaksia eli vaihtoehtoisia nimiä. Määritys ei luo uutta tyyppiä: ainoastaan vaihtoehtoisen tavan viitata johonkin olemassaolevaan tyyppiin. Määrityksen muoto: typedef tyyppi nimi; tyyppi voi koostua useasta sanasta. nimi on yksittäinen sana. Helppo(?) sääntö: luo halutuntyyppisen muuttujan nimi esittely ja aseta eteen avainsana typedef. typedef-määrittelyn näkyvyys: samat säännöt kuin muuttujilla. void tee_jotain(unsigned int x){ /* Määritetään unsigned int -tyypille alias "etumerkiton". */ typedef unsigned int etumerkiton; etumerkiton y = x*x; /* y:n tyyppi on unsigned int. */ } etumerkiton z = 0; /* Virhe: alias "etumerkiton" ei näy. */ 41

42 Tyyppialias / typedef-määrittely... C-standardikirjasto itsessäänkin määrittää useita tyyppialiaksia. Yksi hyvin paljon käytetty tyyppialias: size_t size_t on määritelty olemaan sizeof-operaattorin palautusarvon tyyppi. Käytännössä: jokin etumerkitön kokonaislukutyyppi. Lienee tyypillisesti (muttei välttämättä aina) unsigned long. Standardikirjastossa olisi määritys typedef unsigned long size_t; Tyyppiä size_t käytetään standardikirjastossa yleensäkin kokoa ilmaisevana etumerkittömänä tyyppinä. Esim. otsaketiedosto string.h tarjoaa merkkijonon pituuden laskuun muotoa size_t strlen(const char *mj) olevan funktion. void tee_jotain(char *mj){ size_t pituus = strlen(mj); /* Lasketaan mj:n pituus. */ size_t i = 0; /* Muuttujaa i käytetään alla silmukassa. */ for(i = 0; i < pituus; ++i) /* Käydään mj:n merkit läpi. */ { if(mj[i] ==... /* Esim. tutkitaan merkkiä mj[i]. */ 42

43 Bitit, tavut, muuttujan (tyypin) koko Digitaalisten tietokoneiden pienin perusyksikkö: 1 bitti Muistinkäsittelyn perusyksikkö: 1 tavu Muuttuja(tyypin) koko: kuinka monta tavua sen esitys vie muistissa. C-kielessä on erillinen operaattori muuttujan koon tutkimiseen: sizeof sizeof(tyyppi): tyypin tyyppi koko tavuina. Esim. sizeof(int) kertoo int-tyypin koon tavuina. sizeof x: muuttujan tai arvon x koko tavuina. Muuttujan/arvon koko == muuttujan/arvon tallettavan tyypin koko. Sulkeet sallittu: sizeof x ja sizeof(x): ilmaisevat samaa. (jos x ei tyyppi) C-standardi: Määre unsigned/signed ei vaikuta muuttujatyypin kokoon. char-tyypin koko on 1 tavu. sizeof(char) == sizeof(signed char) == sizeof(unsigned char) == 143

44 C-standardi: Bitit, tavut, muuttujan (tyypin) koko... Ei määritä tarkkaan seuraavia asioita: Kuinka suuria muut kuin char-tyypit ovat (tavuina). Kuinka suuri char loppujen lopuksi on (bitteinä). char on yksi tavu, mutta kuinka suuri on yksi tavu? Määrittää kuitenkin: Tavun bittien lukumäärä vähintään 8. Tavu voi esittää vähintään 2 8 = 256 eri arvoa. Järjestelmän tavun koon selvitys? Tieto löytyy suoraan otsaketiedostosta <limits.h>: Vakio CHAR_BIT: tavun bittien lukumäärä. Tätä hyödyntäen: esim. int-arvossa on CHAR_BIT*sizeof(int) bittiä. 44

45 Kokonaislukujen bittiesitys Etumerkittömien kokonaislukujen esitys: tavallisena binäärilukuna. Esim. 8 bitistä koostuva unsigned char muuttuja tallettaa arvon 175 bittijonona : 175 = = Etumerkillisten lukujen esitys: tavallinen "arvobiteistä" koostuva binääriluku, jonka ohessa lisäksi etumerkkibitti. Etumerkkibitti = 1 luku on negatiivinen. C-standardin mukaan: Positiivisten lukujen arvobitit esitetään keskenään samalla tavalla niin etumerkillisissä kuin etumerkittömissäkin luvuissa. (= tav. binääriluku) Käytännössä esim. muuttujien signed char x = 105 ja unsigned char y = 105 bittiesitykset ovat identtisiä. Etumerkkibitin tulkinta voidaan tehdä kolmella eri tavalla: 1:n komplementti, 2:n komplementti tai etumerkki. Nykyiset järjestelmät tavallisesti: 2:n komplementti. 45

46 Etumerkillinen kokonaisluku: 2:n komplementti n-bittinen 2:n komplementtiesitys: Viimeiset (oikeanpuoleisimmat, vähiten merkitsevät) n-1 bittiä tulkitaan tavallisena binäärilukuna. Oikealta laskien indeksin i omaavan bitin arvo on 2 i. Ensimmäisen (vasemmanpuoleisin, merkitsevin) eli indeksin n-1 omaavan bitin arvo tulkitaan negatiiviseksi: Arvo ei ole 2 n-1 vaan -2 n-1. Esimerkki: 8-bittisen signed char arvon tulkinta = = Jos täysin sama bittijono tulkittaisiinkin unsigned chararvoksi? = = 149 Pienin ja suurin 8-bittinen signed char-arvo? Pienin = -128, suurin =

47 Liukuluvun tyypillinen esitys: IEEE 754 -standardi Tutkitaan esimerkkinä arvoa , jonka 32-bittinen IEEE liukulukuesitys on IEEE 754 liukuluvun esittävä bittijono koostuu, oikealta vasemmalle, kolmesta osasta: 1. Arvo-osa ("mantissa"): Arvo-osa on muotoa 1.x oleva desimaaliluku. Arvo-osan kuvaavat arvobitit kuvaavat ainoastaan desimaaliosan x. 32-bittisellä liukuluvulla on 23 arvobittiä, 64-bittisellä 52. Vasemmalta oikealle, indeksin i bitin painoarvo on 1/2 i+1. Esimerkissä arvo-osan bittijono vastaa desimaaliosaa 1/ /2 2 = =

48 Liukuluvun tyypillinen esitys: IEEE 754 -standardi : Eksponentti: Ilmaisee luvun suuruusluokan määrittämällä arvo-osalle kertoimen 2 eksponentti. Koodattu etumerkittömästi, mutta arvosta vähennetään korjaustermi: eksponentti = etumerkitön arvo korjaustermi. 32-bittisellä liukuluvulla on 8 eksponenttibittiä ja korjaustermi bittisellä liukuluvulla on 11 eksponenttibittiä ja korjaustermi Esimerkissä eksponenttibitit : etumerkitön arvo on 126. Eksponentti = = -1 Toistaiseksi saatu tulkittua arvo 1.75 * 2-1 = 1.75/2 = Etumerkki: Ei-negatiivinen arvo: 0, negatiivinen arvo: 1 Huomioidaan etumerkki esimerkin lopullinen arvo on

49 Biteistä Entä jos haluamme manipuloida suoraan muuttujan bittien arvoja? Kokonaislukumuuttujiin voidaan soveltaa bitti(vektori)operaattoreita: x & y: arvojen x ja y vastaavien bittien looginen AND. x y: arvojen x ja y vastaavien bittien looginen OR. x ^ y: arvojen x ja y vastaavien bittien looginen XOR. ~x: arvon x bittien looginen NOT kääntää bittien arvot 0 1, 1 0. x >> n: siirrä arvon x bittiesityksen bittejä n askelta oikealle. x << n: siirrä arvon x bittiesityksen bittejä n askelta vasemmalle. Esim. 8-bittisillä unsigned char arvoilla x = 74 eli ja y = 156 eli : x & y: x y: x ^ y: & ^ ~x: ~ x >> 3: >> 3 x << 3: <<

50 Biteistä... Muuttujan x oikealta vasemmalle laskien indeksin i omaavan bitin arvon luku onnistuu esim. suorittamalla operaatio (x >> i) & 1. 1) Siirretään ensin x:n bittiesitystä i askelta oikealle, jotta indeksin i bitti siirtyy oikeanpuoleisimmaksi bitiksi (jonka painoarvo on 2 0 = 1). 2) AND-operaatio & arvon 1 kanssa, jonka kaikki muut bitit ovat 0 ja oikeanpuoleisin bitti on 1, jättää oikeanpuoleisimman bitin arvon jäljelle sellaisenaan ja asettaa kaikki muut bitit nolliksi. Lopputulos on 1, jos oikeanpuoleisin bitti on 1, ja muuten 0. Esimerkiksi bittiesityksen omaavan unsigned char -arvon x indeksit 2 ja 6 omaavien bittien arvojen luku: x >> 2: >> 2 x >> 6: >> & 1: & & 1: & tulos tulos 1 50

51 Biteistä... Muuttujan x oikealta vasemmalle laskien indeksin i omaavan bitin arvon asetus 1-bitiksi onnistuu esim. asettamalla x = x (1 << i). 1) Yllä siirretään ensin arvon 1 bittiesitystä i askelta vasemmalle, jotta arvon 1 ainoa 1-bitti siirtyy indeksin i kohdalle. 2) OR-operaatio arvon x kanssa johtaa siihen, että x:n indeksin i kohdalla on 1-bitti ja kaikki muut x:n bitit säilyvät ennallaan. Esimerkiksi bittiesityksen omaavan unsigned char -arvon x indeksien 2 ja 6 omaavien bittien asetus 1-bitiksi: 1 << 2: << 2 1 << 6: << x: x:

52 Biteistä... Muuttujan x oikealta vasemmalle laskien indeksin i omaavan bitin arvon asetus 0-bitiksi onnistuu esim. asettamalla x = x & ~(1 << i). 1) Yllä siirretään ensin arvon 1 bittiesitystä i askelta vasemmalle, jotta arvon 1 ainoa 1-bitti siirtyy indeksin i kohdalle. 2) Tämän jälkeen NOT-operaatio ~ kääntää kohdan 1) tuloksen bitit: lopputuloksessa indeksin i kohdalla on 0 ja muut bitit ovat 1-bittejä. 3) AND-operaatio & arvon x kanssa johtaa siihen, että indeksin kohdalla on 0-bitti ja kaikki muut x:n bitit säilyvät ennallaan. Esimerkiksi bittiesityksen omaavan unsigned char -arvon x indeksien 2 ja 6 omaavien bittien asetus 0-bitiksi: 1 << 2: << 2 1 << 6: << 6 ~: ~ ~: ~ & x: & & x: &

53 Muuttujan (ja funktionkin) osoite Muuttujat (ja merkkijonovakiot sekä funktiot) sijaitsevat muistissa. Niillä on oma (muisti)osoite. sijainnin tavun tarkkuudella ilmaiseva kokonaisluku. C-kielessä on oma operaattori osoitteen selvittämiseen: & Operaatio &nimi kertoo alkion/funktion nimi muistiosoitteen. MUISTI printf-funktiolla oma määre Osoite &par par:n arvo osoitteen tulostamiseen: p Osoite &x x:n arvo (15) koodi.c int i = 99; Osoite &i i:n arvo (99) void apu(int par) { int x = 15; printf("%p", &x); } Osoite &apu Funktio apu. 53

54 Osoitinmuuttuja ("pointteri") C-kielessä on erillinen muuttujakategoria osoitteiden manipuloimiseen: osoitinmuuttujat (lyhyemmin: osoittimet / pointterit) Osoitinmuuttujalla on tyyppi: minkä tyyppiseen alkioon se osoittaa. Osoitinmuuttujan määritys (perustapauksessa): kuin osoitetun tyyppisen muuttujan määritys, mutta muuttujan nimen eteen osoitinmääre *. Muotoa tyyppi *osnimi; oleva määritys: osnimi on osoitin, johon voi tallettaa tyyppiä tyyppi olevan alkion (tai funktion) osoitteen. Esim. char *cp; määrittää: cp on osoitin char-alkioon eli char-osoitin. koodi.c void apu(void) { int x = 15; int *y = &x; } MUISTI Osoite &x x:n arvo (15) Osoite &y Osoite &apu y:n arvo (osoite &x) Funktio apu. 54

55 Osoitettuun alkioon viittaaminen Osoitettuun alkioon voi viitata ns. osoitusoperaattorin * avulla. Jos os on osoitin (tai osoite), niin *os viittaa sen osoittamaan alkioon. Älä sekoita osoitinmäärettä ja osoitusoperaattoria. Eroavat ulkoisesti vain käyttötapansa/käyttöpaikkansa suhteen. Osoitinmääre esiintyy vain osana tyyppimääritystä. void tee_jotain(void) { double x = 5.8; /* Alla double-osoitin y määritetään osoit- */ double *y = &x; /* tamaan x:ään eli y:n arvoksi x:n osoite. */ double z = *y; /* z saa y:n osoittaman arvon eli nyt z 5.8. */ x += 1; /* Kasvatetaan x:ää yhdellä eli nyt x = 6.8. */ z = 2 * (*y); /* z saa 2* y:n osoittaman arvon eli 2*6.8. */ *y = 3.14; /* Asetetaan z:n osoittaman alkion arvoksi */ printf("%.2f", x); /* Tulostuu x:n arvo eli "3.14". */ } 55

56 "Alkuperäisen" alkion välittäminen osoittimella C-kieli (kuten Java) välittää funktion parametrit niiden arvojen kopioina. Ns. "call-by-value". void turhaa(int x){ x = 2*x; /* Muutetaan paikallista parametrimuuttujaa x. */ } void tee_jotain{ int z = 5; turhaa(z); /* Funktio turhaa saa parametrina z:n kopion. */... /* Alkuperäinen z on yhä 5. */ } Muuttujan välitys osoittimella: sallii alkuperäisen arvon muuttamisen. void tuplaa(int *x){ /* Parametri: osoitin int-arvoon. */ *x = 2*(*x); /* Muutetaan parametrin osoittamaa arvoa. */ } void tee_jotain{ int z = 5; tuplaa(&z); /* Funktiolle tuplaa parametrina z:n osoite. */... /* Nyt z on 10, koska tuplaa muutti sitä. */ } 56

57 Osoittimet ja taulukot, osoitinaritmetiikka C-kielessä taulukkomuuttuja osoitin taulukon ensimmäiseen alkioon. Mutta: taulukkomuuttuja ei ole osoitinmuuttuja. Taulukkomuuttujan arvoa ei voi muuttaa. Taulukkomuuttujalle taulu pätee sopimus &taulu == taulu. Taulukon arvot sijaitsevat peräkkäisissä osoitteissa. Osoittimelle (tai osoitteeseen) os voi soveltaa ns. osoitinaritmetiikkaa: Osoite, joka on i askelta osoitteesta os eteenpäin: os + i. Yksittäinen askel sizeof(*os) tavua eli osoitetun alkion koko tavuina. Taulukon t alkio t[i] sijaitsee osoitteessa t + i. (eli &t[i] == t + i) koodi.c int t[3] = {6,3,7}; Osoite t = &t t[0]:n arvo (6) Osoite t + 1 t[1]:n arvo (3) MUISTI Osoite t + 2 t[2]:n arvo (7) 57

58 Osoittimet ja taulukot, osoitinaritmetiikka... Taulukon indeksioperaattori []: osoitinaritmetiikkalasku ja osoitus. C-kielessä merkintä t[i] tarkoittaa laskutoimitusta/operaatiota *(t+i). Indeksioperaattori laskee osoitettavan osoitteen t+i ja sitten viittaa siihen osoitusoperaattorilla *. Seuraus: alkioon t[15] voi viitata tapaan 15[t]. *(t + 15) == *(15 + t). (mutta älä viittaa!) Taulukkoparametri funktiokutsussa: funktiolle välitetään osoitinmuuttuja, joka osoittaa taulukon alkuun. Esim. int apu(int t[]); vastaa tosiasiassa muotoa int apu(int *t);. Eräs seuraus: jos funktion sisällä tehdään operaatio sizeof(t)? Tulos on sizeof(int *) eli sen alkuun osoittavan osoittimen koko. Se tavumäärä, jonka yksi kyseisen tyyppinen osoitin vie tilaa. Ei riipu millään tavalla taulukon koosta. 58

59 Osoittimet ja taulukot, osoitinaritmetiikka... Osoitin, joka ei osoita mihinkään: ns. nollaosoitin (null pointer) Arvo 0, mutta C-standardikirjastossa määritellään myös nimi NULL. int-taulukon suurimman alkion haku osoitinaritmetiikkaa ja -operaatioita käyttäen: (vrt. saman tekevä funktio sivulla 30) int suurin(int koko, int *taulu) { int *nyky = NULL; /* Alustetaan nollaosoittimeksi. */ int suurin = 0; /* Alla nyky alustetaan arvoon taulu eli se osoittaa */ /* alkioon taulu[0]. Kullakin kierroksella ++nyky asettaa */ /* nyky = nyky + 1 eli nyky siirtyy osoittamaan askeleen */ /* eteenpäin taulukossa taulu. Silmukka lopetetaan koko */ /* askeleen jälkeen eli kun nyky == taulu + koko. */ for(nyky = taulu; nyky < taulu + koko; ++nyky) { /* Alla tutkitaan osoittimen nyky osoittamaa arvoa *nyky. */ suurin = (nyky == taulu *nyky > suurin)? *nyky : suurin; } return suurin; } 59

60 Vakiokokoinen moniulotteinen taulukko C-kielessä voi määrittää moniulotteisen taulukon ilmaisemalla ulottuvuuksien koot peräkkäisten hakasulkeiden sisällä. Esim. int taulu2d[5][10]; määrittää 5x10-kokoisen int-taulukon ja double taulu3d[7][3][5]; määrittää 7x3x5-kokoisen double-taulukon. Kuten yksiulotteisessakin tapauksessa, määritys samalla luo taulukon. int taulu2d[2][4]; /* Määritetään 2x4-kokoinen int-taulukko. */ int i = 0; int j = 0; for(i = 0; i < 2; ++i) for(j = 0; j < 4; ++j) taulu2d[i][j] = i*j; /* Asetetaan vaikkapa arvo i*j. */ Alustusarvot voi antaa kuin yksiulotteiselle taulukolle: Arvojono, joka luettelee alustusarvot "riveittäin" edeten. Alustusarvojen hierarkian voi myös esittää sisäkkäisillä aaltosulkeilla. Jos kaikille alkioille ei anneta alustusarvoa, alustamattomat nollataan. /* Alla alustetaan 3x2x3-kokoinen int-taulukko niin, että 2x3*/ /* -kokoinen alitaulu t[0] saa arvot 0,1,...,5 ja loput 0. */ int t3d[3][2][3] = {{{0, 1, 2}, {3, 4, 5}}}; 60

61 Vakiokokoinen moniulotteinen taulukko... Vakiokokoisin ulottuvuuksin määritetty moniulotteinen taulukko koostuu konkreettisesti peräkkäisistä taulukoista, on siis "taulukoiden taulukko". Esim. int taulu2d[5][10]; on 50 int-arvoa käsittävä yhtenäinen taulukko, jonka kukin päätason alialkio on 10-alkioinen int-taulukko. Esim. pätee sizeof(taulu2d) = 50*sizeof(int) ja sizeof(taulu2d[0]) = 10*sizeof(int). taulu2d[0][4] taulu2d[1][8] taulu2d[0] taulu2d[1] taulu2d[2] Tällainen vakiokokoinen moniulotteinen taulukko funktion parametrina: alitaulukoiden koot pitää tietää jo parametrin tyypissä. (suuri rajoite!) Sama funktio ei sovi yleisille erikokoisille taulukoille! /* Tämä käy 4-alkioisia alitaulukoita omaaville taulukoille. */ int suurin2d(int rivilkm, int taulu2d[][4]) {... 61

62 Funktio-osoitin Funktio-osoittimen määritys: kuin funktion esittely, mutta: Funktion nimen tilalla osoittimen nimi. Nimen eteen osoitinmääre * ja sulut ympärille. Esim. int (*fos)(int, int); määrittää funktio-osoittimen fos, jonka osoittama funktio palauttaa int-arvon ja ottaa kaksi int-parametria. Sulkeiden merkitys: int *fos(int, int); esittelisi funktion fos, joka palauttaa int-osoittimen. Funktio-osoittimen kautta voi tehdä funktiokutsun joko suoraan sellaisenaan tai osoitusoperaattoria * käyttäen. Esim. yllä määritellyn osoittimen fos kohdalla sekä fos(2, 3) että (*fos)(2, 3) olisi laillinen kutsutapa. Funktio-osoittimen asetus osoittamaan funktioon: voi käyttää tai olla käyttämättä osoiteoperaattoria &. Esim. sekä int (*mainos)(int, char *[]) = main että int (*mainos) (int, char *[]) = &main määrittävät osoittimen mainos, joka osoittaa main-funktioon. 62

63 Funktio-osoitin... Funktio-osoittimella voisi esimerkiksi valita halutun toimenpiteen. int pienempi(int a, int b){ return (a < b); /* int-totuusarvo: päteekö a < b? */ } int isompi(int a, int b){ return (a > b); /* int-totuusarvo: päteekö a > b? */ } /* vrt on osoitin muotoa int vrt(int, int) olevaan funktioon.*/ int haeparas(int k, int *t, int (*vrt)(int, int)){ int paras = 0; int i = 0; for(i = 1; i < k; ++i){ if(vrt(t[i], t[paras])) /* vrt palauttaa totuusarvon. */ paras = i; } return t[paras]; } int main(void){ int taulu[8] = {4, 8, 2, 9, 5, 1, 0, 7}; int a = haeparas(8, taulu, pienempi); /* Hakee pienimmän. */ int b = haeparas(8, taulu, isompi); /* Hakee isoimman. */ printf("min %d ja max %d\n", a, b); /* "min 0 ja max 9" */ } 63

64 Muuttujan tyypin lisämääreet const/volatile/register Muuttuja voidaan määrittää vakiomuuttujaksi antamalla lisämääre const. Tapaan const tyyppi muuttujan_nimi = alustusarvo; Esim. const float pii = 3.14; ANSI C: const-muuttujia ei lasketa käännösaikaisiksi vakioiksi! const int koko = 100; int taulukko[koko]; /* Virhe: koko ei käännösaikainen vakio. */ const-muuttujan arvoa ei saa muuttaa sen arvon alustuksen jälkeen. Yritys tehdä niin johtaa kääntäjän virheilmoitukseen. Entä jos yrittää muuttaa const-arvoa epäsuorasti? C-standardi ei ota kantaa, mitä tapahtuu. ("undefined behaviour") int main(void){ const int a = 100; int *a_os = (int *) &a; /* a_os osoittaa vakioon a. */ a = 125; /* Kääntäjän virheilmoitus: const-arvon muutos! */ *a_os = 125; /* Tämän efekti riippuu järjestelmästä! */ /* Linux/gcc:llä alla sain a:n arvoksi 125, kun taas Mac OS */ /* X:ssä a:n arvo ei muuttunut vaan päti yhä a == 100. */ 64

65 Muuttujan tyypin lisämääreet const/volatile/register... Sekä osoittimelle että osoitetulle alkiolle voidaan antaa määre const. const tyyppi * const os = &osoitettava; Osoitinmuuttujan os kautta ei saa kirjoittaa. Osoitinmuuttujan os arvoa ei saa muuttaa. Eräs erikoistapaus: merkkijonovakiot, kuten esimerkiksi "huhtikuu". Kääntäjän alustamia char-taulukoita, joita ei pidä yrittää muuttaa. Esim. const char *kk = "huhtikuu" tai char *kk = "huhtikuu". Kumpikin määritys saa kääntäjän alustamaan muistiin char -taulukon "huhtikuu" ja asettamaan kk:n osoittamaan kyseisen taulukon alkuun. Tyyppi const char * parempi, koska "huhtikuu" on merkkijonovakio. Esimerkki: monen merkkijonovakion taulukko. const char *mt[] = {"eka", "toka", "kolmas"}; Taulukon mt alkiot const char-osoittimia eli tyyppiä const char *. Kääntäjä luo muistiin merkkijonot "eka", "toka" ja "kolmas". Taulukon mt alkiot mj[0],, mj[2] alustetaan osoittamaan niihin. 65

66 Muuttujan tyypin lisämääreet const/volatile/register... const-määreen käyttö funktion osoitinparametrien kanssa: Keino luvata, että funktio ei muuta osoitettua dataa. void tee_jotain(const int *t) /* t osoitin vakioon. */ { t[0] = 1; /* Virheilmoitus: yritys muuttaa const-dataa. */... Jos funktio ei lupaa näin, sille ei pitäisi antaa osoitinta vakiodataan! void apu(int *t) /* t tavallinen osoitin. */ {... /* Tehdään jotain (ei välttämättä muuteta t:tä). */ } void tee_jotain(const int *t) /* t osoitin vakioon. */ { apu(t);/* Kääntäjä voi varoittaa: annamme funktiolle apu */... /* osoittimen const-dataan, vaikka apu ei lupaa */ } /* olla muuttamatta osoitettua dataa. */ Nyrkkisääntö: anna funktion osoitinparametrille const-määre, jos funktio ei muuta osoitinparametrin osoittamaa dataa. 66

67 Muuttujan tyypin lisämääreet const/volatile/register... Kääntäjän eräs keino yrittää optimoida muuttujan käsittelyä: Pidetään paljon käytetyn muuttujan arvoa prosessorin sisäisessä työmuistissa (ns. rekisterissä) useiden komentojen ajan. Vähentää tarvetta muistin lukuun ja kirjoittamiseen. Potentiaalinen ongelma: entä jos jokin ulkopuolinen tekijä tällä välin muuttaa muuttujan arvoa suoraan muistissa? Muuttujan määre volatile: muuttujan arvoa tulee ylläpitää suoraan muistissa. Esim. volatile int x; estää int-muuttujan x optimoinnin rekisteriin. Muuttujan määre register: neuvo C-kääntäjää ylläpitämään muuttuja muistin sijaan suoraan prosessorin rekisterissä. Esim. register double x; Sopii hyvin laiteläheiseen optimointiin. Ei yleensä tarvita. 67

68 Nimetyt int-vakiot enum-määrittelyn avulla C-kielessä voi määrittää nimettyjä int-vakioita ns. enum-määrittelyiden avulla, jotka ovat muotoa: enum [enum_tyypin_nimi] { vakio_nimi_1 [= int-arvo], vakio_nimi_n [= int-arvo] }; Edellä hakasuluissa olevat harmaat osat ovat vapaaehtoisia. Pilkku tulee muiden paitsi viimeisen määritetyn vakion perään. Jos vakiolle ei määritä arvoa, sen arvo on edeltävän vakion arvo + 1 Jos ensimmäiselle vakiolle ei anneta arvoa: arvoksi tulee 0. enum Bool /* Annetaan enum-tyypille nimi Bool. */ { false = 0, /* Määritetään vakioarvo false = 0. */ true /* Emme anna arvoa, joten true = false + 1 = 1. */ }; /* Lopusta ei saa unohtaa puolipistettä. */ 68

69 Nimetyt int-vakiot enum-määrittelyn avulla... enum-vakioiden nimet näkyvät koodissa määrityskohdastaan eteenpäin. enum-tyyppi määrittää oman lukutyyppinsä, joka käyttäytyy kuin int. enum-tyypin nimeen viitataan muodossa enum enum_tyypin_nimi. enum Bool{ /* Annetaan enum-tyypille nimi Bool. */ false = 0, /* Määritetään vakioarvo false = 0. */ true /* Emme anna arvoa, joten true = false + 1 = 1. */ }; /* Lopusta ei saa unohtaa puolipistettä. */ int * hae_arvo(int *t, int koko, int a) { enum Bool loytyi = false; /* enum Bool -muuttuja loytyi. */ int *loppu = t + koko; /* Taulukon t loppuraja. */ for(; t < loppu; ++t) { /* Kävellään taulukkoa t läpi. */ if(*t == a) { /* Löytyikö t:n nykykohdasta arvo a? */ loytyi = true; /* Kirjataan muistiin, että löytyi. */ break; } } /* Jos a löytyi, palautetaan osoitin siihen, muuten NULL. */ return (loytyi == true)? t : NULL; } 69

70 Nimetyt int-vakiot enum-määrittelyn avulla... enum-vakiot ovat käännösaikaisia vakioita. Voidaan käyttää esim. taulukon koon määrityksessä. enum-tyypille määritetään usein typedef-alias ilman avainsanaa enum. Esim. typedef enum Bool Bool; Nyt tyyppiin enum Bool voidaan viitata myös pelkällä nimellä Bool. enum { /* Ei anneta tälle enum-tyypille nimeä: */ koko = 100 /* määritetään vain vakioarvo koko = 100. */ }; enum Viikonloppu { lauantai = 6, sunnuntai /* sunnuntai = lauantai + 1 = 7 */ }; typedef enum Viikonloppu Viikonloppu; void tee_jotain() { double taulukko[koko] = {0}; /* Koon 100 taulukko. */ Viikonloppu vl = lauantai; /* Tyyppinä enum Viikonloppu. */ vl += 4; /* Luvallista: enum käyttäytyy kuin int. */ printf("vl: %d", vl); /* Tulos "vl: 10", koska vl = 6+4. */... 70

71 C-kielen "oliotyypit": struct- ja union-tietueet C-kielessä voi määrittää useasta data-jäsenestä koostuvia tietuetyyppejä. Hieman kuin luokka ilman mitään jäsenfunktioita, perintää tms. Tällaisen ns. struct-tietueen määritys on tavallisesti muotoa: struct tietueen_nimi { tyyppi_1 jäsen_1;... tyyppi_n jäsen_n; }; struct-tietueen tyyppiin viitataan muodossa struct tietueen_nimi. Usein määritetään lisäksi typedef-alias ilman avainsanaa struct. struct Kurssi /* Kurssia kuvaava tietuetyyppi. */ { int op; /* Jäseneen op voi tallettaa kurssin laajuuden. */ char *nimi; /* Kurssin nimeen osoittava char-osoitin. */ }; /* Puolipistettä ei saa unohtaa! */ typedef struct Kurssi Kurssi; /* typedef-alias Kurssi. */ 71

72 C-kielen "oliotyypit": struct- ja union-tietueet... struct-tietuemuuttujat määritetään samaan tapaan kuin muut muuttujat. Määritys samalla luo kyseisen muuttujan. (vrt. taulukko) Tietuemuuttujan x jäseneen n viitataan pisteoperaattorilla tapaan x.n. Tietuemuuttujien x ja y välinen asetus x = y: Muuttujan x jäseniin kopioidaan muuttujan y jäsenten arvot. Tietuemuuttujan jäsenet voi alustaa samalla tavalla kuin taulukon alkiot. Annetaan jäsenten alustusarvot, järjestyksessä, aaltosulkeissa. Jos kaikille jäsenille ei anneta alustusarvoja, loput alustetaan nollilla. Jos tietueella on const-jäsen, on tämä ainoa suora alustustapa! Kurssi k = {5, "Ote C"}; /* k.op = 5, k.nimi = "Ote C". */ Kurssi k2; /* Asetetaan k2:n jäsenten arvot alla erikseen. */ Kurssi k3 = {20}; /* k3.op = 20, k3.nimi = 0 (eli NULL). */ k2.op = 10; k2.nimi = "Tietorakenteet". k2 = k; /* Nyt k2.op = k.op ja k2.nimi = k.nimi. */ printf("%s %dop", k2.nimi, k2.op);/* Tulostuu "Ote C 5op". */ 72