1 / 50

Olio-ohjelmoinnin perusteet luento 1

Olio-ohjelmoinnin perusteet luento 1. Päivi Ovaska LTKK/Tietotekniikan osasto. Sisältö. Johdanto oliomaailmaan C++ -ohjelmien yleisrakenne ja moduularisuus C++-kielen erityispiirteitä Kommentit Tyyppimuunnokset (type casting) Syöttö ja tulostus Muuttujien näkyvyys

thelma
Télécharger la présentation

Olio-ohjelmoinnin perusteet luento 1

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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ä

More Related