Osoittimet ja taulukot

Transkriptio

1 Osoittimet ja taulukot Hannu Laine Copyright Hannu Laine

2 Osoittimet int main (void) { int a; int *p; //p on osoitinmuuttuja p = &a; *p = 10; printf( %d, *p); //tulostuu muuttujan a sisältö scanf( %d, p); //muuttujaan a luetaan uusi arvo printf( %d, a); //tulostetaan se * muuttujan määrittelyssä (määrää muuttujan tyypin) * muuttujaa käytettäessä (tarkoittaa epäsuoraa osoitusta) & ei voi esiintyä muuttujan määrittelyssä (C:ssä) & muuttujaa käytettäessä on osoiteoperaattori int * vai int*? *(&a) ok ja on sama kuin a *a on kielioppivirhe &(*p) Entä &p? ok ja on sama kuin &a Left value / Right value HL 1

3 Taulukot (käännösaikana varattavat) 1 Taulukkomuuttujan määrittely Yleinen muoto: alkiotyyppi nimi[koko]; Esim: float taulukko[5]; //tila varataan pinosta 5 floatalkiolle. Koon pitää olla vakio (käännösaikana selvitettävissä oleva luku). Alkiotyyppi voi olla mikä tyyppi tahansa. Taulukon nimi on muistissa vakio-osoitin, jonka kohdetyyppi on alkion tyyppi. Yllä olevassa tapauksessa siis vakion taulukko tyyppi on float *. Sisäinen esitys muistissa: taulukko HL 2

4 Taulukot (käännösaikana varattavat) 2 Taulukon alustus float t1[5] = {1.0, 2.0, 3.0, 4.0, 5.0; float t2[5] = {0; // kaikki 5 alkiota alustetaan nollaksi float t3[ ] = {1.0, 2.0, 3.0, 4.0, 5.0; //varataan tila 5:lle float t4[ ] ; //ei ole järkevä merkintä // muuttujan määrittelyssä Taulukon sijoitus: Taulukon sijoitus ei onnistu: float t5[5]; t5 = t1; Edellä oleva lause aiheuttaa käännösvirheen: Syntax error: Left value required tai t5 is constant Tarvitaan silmukka, jossa kopioidaan alkio alkiolta Yksittäistä alkiota voidaan osoittaa indeksoimalla: t1[3] tarkoittaa neljättä alkiota eli neljättä float lukua taulukossa. HL 3

5 Osoitinmuuttuja edustaa taulukkoa float t [5]; float *p; float x; //Varataan tila taulukolle //Varataan tila osoittimelle p = t; //tämä onnistuu ( t = p ei onnistuisi ) Tämän jälkeen ilmaisut t [2] ja p [2] viittaavat samaan alkioon taulukossa t. Miksi näin? Koska indeksointi merkitsee vain osoitinaritmetiikkaa: *t = 1.0; t [0] = 1.0; *(t+1) = 2.0; t [1] = 2.0; *(t+2) = 3.0; t [2] = 3.0; Osoitinaritmetiikka: lisätään int ( + ) osoitin vähennetään int ( - ) osoitin vähennetään osoitin ( - ) int int edustaa näissä kohdetyypin kokoisia yksiköitä vertailuoperaatiot mahdollisia t p HL 4

6 Osoitinmuuttujan juoksutus int main(void) { float t [5]; float *p; //Tietojen luku for (p = t ; p < t + 5 ; p++) scanf( %f, p); //Tietojen tulostus for (p = t ; p < t + 5 ; p++) printf( %f, *p); //Vastaa allaolevaa ohjelmaa int main(void) { float t [5] ; int i; //Tietojen luku for (i = 0; i < 5 ; i++) scanf( %f, &t [i]); //Tietojen tulostus for (i = 0; i < 5 ; i++) printf( %f, t [i]); HL 5

7 Taulukko parametrina 1 int lue_taulukko(float *t, int koko); void tulosta_taulukko(const float *t, int n); int main(void) { float taul[5] ; int n; n = lue_taulukko(taul, 5); tulosta_taulukko(taul, n); return 0; taul //Funktioiden toteutukset #include <stdio.h> t int lue_taulukko(float *t, int koko) { 5 int i = 0; float x ; printf( \nanna taulukon %d :s alkio, i); scanf( %f, &x ); while ( x > 0 && i < koko) { t [ i++ ] = x; if ( i < koko) { printf( \nanna taulukon %d :s alkio, i); scanf( %f, &x ); return i; HL 6 koko

8 Taulukko parametrina 2 //Funktioiden toteutukset void tulosta_taulukko(const float *t, int n) { int i ; printf( \ntaulukon sisältö on ); for (i = 0 ; i < n ; i++) printf( \n %7.2f, t [i]); Lisämääre const parametrilistassa Taulukko välitetään siis aina osoittimena tehokkuussyistä. Halutaan säilyttää periaate, että protosta näkee, mitä parametreja funktio pääsee muuttamaan. Kääntäjä huolehtii, että osoitinta ei käytetä kohteen muuttamiseen. Yllä olevan funktion toteutuksessa t++; olisi ok, koska muuttaa osoitinta t *t++ = x; ei ole ok, koska muuttaa kohdetta HL 7

9 Taulukko dynaamisessa muistissa (esim) //Vastaa muuten aikaisemmin esillä ollutta (sivun 5 // alaosa) ohjelmaa mutta nyt taulukko varataan // ajonaikana dynaamisesta muistista #include <stdlib.h> int main(void) { float *t; //tässä on ero int koko, i; //Tilan varaus alkioille koko = 5; //koko voi nyt olla muuttujassa t = (float*)malloc(koko*sizeof(float)); //tässä on ero //Tietojen luku for (i = 0; i < koko ; i++) scanf( %f, &t [i]); //Tietojen tulostus for (i = 0; i < koko ; i++) printf( %f, t [i]); free(t); //taulukolle varatun tilan vapautus Huom. Tässä varattu taulukko t voitaisiin välittää aivan samalla tavalla funktioille lue_taulukko ja tulosta_taulukko kuin aikaisempi staattisesti varattu taulukko t. HL 8

10 Taulukon palautus funktiosta Esimerkki #include <stdlib.h> float *f(int *size); int main(void) { float *t; int n, i; t = f(&n); //Tietojen tulostus for (i = 0; i < n ; i++) printf( %f, t [i]); return 0; //Tällä ei toimi. Miksi? float *f(int *n) { float taul [4] = {1.0, 2.0, 3.0, 4.0; *n = 4; return taul; //Tällä toimii. Miksi? float *f(int *n) { float *taul = (float*)malloc(4*sizeof(float)); taul[0] =1.0; taul[1] =2.0; taul[2] =3.0; taul[3] =4.0; *n = 4; return taul; HL 9

11 2-ulotteiset taulukot (staattiset) Määrittely: Vaihtoehto 1. TElementType arr_2dim[n][m]; Vaihtoehto 2. (Määritellään tyyppinimi riville (typedef)) typedef TElementType Trow[M]; Trow arr_2dim[n]; Molemmissa tapauksissa tilaa varataan NxM alkiolle. Taulukon nimi arr_2dim on edelleen vakio-osoitin. Tämän osoittimen kohdetyyppi on yksiulotteinen taulukko (Trow). arr_2dim Kuinka määritellään vastaava osoitinmuuttuja? Vaihtoehto 1. TElementType (*pointer_for_arr_2dim)[m]; Vaihtoehto 2 typedef TElementType Trow[M]; Trow *pointer_for_arr_2dim; Nyt siis tilaa varataan osoittimelle, ei taulukon alkioille. HL 10

12 2-ulotteinen taulukko (staattinen) parametrina Edellisellä sivulla määritelty osoitinmuuttuja pointer_for_arr_2dim voi edustaa kaksiulotteista taulukkoa, jossa on M saraketta. Tämän muuttujan tyyppi on siis samalla sellaisen funktion parametrin tyyppi, joka ottaa kyseisenlaisen kaksiulotteisen taulukon parametrina. Tällaisen funktion prototyyppi on silloin Vaihtoehto A. void f(trow *array, int rows); Vaihtoehto B. void f(titem (*array)[m], int rows); Kuinka tällaista funktiota kutsutaan: typedef Titem Trow[M]; void main (void) { //Trow arr[n]; //Vaihtoehto A Titem arr[n][m]; //Vaihtoehto B f(arr, N); // Tässä kutsutaan funktiota f Kuinka funktio toteutetaan Funktion toteutuksessa taulukon alkioihin päästään käsiksi normaalilla kaksoisindeksoinnilla tai osoitinaritmetiikalla: array[i][j] *(*(array+i)+j) Rivien määrä voi siis funktiossa olla vaihteleva, mutta sarakkeiden määrä on nyt lyöty lukkoon käännösaikana. HL 11

13 Rivien määrän suhteen dynaaminen 2- ulotteinen taulukko Vain rivien lukumäärä voidaan tässä määrätä ajonaikana. Tiedämme jo millainen osoitinmuuttuja voi edustaa tällaista kaksiulotteista taulukkoa (pointer_for_arr_2dim). Nyt vain pitää varata tila dynaamisesta muistista: Vaihtoehto A. pointer_for_arr_2dim = (Trow *) malloc(n*sizeof(trow)); Tämä versio on täysin analoginen yksiulotteisen taulukon kanssa. Nyt vain alkiotyyppi on Trow, joka sattuu olemaan taulukko. Vaihtoehto B. pointer_for_arr_2dim = (float (*)[M]) malloc(m*n* sizeof(float)); tai pointer_for_arr_2dim = (float (*)[M])malloc(n*sizeof(float [M])); Vain rivimäärä voidaan valita ajonaikana. Sarakkeiden määrän on oltava käännösaikainen vakio. Seuraavaksi tehdään taulukko, jossa sarakkeiden määrä on valittavissa ajonaikana ja rivien määrä on käännösaikainen vakio Lopullisena vaiheena on taulukko, jossa molemmat dimensiot määrätään ajonaikana. HL 12

14 Sarakkeiden määrän suhteen dynaaminen 2-ulotteinen taulukko 1 Nyt oletetaan tilanne, että tarvittavien rivien maksimimäärä tiedetään käännösaikana, mutta riville tarvittavien sarakkeiden määrä saadaan selville vasta ajonaikana. Vaaditaan edelleen, että yksittäiseen alkioon päästään merkinnällä arr [ i ] [ j ]; Nyt jokainen rivi on varattava dynaamisesta muistista, koska sen koko määräytyy vasta ajonaikana. Jokaista riviä edustava osoitin tallennetaan osoittimien taulukkoon. Tämä taulukko voi tässä tapauksessa olla staattinen taulukko. 2-ulotteista taulukkoa edustavan staattisen yksiulotteisen osoitintaulukon määrittely on silloin: Telement *arr[rows]; Rakenne näyttää silloin seuraavalta: arr HL 13

15 Sarakkeiden määrän suhteen dynaaminen 2-ulotteinen taulukko 2 Tilanvarausfunktio: void allocatematrix(telement **arr, int rows, int cols) { int i; for(i = 0; i < rows ; i++) arr[i] = (Telement*)malloc(cols*sizeof(Telement)); HL 14

16 Täydellisesti dynaaminen 2-ulotteinen taulukko 1 Halutaan, että rivien määrä ja sarakkeiden määrä on valittavissa ajonaikana. Vaaditaan silti edelleen, että yksittäiseen alkioon päästään merkinnällä arr [ i ] [ j ]; Tilanne on nyt muuten sama kuin edellä, mutta nyt myös rivejä edustavien osoittimien taulukko on varattava dynaamisesta muistista, koska senkin koko määräytyy vasta ajonaikana. Tätä osoittimien taulukkoa edustaa silloin osoitin, jonka kohdetyyppi on osoitin. 2-ulotteista taulukkoa edustavan osoittimen tyyppi on nyt Telement **arr; Rakenne näyttää silloin seuraavalta: arr Tilanvarausfunktio: Telement ** allocatematrix(int rows, int cols) { Telement **p; int i; p =(Telement**)malloc(rows*sizeof(Telement*)); for(i = 0; i < rows ; i++) p[i] = (Telement*)malloc(cols*sizeof(Telement)); return p; HL 15

17 Täydellisesti dynaaminen 2-ulotteinen taulukko 2 Huomautus 1. Nyt jokainen rivi voisi olla myös pituudeltaan erilainen (ragged array). Huomautus 2. Varausfunktion looppi voitaisiin korvata yhdellä varauksella ja sen jälkeen käydä loopissa sijoittamassa oikeat osoitteet osoitintaulukkoon. Pohdittavaa. Entä kun varausfunktion halutaan tuottavan varatun alueen osoitin parametrissaan. Tällöin siis varausfunktio allocatematrix olisi prototyypiltään muotoa void allocatematrix(????); HL 16

18 Täydellinen 2-ulotteinen taulukko parametrina Esimerkkinä 2-ulotteinen float-taulukko //Funktioiden prototyypit float ** allocatematrix(int rows, int cols); void readmatrix(float **matrix, int rows, int cols); void displaymatrix(float **matrix, int rows, int cols); int main (void) { float **matrix; int n = 3, m = 4; matrix = allocatematrix(n,m); //koko voidaan määrätä ajonaikana readmatrix(matrix, n, m); printf( %f, matrix[ 1 ][ 2 ]); //kaksoisindeksointi toimii displaymatrix(matrix, n, m); return 0; //Tässä funktion readmatrix toteutus: void readmatrix(float **matrix, int rows, int cols) { int i, j; for (i = 0 ; i < rows ; i++ ) for (j = 0 ; j < cols ; j++ ) scanf( %f, &matrix[ i ] [ j ]); //kaksoisindeksointi toimii HL 17

19 Merkkijonot (luku, tulostus, kopiointi) Merkkijono on C-kielessä merkkien taulukko, jossa merkki, jonka koodi on 0, päättää merkkijonon. Tähän erityisominaisuuteen perustuu kaikki merkkijonofunktiot. Merkkijonon tyyppi on siis osoitin merkkiin (char *). Esimerkki. int main(void) { char name[20]; //tilaa 19 merkille + loppunollalle char kopio[20]; scanf( %s, name); //voidaan lukea ilman looppia strcpy(kopio, name); //kopioi merkki merkiltä //kopio = name; on edelleen käännösvirhe printf( %s, kopio); return 0; Huomautus 1. scanf ja strcpy hoitavat myös päätösnollan kohteeseensa. Merkkien tulostuksen lopetus ajoissa perustuu päätösnollan löytymiseen. Huomautus 2. Jos kyseessä olisi mikä tahansa muu kuin merkkitaulukko, sen lukemiseen, kopioimiseen ja tulostamiseen pitää itse kirjoittaa loopin sisältävä koodi. HL 18

20 Merkkijonot (määrittely ja alustus) A) Kaikki mitä on sanottu taulukoista yleensä on edelleen voimassa: A1) staattinen taulukko char string1[10]; //tilan varaus char string2[10] = { a, b, c, d, e, \0 ; //tilanvaraus ja alustus (tilaa 10) char string3[ ] = { a, b, c, d, e, \0 ; //tilanvaraus ja alustus (tilaa 6) A2) dynaamisesti varattu n = 6; char *string4 = (char*)malloc(n*sizeof(char)); string4[0] = a ; string4[1] = b ; string4[2] = c ; string4[3] = d ; string4[4] = e ; string4[5] = \0 ; string4 = abcde ; //ei kopioi merkkejä mutta mitä? B) Voimassa erityisesti merkkijonoille char string5[10] = abcde ; //helppo alustus char string6[ ] = abcde ; // (tilaa 6) char *string7 = abcde ; //mikä on ero edellisiin! string6 = abcde ; // ei toimi (left value required!) string7 = abcde ; // toimii HL 19

21 Merkkijonotaulukot Merkkijonojen taulukko on 2-ulotteinen taulukko, koska yksi merkkijono on jo taulukko. Kaikki mitä on sanottu kaksiulotteisista taulukoista yleensä pätee edelleen. Nyt vain yhtä merkkijonoa (yhtä 2-ulotteisen taulukon riviä) voidaan käsitellä kokonaisuutena kirjastofunktioilla. Kaikki versiot siis staattisesta, merkkijonojen määrän (rivien määrän) suhteen dynaamisesta, merkkien määrän (sarakkeiden määrän) suhteen dynaamisesta ja täysin dynaamisesta versiosta ovat mahdollisia. Lisäksi vielä on muistettava, että itse merkkijonot voivat sijaita vakio-merkkijonoalueella. HL 20

22 char names1[4][30]={ Pekka, Petra, Matti, Maija ; char names1[ ][30] ={ Pekka, Petra, Matti, Maija ; Mitä antaa sizeof (names1)? Seuraava ei toimi: char names1[ ][ ] = { Pekka, Petra, Matti, Maija ; Mikä on erona seuraavissa? char *names2[4] = { Pekka, Petra, Matti, Maija ; char *names2[ ] = { Pekka, Petra, Matti, Maija ; Mitä antaa sizeof (names2)? Entä mitä eroa seuraavassa? char **names3; Mitä antaa sizeof (names3)? Sijoitukset names3 = names1; // ei ok names3 = names2; //on ok Kaikissa tapauksissa toimii: int i; Merkkijonotaulukot (esimerkkejä) for (i = 0 ; i < 4 ; i++) printf("%s", namesx[i]); //X voi olla 1,2 tai 3 HL 21

23 Komentoriviparametrit (Command line parameters) Ohjelmalle voidaan antaa käynnistyksen yhteydessä komentoriviparametreja. Käytännössä nämä ovat käytettävissä main-funktion parametreina. startup koodi vie parametrit pinoon ennen mainfunktion kutsua normaalin funktion kutsumenettelyn mukaan. int main (int argc, char **argv) { for (int i = 0 ; i < argc ; i++) printf( %s, argv[i]); //or printf( %s, *argv++); return 0; Oletus: Komentorivi on muotoa C:\>oh.exe aaa bb 123 Pino argc 4 argv o h. e x e \0 a a a \0 b b \ \0 HL 22