Olio-ohjelmoinnin perusteet luento 1

1. Olio-ohjelmoinnin perusteetluento 1 Päivi Ovaska LTKK/Tietotekniikan osasto

2. Sisältö • Johdanto oliomaailmaan • C++ -ohjelmien yleisrakenne ja moduularisuus • C++-kielen erityispiirteitä • Kommentit • Tyyppimuunnokset (type casting) • Syöttö ja tulostus • Muuttujien näkyvyys • Aliohjelman esittely (function prototypes) • Vakiomuuttujat (constant variables) • Viittausmuuttujat (reference variables) • Dynaaminen muistinvaraus • Inline aliohjelmat • Merkkijonojen käsittely

3. Johdanto • Oliolähestymistapa (object-oriented approach) on ajattelutapa, systeemityön lähestymistapa ja ohjelmointitekniikka • Ensimmäinen olio-ohjelmointitekniikoita sisältävä ohjelmointikieli Simula otettiin käyttöön vuonna 1967 • Seuraavalla vuosikymmenellä varsinaisen lähtölaukauksen olio-ohjelmointiin antoi Smalltalk, joka oli 1980-luvulla suosittu olio-ohjelmointikieli • 1990-luvulla suosituimmaksi olio-ohjelmointikieleksi nousi C++-kieli • Uusimpana kielenä Internetin suosion myötä on noussut Java-kieli • Toteutusvälineiden kirjo on nykyisin monipuolinen ohjelmointikielineen ja kehittimineen

4. Miksi olioita? • Ohjelmistokriisi: • Ohjelmistotyön kustannuksista noin 80 % johtuu ylläpitotyöstä. Tästä noin 30% kuluu virheiden korjaukseen ja noin 70% ohjelmistojen saattamiseksi muutuneita vaatimuksia vastaaviksi • Käytössä olevan ohjelmiston ylläpito on vaikea tehtävä • Ylläpito johtaa usein siihen, että ohjelmisto kasvaa ja monimutkaistuu, minkä jälkeen ylläpito on entistä vaikeampaa • Ohjelmistokriisin helpottamiseksi on kehitetty lukuisia systeemityömalleja, menetelmiä, työvälineitä jne • Ohjelmistojen kehittämiseen on pyritty luomaan järjestelmällisyyttä, on syntynyt kokonaisvaltaisia lähestymistapoja, jotka raamittavat ohjelmistojen suunnittelu- toteutus- ja ylläpitotyötä • Lähestymistavoista uusin on oliolähestymistapa, jossa keskeisessä asemassa on ylläpidettävyys ja uudelleenkäytettävyys.

5. Erilaisia lähestymistapoja ohjelmistokehitykseen ja ohjelmointiin • Tietojenkäsittelyn ongelmiin erilaisia lähestymistapoja on toimintokeskeinen, tietokeskeinen ja oliokeskeinen lähestymistapa • Toimintokeskeisessä lähestymistavassa keskeisiä käsitteitä ovat toiminnot, tehtävät, toimenpiteet ja niiden käsittelysäännöt. Toimintokeskeiseen lähestymistapaan liittyy proseduraalinen ohjelmointityyli, jossa ohjelman kontrolli muodostuu peräkkäin suoritettavista toimenpitestä • Prosedulaarinen ohjelma on yksi ohjelma, joka on jaettu pienempiin palasiin, joita kutsutaan proseduureiksi • Modulaarinen ohjelma on jaettu useampaan moduuliin, jolla on omat muuttujansa. Jokaisella modulilla on näin oma tilansa, jota muutetaan proseduurien avulla • Tietokeskeisessä lähestymistavassa keskeisiä käsitteitä ovat käsiteltävät kohteet ja niihin liittyvät tiedot. Tietokeskeiseen lähestymistapaan liittyvät relaatiotietokannat ja kohdemalli • Oliokeskeisessä lähestymistavassa keskeistä on tietojen ja toimintojen yhdistäminen yhdeksi kokonaisuudeksi, olioksi

6. Spaghetti -ohjelmat

7. Proseduraaliset ohjelmat

8. Modulaariset ohjelmat

9. Olio-ohjelmat

10. C++ -ohjelmien yleisrakenne • esittelytiedostot (header files) .h, .hpp • sisältävät ohjelmayksikön rajapintainformaation, kuten funktioiden otsakkeet ja tyyppien määrittelyt • toteutustiedostot (source files) .cc, .cpp • esittelytiedostot sisällytetään (include) kaikkiin niihin toteutustiedostoihin, joissa niiden sisältämiä esittelyjä tarvitaan • yleensä esitettelytiedostossa olevat esittelyt tulee kirjoittaa ehdollisen käännöksen sisään käyttämällä #ifnder-#endif –kääntäjäkomentoja • jako esittely- ja toteutustiedostot toteuttavat modulaarisuuden periaatteen • moduulin julkisen rajapinnan määrittely esittelytiedostossa • Moduuli= tietorakenne, käsittelyfunktiot (rajapinta) ja niiden toteutus samassa paketissa

11. C-kielen moduulirakenne

12. Päiväysmoduulin rajapinta C:llä #ifndef C_MODUULI_H #define C_MODUULI_H typedef struct paivays data { int p , k , v ; }paivays_PVM; paivays_PVM paivays_luo( int paiva, int kuukausi, int vuosi ); paivays_tulosta( paivays_PVM kohde ); #endif /* C_MODUULI_H */

13. C++ • Varsinkin teollisuudessa yleistynyt oliokieli • C-kielestä lähinnä laajentamalla johdettu • Suurin osa ANSI C -ohjelmista laillisia C++-ohjelmia • Tuloskoodi usein varsin tehokasta • Luokkakäsite & olio-ajattelu ->korkean tason abstraktio • Mahdollisuus myös matalan tason ohjelmointiin • Helpohko oppia C:tä osaaville • Helppo yhdistää C-kirjastoja C++:aan • Kieli ei rajoita ohjelman toteutustapaa • Staattinen (käännösaikainen) tyypitys • ISO C++ -standardi tarjoaa työkaluja C:n puutteiden kiertämiseen

14. C++ haittoja • C:stä periytyvä turvattomuus • Yhteensopivuus C:n kanssa ->ikäviä kompromisseja oliopiirteissä • Vaatii myös C-tuntemusta • Runsaasti ansoja ohjelmoijalle • Helppo kirjoittaa C++:aa C-mäisesti • Kielessä ei kaikkialla pakollisia automaattisia virhetarkastuksia->ohjelmien sekoamiset yleisiä • C:n matalatasoisuus paistaa kielestä läpi myös oliotasolla • Periytymismekanismia käytettäessä sallii toteutukset, jotka itse asiassa olioajattelun vastaisia • Ei pakota olioajatteluun

15. C++ kielen ominaisuuksia • perustana on C-kieli, johon on tehty joitakin lisäyksiä ja olio-ohjelmointimekanismit sisältävät laajennus • C-kielen laajennukset: • Kommentit • Tyyppimuunnokset (type casting) • Syöttö ja tulostus • Muuttujien näkyvyys • Nimiavaruudet (namespace) • Aliohjelman esittely (function prototypes) • Vakiomuuttujat (constant variables) • Viittausmuuttujat (reference variables) • Dynaaminen muistinvaraus • Inline aliohjelmat • Merkkijonojen käsittely

16. C++ kommentit • C-kielen /* … */kommenttien lisäksi käytössä • yhden rivin kommentti, joka on rivin alussa //

17. C++ muuttujien näkyvyys • C-kielisessä ohjelmassa muuttujien määrittelyjen tulee olla funktion alussa tai lohkon alussa: void f() { int x; /* ... */ while (x){ int y; /* ... */ } } • C++-kielessä muuttujien määrittely voi sijaita missä kohtaa ohjelmaa tahansa • Muuttujien näkyvyys alkaa kohdasta, jossa määrittely tapahtuu ja päättyy sen lohkon loppuun int x; // globaali x void f () { int x; //peittää globaalin x:n x=1; //paikallinen x { int x; //peittää ensimmäisen paikallisen x:n X=2; //toinen paikallinen x } x=3; //ensimmäinen paikallinen x } int* p = &x; //ottaa globaalin x:n osoitteen

18. C++ muuttujien näkyvyys • :: näkyvyysoperaattorin avulla mahdollisuus käyttää peitettyä globaalia muuttujaa int x; void f2(); { int x=1; //peitää globaalin x:n ::x=2; //sijoitus globaaliin x:ään }

19. C++ -nimiavaruudet • C:n moduulien ongelmat: • Moduulin nimet (funktiot ja globaalit muuttujat) ovat näkyvissä kaikkialla ohjelmassa. • Käytössä vain yksi (globaali) näkyvyysalue ->nimiavaruuden roskaantuminen ja nimitörmäykset • ISO C++ standardi (ISO 1998) tarjoaa nimiavaruuksien (namespace) avulla tapahtuva hierarkkisen nimeämiskäytännön • avainsanalla namespace ohjelmoija voi koota yhteen samaan kokonaisuuteen liittyviä ohjelmakokonaisuuksia, jotka voivat olla nimetyn lohkon sisällä mitä tahansa C++-ohjelmakoodia

20. C++ nimiavaruudella toteutettu rajapinta 1 // Päiväys-moduulin rajapinnan esittely (tiedosto: paivays.hh) 2 #ifndef PAIVAYS_HH 3 #define PAIVAYS_HH 4 5 namespace Paivays { 6 7 // Päiväyksien tietorakenne: 8 struct PVM { int p , k , v ; }; 9 10 // Rajapinnan funktiot: 11 PVM Luo( int paiva, int kuukausi, int vuosi ); 12 // Palauttaa uuden alustetun päiväyksen. 13 void Tulosta( PVM kohde ); 14 // Tulostetaan päiväys järjestelmän oletuslaitteelle. 15 } 16 #endif

21. C++ -moduulin rajapintafunktioiden toteutus erillisessä tiedostossa 1 // Päiväys-moduulin toteutus (tiedosto: paivays.cc) 2 #include "paivays.hh" /* rajapinnan esittely */ 3 4 namespace Paivays { 5 PVM Luo( int paiva, int kuukausi, int vuosi ) 6 { 7 PVM paluuarvo; …… 8 return paluuarvo; 9 } 10 11 void Tulosta( PVM p ) 12 { …… 13 } 14}

22. C++ nimiavaruuden rakenteiden käyttäminen 1 #include "paivays.hh" 2 3 int main() { 4 Paivays::PVM vappu; 5 vappu = Paivays::Luo( 1,5,2001 ); 6 Paivays::Tulosta( vappu); … 7}

23. C++ syöttö ja tulostus • Oma luokkakirjasto iostream • Tulostaminen cout-olion avulla • cout-olio edustaa standarditulostevirtaa, joka vastaa C-kielen stdout-standarditulostevirtaa cout<<parametri1<<parametri2<<...; • parametri= vakio,muuttuja tai lauseke • cout-olio tunnistaa itse parametrin tyypin ja tulostaa sen oletusasetustensa mukaisessa muodossa • esim. Tulostaminen cout-olion avulla #include <iostream> int main(void) { int ika = 20; char nimi[11] = "Maija"; cout<<"\nNimi on: "<<nimi; cout<<" ja ikä on "<<ika; return 0; }

24. C++ syöttö ja tulostus (jatkuu) • tulostusta voi muodoilla kirjaston aliohjelmien ja ns. manipulaattoreiden avulla #include <iostream> int main(void) { char jono[10] ; cin>>ws>>jono; cout<<”Teksti: “<<endl<<jono<<endl; return 0; } • manipulaattoreita: endl lisää ‘\n’-merkin ja tyhjentää tulostuspuskurin ends lisää ‘\0’-merkin ja tyhjentää tulostuspuskurin flush tyhjentää tulostuspuskurin ws lukee tyhjät syöttöpuskurista

25. C++ syöttö ja tulostus (jatkuu) • Tiedon lukeminen cin-olion avulla • cin-olio edustaa standardisyötevirtaa (C-kielessä stdin) cin>>parametri1>>parametri2>>...; #include <iostream> using namespace std; int main(void) { int ika; char nimi[11] ; cout<<”Syötä ikä ja nimi: “; cin>>ika>>nimi; cout<<”\nNimi oli siis: “<<nimi; cout<<”ja ikä “<<ika; return 0; }

26. C++ syöttö ja tulostus (jatkuu) • Syötteiden välissä oleva merkki voidaan lukea get-aliohjelmalla get(); get(merkki); • Välilyöntejä sisältävä merkkijono voidaan lukea get-aliohjelmalla get(merkkijono, maksimipituus); get(merkkijono,maksimipituus,lopetusmerkki); #include <iostream> using namespace std; void main() { int ika; char kokonimi[30]; char osoite[30]; cout<<"\nIkä? "; cin>>ika; cout<<"Nimi? "; cin.get(); cin.get(kokonimi, 30); cout<<"Osoite? "; cin.get(); cin.get(osoite, 30); cout<<"\nIkä : "<<ika; cout<<"\nNimi: "<<kokonimi; cout<<"\nOsoite: "<<osoite; }

27. C++ syöttö ja tulostus (jatkuu) • Tyhjiä välejä sisältäviä merkkijonoja voidaan lukea getline-ohjelmalla getline(merkkijono, maksimipituus) getline(merkkijono, maksimipituus,lopetusmerkki) #include <iostream> using namespace std; void main() { int ika; char kokonimi[30]; char osoite[30]; cout<<"\nIkä? "; cin>>ika; cout<<"Nimi? "; cin.get(); cin.getline(kokonimi, 30); cout<<"Osoite? "; cin.getline(osoite, 30); cout<<"\nIkä : "<<ika; cout<<"\nNimi: "<<kokonimi; cout<<"\nOsoite: "<<osoite; } • Tyhjämerkkien ohitus syötteesta cin>>ws

28. C-kielen tiedon käsittely ja välittäminen • Muuttujat ja osoittimet • C-kielessä käytetään usein osoittimia funktion parametrien välitykseen, miksi? void swap (int *i, int *j) { int t = *i; *i = *j; *j=t; } main() { int a=10,b=5; swap(&a,&b) cout<<a<<b<<endl; }

29. Osoittimet • Osoitin on muuttuja, joka voi sisältää keskusmuistiosoitteen • Osoitinmuuttujan sisältämän keskusmuistiosoitteen kautta voidaan viitata keskusmuistiosoitteeseen talletettuun tietoon • Osoittimia käytetään dynaamisessa muistinhallinnassa (kun varattavan tilan koko vaihtelee ohjelman eri suorituskerroilla) ja aliohjelmien muuttujaparametreissa (kun aliohjelman tietoon tekemän muutoksen tulee näkyä kutsuvassa aliohjelmassa)

30. Osoitinesimerkkejä int* osoitin1 = NULL; //osoitin 1 määritelty tyhjäksi int luku = 2; int * osoitin2=&luku, *osoitin3= NULL;// osoitin2-niminen //muuttuja on //alustettu int-tyyppisen luku-muuttujan keskusmuistiosoitteella, //osoitin3 on //määritelty tyhjäksi Keskusmuisti näyttää muuttujien varauksen jälkeen seuraavalta: 2 NULL 11 10 11 12 osoitin1 luku osoitin2

31. Osoitinoperaattori& ja sisältöoperaattori* • Osoitinoperaattori muuttujan nimen edessä palauttaa muuttujan keskusmuistiosoitteen • käytetään kun osoitinmuuttujaan sijoitetaan toisen muuttujan keskusmuistiosoite tai kun muuttujan tunnuksen keskusmuistiosoitteeseen halutaan viitata • Sisältöoperaattori osoitinmuuttujan nimen edessä viittaa osoitinmuuttujan osoittaman muuttujan sisältöön

32. Osoittimien käyttö funktion parametrien käsittelyyn #include <iostream> using namespace std; void Korota(int *); //esittely int main() { int luku; cout<<"\nSyötä jokin kokonaisluku: "; cin>>luku; Korota(&luku); cout<<"\nLuku *luku: "<<luku; return 0; } void Korota(int *p_luku) //määrittely { *p_luku = (*p_luku) * (*p_luku); }

33. C++ kielen viittausmuuttujat (reference variables) • C++ tarjoaa viittausmuuttujan: void swap(int& i, int& j) { int t=i; i=j; j=t; } main() { int a=10,b=5; swap(a,b); cout<<a<<b<<end; } • int & viittaus kokonaislukuun • Kun viittaus osoittaa johonkin muuttujaan, se on ikäänkuin toinen nimi tai alias tälle muuttujalle • Esim. int a; int &b=a; a=0; b=5; cout<<a<<endl; • Mitä ohjelma tulostaa ?

34. Viittauksien käyttö funktion parametrien käsittelyyn • #include <iostream> • using namespace std; //käyttää std nimiavaruutta kaikkialla • void Korota(int &); //esittely • int main() • { • int luku; • cout<<"\nSyötä jokin kokonaisluku: "; • cin>>luku; • Korota(luku); • cout<<"\nLuku * luku: "<<luku; • return 0; • } • void Korota(int &p_luku) /määrittely • { • p_luku = p_luku * p_luku; • }

35. C++ kielen viittausmuuttujat (reference variables) • Rajoitukset: • Viittausta ei voi määritellä toiseen viittausmuuttujaan • Viittausmuuttujista ei voi määritellä taulukkoa • Viittaukseen ei voi määritellä osoitinta • Bittikenttään ei voi määritellä viittausta • Viittausmuuttuja viittaa aina samaan alustuksessa määrättyyn kohteeseen, kohdetta ei voi vaihtaa • Esimerkki: int i=0; int& ir=i; ir=-19; //ok const int& irc=47; irc=-37 //ei sallittu, koska viittausmuuttuja on // on määritelty vakioksi

36. C++ kielen viittausmuuttujat (reference variables) • Hyödyt: • Helpottaa osoittimien käytöstä johtuvaa monimutkaisuutta • Ei tapahdu yhtä helposti virheitä kuin osoittimien käytössä, NULL-vertailua ei tarvitse tehdä viittausmuuttujalle

37. Viittaus tietueeseen #include <iostream> using namespace std; struct PVM { int pp, kk, vv; }; int main() { PVM tietue = {1, 1, 1996}; PVM &viittaus = tietue; //viittaus-muuttuja on alustettava // määrittelyn yhteydessä cout<<"\nVuosi viittauksen kautta tulostettuna: "; cout<<viittaus.vv; return 0; }

38. Viittaus osoittimeen #include <iostream> using namespace std; struct PVM { int pp, kk, vv; }; int main() { PVM paiva = {1, 2, 96}; PVM *osoitin1 = &paiva; // osoitinmuuttuja on alustettu paiva- // tietueen keskusmuistiosoitteella PVM *&osoitin2 = osoitin1; //viittaus PVM-tyyppiseen tietueeseen // osoittavaan osotitinmuuttujaan cout<<"\nKuukausi: "<<osoitin1->kk; cout<<"\nKuukausi: "<<osoitin2->kk; return 0; }

39. C++-kielen vakiomuuttujat • C-kieli #define MAX 100 • C++: const int MAX_MJONON_KOKO=100; const douple pi=3.14159265; const int raja=annaRaja(); char mjono[MAX_MJONON_KOKO]; const char* mjono; //vakio-osoitin const int& luku; //vakio-viite • Parametrin arvo voidaan tehdä muuttumattomaksi const-määreellä. Käyttökelpoinen silloin, kun muttuujan arvon vaihtuminen aliohjelmassa viittauksen tai osoittimen kautta halutaan estää #include <iostream> using namespace std; void Aliohjelma(const int &luku); int main(void) { int luku = 5; Aliohjelma(luku); return 0; } void Aliohjelma(const int &luku) { cout<<"Luvun voi tulostaa: "<<luku; cout<<"\nMutta sitä ei voi muuttaa."; //luku = 10; }

40. C++ -kielen vakiomuuttujat • Esimerkkejä vakiomuuttujan käytöstä: void func1(const int i) { i=5; //ei voida muuttaa vakiota } void func2(char * const s) vakio-osoitin merkkijonoon { s=”hello”; //ei voida muuttaa osoitinta } void func3(const char *s) osoitin vakiomerkkijonoon { s=”hello”; //Ok, voidaan muutta osoitinta *s=’A’; //ei voida muuttaa vakiomerkkijonoa } • C++sisältää automaattiset tyyppimuunnokset ei-vakio-osoittimista vakio-osoittimiksi (sama viitteille), mutta ei toiseen suuntaan: char * mjono= ”Käytä String-luokkaa char*:n sijaan”; const char* vakiomjono=mjono; //ok ei-vakio->vakio char* mjono=vakiomjono; //KÄÄNNÖSVIRHE: vakio->ei-vakio

41. C++ aliohjelman esittely (Function prototype) • C++-kielessä aliohjelmat täytyy esitellä ohjelman alussa • liittää aliohjelman nimeen aliohjelman ja parametrien tyypit • esittely muotoa: tyyppi aliohjelman_nimi(parametrilista) #include <iostream> using namespace std; void Korota(int); //esittely int main(void) { int luku; cout<<"\nSyötä jokin kokonaisluku: "; cin>>luku; Korota(luku); cout<<"\nPääohjelman luku on: "<<luku; return 0; } void Korota(int p_luku) { p_luku = p_luku * p_luku; cout<<"\nLuku * luku: "<<p_luku; }

42. Inline-aliohjelmat • Inline-aliohjelmalla optimoidaan aliohjelman suoritusnopeutta, jolloin kuitenkin ohjelmakoodin koko kasvaa • Varattu sana inline on käsky kääntäjälle korvata aliohjelmakutsu aliohjelman rungolla • Kannattaa käyttää lyhyissä aliohjelmissa • Turvallisempi, kuin käyttää makroja (parametrien tarkistus) • esittely: inline tyyppi Aliohjelma();

43. Inline aliohjelma, esimerkki • Muuntaa kirjaimet suuriksi #include <iostream> using namespace std; #include <cctype> inline char MuutaIsoksi(char merkki) { return (toupper(merkki)); } int main() { char merkki = 'a'; merkki = MuutaIsoksi(merkki); cout<<"\nMuutettuna: "<<merkki; return 0; }

44. Tyyppimuunnokset (Type casting) • C-kielessä: int i; float f; f = (float) i; • C++ myös: int i; float f; f = float(i);

45. C-kielessä malloc ja free: int *ip; ip=(int*)malloc sizeof(int)*100); ..... free((void*)ip); C++-kielessä new ja delete: int *p; p=new int; *p=12; cout << *p; delete p; int* ip; ip=new int100; ... delete  ip; typedef node { int data; node *next; }node; main() { node *p; p=new node; p->data=10; delete p; } Dynaaminen muistinkäsittely

46. Osoittimien käyttö dynaamisen muistin hallintaan • Muuttujien tarvitseman keskusmuistitilan varausta ja vapautusta ajonaikaisesti • esim. tietueen tilanvaraus ja –vapautus ajonaikaisesti #include <iostream> using namespace std; #include "pvm.h" int main() { PVM *pvm = NULL; // pvm osoitinmuuttujan esittely ja alustus Null-arvolla pvm = new PVM; // muistitilan varaus PVM tyyppiselle tietueelle if (pvm) // jos tilanvaraus on onnistunut { cout<<"Syötä pp kk vv "; cin>>pvm->pp>>pvm->kk>>pvm->vv; //viittaus tietueen kenttiin osoitin- cout<<"Pvm on: "<<pvm->pp<<"/"; // muuttujan kautta cout<<pvm->kk<<"/"<<pvm->vv; } else cout<<"Tilanvaraus epäonnistui"; delete pvm; // tietueen tilanvapautus return 0; }

47. Osoittimien käyttö dynaamisen muistin hallintaan: taulukko • Yksiulotteisen taulukon tilanvaraus ja –vapautus #include <iostream> using namespace std; int main() { int *luku_osoitin1 = NULL; int vastaus, laskuri = 0; cout<<"\nMontako lukua varataan ? "; cin>>vastaus; luku_osoitin1 = new int[vastaus]; // varataan käyttäjän ilmoittama määrä kokonaislukuja if (luku_osoitin1) { for (laskuri = 0; laskuri < vastaus; laskuri++) { cout<<"\nLuku ?"; cin>>luku_osoitin1[laskuri]; //viittaus taulukon alkioihin } for (laskuri = 0; laskuri < vastaus; laskuri++) { cout<<"\nLuku: "<<luku_osoitin1[laskuri]; cout<<" osoitteessa: "<<&luku_osoitin1[laskuri]; //tulostaa taulukon alkion //keskusmuistiosoitteen } } else cout<<"\nTilanvaraus epäonnistui"; delete [] luku_osoitin1; //taulukon muistitilan vapautus return 0; }

48. Osoittimien käyttö dynaamisen muistin hallintaan: kaksiulotteinen taulukko • Kaksiulotteisen taulukon tilanvaraus ja –vapautus #include <iostream> using namespace std; int main() { int **osoitin; //osoitinmuuttuja kaksiulotteiselle taulukolle int rivit, sarakkeet; int rind, sind; cout<<"Montako riviä? "; cin>>rivit; cout<<"Montako saraketta? "; cin>>sarakkeet; osoitin = new int*[rivit]; //riviosoittimien tilanvaraus. Yksiulotteinen taulukko, jonka osoite on // sijoitettu osoitinmuuttujaan osoitin for (rind = 0; rind < rivit; rind++) osoitin[rind] = new int[sarakkeet]; //tilanvaraus kunkin rivin sarakkeita varten for (rind = 0; rind < rivit; rind++) for (sind = 0; sind < sarakkeet; sind++) { osoitin[rind][sind] = rind; //mitä tulee taulukon alkion arvoiksi? } for (rind = 0; rind < rivit; rind++) { for (sind = 0; sind < sarakkeet; sind++) { cout<<osoitin[rind][sind]<<"("<<&osoitin[rind][sind]<<") "; } cout<<endl; } for (rind = 0; rind < rivit; rind++) delete [] osoitin[rind]; //riviosoittimien tilan vapautus delete [] osoitin; //osoitinmuuttujan tilan vapautus return 0; }

49. C-kielen merkkijonojen käsittely • C-kielessä merkkijono on merkkitaulukko, jonka kukin alkio on char-tyyppinen ja viimeisen alkion sisältö on ’\0’ char vuosi[14+1]=”1995”; char kieli[15]=”C++-kieli”; char muukieli[]=”C-kieli”

50. C++-kielen merkkijonojen käsittely • string-luokka #include <iostream> using namespace std; #include <string> int main() { String etunimi = "Maija"; String sukunimi("Meikäläinen"); cout<<endl<<etunimi; cout<<endl<<sukunimi; return 0; } tästä myöhemmin lisää valmiiden luokkien käytön yhteydessä