1. Standardikirjasto Ohjelmankehitysympäristössä on joukko kirjastoituja funktioita. on joukko otsikkotiedostoja, joissa on kirjastofunktioiden prototyypit (esittelyt) ja tarvittavien vakioiden, tietotyyppien ja olioiden määrittelyt. kirjastofunktioista suuri osa on ISO-C-standardin mukaisia ja siten siirrettävissä käyttöympäristöstä toiseen. jotkin kirjastofunktiot ovat käyttöjärjestelmä- tai konekohtaisia. 1.1 I/O Käyttöjärjestelmä (ja standardikirjaston funktiot) puskuroi raa an (raw) levy- ja konsolidatan koneen muistiin. Ohjelmoijan kannalta syötettävä/tulostettava data näkyy yhtenäisenä datavirtana (stream). Puskuri- ja datavirtatyypit on määritelty tiedostossa stdio.h. Datavirtatyyppi on FILE. Ohjelmoija käyttää (yleensä) osoittimia (FILE*) datavirtaolioihin. C++:ssa on käytettävissä tiedostossa iostream.h määriteltyjä korkeamman tason luokkia ja olioita (esim. cin, cout,... ). On myös mahdollista käsitellä I/O:ta alhaisen tason funktioilla (esim. levysektoreittainen luku/kirjoitus). Ohjelmasta tulee tällöin useinkin kone/käyttöjärjestelmäkohtainen. Konsoli-I/O main()-funktion käynnistyessä on käytettävissä kolme FILE*-osoitinta: stdin Standardisyöttö, näppäimistö. stdout Standarditulostus, näyttö. stderr Standardivirhe, näyttö. Useat kirjastofunktiot operoivat näihin datavirtoihin. Merkki- ja merkkijono-konsoli-i/o int getchar() Palauttaa standardisyötöstä lukemansa merkin. Tiedoston loppuessa palautetaan EOF. int putchar(char) Kirjoittaa argumenttinsa standarditulostukseen. char *gets(char *buff) Lukee standardisyötöstä puskuriin buff telanpalautukseen päättyvän merkkijonon. Telanpalautusta ei oteta mukaan. Merkkijono päätetään \0 :lla. Arvona on buff. Formatoitu konsoli-i/o int printf(const char *format,) Formatoitu tulostus. int scanf(const char *format,) Formatoitu syöttö. Esim. #include <stdio.h> main() { float x, y; printf( "Kaksi lukua: " ); scanf( "%f%f", &x, &y ); printf( "Lukujen %f ja %f summa on %f\n", x, y, x + y ); Tiedostot Tiedostojen käsittely FILE *fopen(const char *nimi,const char *mod); Tiedoston nimi avaus. mod on merkeistä r (read), w (write), a (append) ja + (update) koostuva merkkijono. int fclose( FILE *file ); Tiedoston sulku. tuhoa- int remove( const char *nimi); Tiedoston minen. int puts(char *buff) Kirjoittaa puskurissa buff \0 :lla päätetyn merkkijonon standarditulostukseen. int fseek( FILE *file, long kohta, int miten ); Seuraava I/O kohta tavun päästä tiedoston alusta (miten=0), lopusta (miten=2) tai nykykohdasta (miten=1). Tiedosto-I/O int fgetc( FILE *file ); Palauttaa seuraavan merkin datavirrassa file. int fputc( int c, FILE *file ); Kirjoittaa merkin c tiedostoon file. char *fgets( char *s, int n, FILE *file ); Lukee puskuriin s merkkiin \n päättyvän, korkeintaan n 1 merkkiä pitkän, merkkijonon. int fputs( const char *s, FILE *file ); Kirjoittaa puskurista s merkkijonon datavirtaan file. int fprintf(file *file, const char *form, ); Kuten printf(). int fscanf( FILE *file, const char *form, ); Kuten scanf().
Formatoimaton (binäärinen) I/O long fread(void *b,long k,long n,file *file); Lukee puskuriin b n kappaletta k tavun suuruista oliota. long fwrite(const void *b,long k,long n, FILE *file); Kirjoittaa puskurista b n kappaletta k tavun suuruista oliota. Formatoitu I/O merkkijonoon/jonosta int sprintf( char *b, const char *fm, ); Kuten printf(), mutta tulostus puskuriin b. int sscanf(const char *b,const char *fm,); Kuten scanf(), mutta luku puskurista b. 1.2 Merkkijonot Prototyypit tiedostossa string.h. int strlen( const char *s ); Merkkijonon pituus. char *strcpy( char *dest, const char *src ); Merkkijonon kopiointi. char *strcat( char *dest, const char *src ); Liittää jonon src jonon dest perään. int strcmp( const char *s1, const char *s2 ); Merkkijonojen vertailu. Arvona < 0, jos s1 pienempi kuin s2, > 0, jos s1 suurempi kuin s2, ja 0, jos merkkijonot ovat samoja. void *memcpy(void *dst,const void *sr,long n); Kopioi n tavua. 1.3 Standardirutiinit Prototyypit tiedostossa stdlib.h. double atof( const char *s ); Muuntaa merkkijonon s liukuluvuksi. int atoi( const char *s ); Muuntaa merkkijonon s kokonaisluvuksi. char *getenv( const char *nimi ); Palauttaa osoittimen ympäristömuuttujan nimi arvoon. (WINDOWSissa ympäristömuuttujat asetetaan esim. SET nimi=arvo tyyppisillä komennoilla) int putenv( const char *jono ); Asettaa ympäristöön jonon. (WINDOWSissa jono voi olla esim. "PATH=C:\BIN") void qsort( void *base, long n, long w, int(*cmp)(const void*, const void*) ); Quicksortlajittelu. 1.4 Muistinhallinta Prototyypit tiedostossa alloc.h. void *malloc( long koko ); void *calloc( long kpl, long koko ); void *realloc( void *block, long koko ); Muuttaa aiemmin varatun muistiblokin block kokoa. void free( void *block ); 1.5 Prosessikontrolli Prototyypit tiedostossa process.h. void exit( int status ); Lopettaa ohjelman ja palauttaa arvon status kutsuvalle prosessille. Tiedostot suljetaan ennen ohjelman lopetusta. void abort(); Hätälopetus. int execl( char *path, char *arg0, char *arg1,, char *argn, NULL ); Lataa kutsuvan prosessin päälle ja suorittaa ohjelman path, jonka komentoriviargumenteiksi tulevat merkkijonot arg0 (yleensä merkkijonon path kopio), arg1,...,argn. Mikäli kutsu onnistuu, execl() ei koskaan palaa. Tästä funktiosta on lukuisia argumenttien esitystapojen suhteen poikkeavia muunnelmia. Lapsiprosessit (child processes) int spawnl( char *path, char *arg0, char *arg1,, char *argn, NULL ); Kuten execl(), mutta ohjelmaa ei ladata kutsuvan prosessin päälle. spawnl() palauttaa suoritetun ohjelman status-koodin. Tästä funktiosta on myös lukuisia muunnelmia. int fork(); Luo uuden prosessin, joka on oleellisesti kutsuvan prosessin kopio. Ohjelmoijan kannalta fork() palaa kahdesti: arvolla 0 luotuun lapsiprosessiin ja ns. lapsiprosessi-id:llä kutsuvaan prosessiin. Lapsiprosessi voi esim. kutsua myöhemmin funktiota execl(). UNIXissa, samoin kuin monissa muissa ns. moniprosessikäyttöjärjestelmissä fork() on tärkein uusien prosessien luontimekanismi. Esim. UNIXissa jokainen prosessi lukuunottamatta prosessia 1 (init) luodaan fork():lla. Esim. main() { int child_id, stat; if(!(child_id = fork()) ) { cout << "Lapsiprosessissa\n"; sleep( 20 ); // Nukutetaan lasta 20s // tuutilullaa cout << "Lopetetaan lapsiprosessi\n"; exit( 0 ); cout << "Luotiin lapsiprosessi " << child_id
<< "\n"; wait( &stat ); // Odota lapsiprosessin // päättymistä cout << "Lapsiprosessi päättyi\n"; 1.6 Kontit Standardikirjaston kontit on määritelty nimiavaruudessa std. Ne voidaan jakaa kahteen ryhmään: sekventiaaliset kontit, esim. vektorit. assosiatiiviset kontit, joissa olioihin voidaan viitata avaimella. Kontteihin talletetaan objektien kopioita. Siksi objekteille täytyy olla määriteltynä sijoitusoperaattori, esim. X& X::operator=( const X& x ) { return *this; kopiomuodostin, esim. X::X( const X& x ) { Jokainen kontti määrittelee joukon tyyppinimiä, mm. template<class T,.> class Cont { typedef T value_type; typedef reference; typedef const_reference; typedef size_type; typedef iterator; typedef const_iterator; typedef reverse_iterator; typedef const_reverse_iterator; Tässä value_type on konttiin talletettavan tiedon tyyppi. reference ja const_reference käyttäytyvät kuten tyypit T& ja const T&. size_type on lukumäärälaskuriksi sopiva kokonaislukutyyppi. iterator ja const_iterator käyttäytyvät kuten T* ja const T*. Näiden tyyppisille objekteille on määritelty mm. inkrementointioperaattori ++. reverse_iterator ja const_reverse_iterator tyypit käyttäytyvät kuten iterator ja const_iterator, mutta niiden tyyppiset objektit tottelevat dekrementointioperaatiota --. Tyyppimäärittelyjen avulla on mahdollista kirjoittaa geneerisiä ohjelmia, esim. template<class C> typename C::value_type sum( const C& c ) { typename C::value_type s = 0; typename C::const_iterator p = c.begin(); while( p!= c.end() ) { s += *p; ++p; return s; Huom.Avainsana typename kertoo kääntäjälle, että seuraava tunnus tarkoittaa tyyppiä. Normaalisti resoluutio-operaattorilla viitataan luokan jäseniin: X::c tarkoittaa luokan X jäsentä c. Jokainen kontti määrittelee iteraattorit template<class T, > class Cont{ iterator begin(); const_iterator begin() const; iterator end(); const_iterator end() const; reverse_iterator rbegin(); const_reverse_iterator rbegin() const; reverse_iterator rend(); const_reverse_iterator rend() const; Metodin begin() palauttama olio viittaa kontin ensimmäiseen alkioon. end() palauttaman olion voidaan ajatella viittaavan viimeistä alkiota seuraavaan alkioon. rbegin() palauttama olio viittaa viimeiseen alkioon. rend() palauttama olio viittaa ensimmäistä edeltävään alkioon. Jokaisessa kontissa on myös määritelty metodi size_type size(), joka kertoo konttiin talletettujen olioiden lukumäärän. Vector (<vector>) Standardikirjaston määrittelemässä vektorissa vector voidaan alkioita käsitellä mielivaltaisessa järjestyksessä: template <class T> class vector { reference operator[]( size_type n ); const_reference operator[]( size_type n ) const; refrence at( size_type n ); const_reference at( size_type n ) const; reference front();
const_reference front() const; reference back(); const_reference back() const; Kontin vector indeksointioperaattorit operator[] eivät tarkista indeksiä. Käyttäjän on huolehdittava siitä, että indeksi pysyy sallituissa rajoissa, ts. välillä 0 alkioiden lukumäärä - 1. metodit at() tarkistavat indeksin laillisuuden. Mikäli indeksi on laiton, ne heittävät out_of_range-poikkeuksen (ks. Poikkeukset). indeksointioperaattorit ovat nopeampia kuin at()- metodit. metodit front() ja back() palauttavat referenssin vektorin ensimmäiseen ja viimeiseen alkioon. aksessointioperaatioiden [] ja at() argumentti on kokonaislukutyyppiä size_type, kun taas mm. metodi begin() palauttaa jonkin iteraattorityypin. Siispä lausekkeen c[c.begin()] kaltaiset ilmaisut ovat laittomia. Luokka vector määrittelee mm. muodostimet template <class T> class vector{ vector(); vector( size_type n ); vector( const vector& v ); Muodostin vector() luo vektorin, jonka koko riippuu implementoinnista. vector( size_type n) luo n alkioisen vektorin. vector( const vector&v) luo kopion vektorista v. Luokan vector objekteja voidaan käyttää myös pinon tavoin: template <class T> class vector{ void push_back( const T& x ); void pop_back(); Metodi push_back() lisää alkion vektorin loppuun vektorin koon kasvaessa yhdellä. pop_back() poistaa vektorin viimeisen alkion, joten vektorin koko pienenee yhdellä. Alkioita on myös mahdollista lisätä ja poistaa vektorin keskeltä: template <class T> class vector{ iterator insert( iterator p, const T& x ); void insert( iterator p, size_type n, const T& x ); iterator erase( iterator p ); iterator erase( iterator first, iterator last ); void clear(); Metodit insert( iterator p, ) lisäävät alkioita iteraattorin p osoittaman alkion eteen. erase( iterator ) poistavat iteraattorin viittaaman alkion tai kaikki iteraattorien väliin jäävät alkiot. Metodi clear() tyhjentää koko vektorin. List (<list>) Lisäysten ja poistojen kannalta listarakenne on optimaalinen (ks. Kaksoislinkitetty lista). Tälläisen rakenteen toteuttaa standardikirjaston list-kontti. Se tarjoaa kaikki edellä mainitut vector-kontin metodit lukuunottamatta indeksointioperaatioita, joita ei ole mahdollista implementoida tehokkaiksi. Listojen manipulointiin on tarjolla metodit template <class T> class list{ void splice( iterator pos, list& x ); void splice( iterator pos, list& x, iterator p ); void splice( iterator pos, list& x, iterator first, iterator last ); void merge( list& x ); void sort(); Operaatio splice( iterator pos, list&x ) siirtää listan x alkiot iteraattorin pos osoittaman alkion edeltäjiksi. splice( iterator pos, list&x, iterator p ) siirtään listasta x iteraattorin p osoittaman alkion iteraattorin pos osoittaman alkion eteen. splice( iterator pos, list&x, iterator first, iterator last ) siirtää listasta x iteraattorien first ja last osoittamien alkioiden väliin jäävät alkiot (*first mukaanlukien) kohdan pos eteen. merge() yhdistää kaksi järjestettyä listaa. sort() järjestää listan.
Jotta metodit sort() ja merge() toimisivat, täytyy alkioiden olla vertailtavissa. Vertailumetodina käytetään oletuksena operaattoria <. Käyttäjä voi myös määritellä jonkin muun vertailumenetelmän. Erikoisesti listan kärjen käsittelyyn on metodit template <class T> class list{ reference front(); const_reference front() const; void push_front( const T& x ); void pop_front(); Nämä toimivat vastaavien back-operaatioiden tavoin, mutta kohdistuvat listan kärkeen. Deque (<deque>) Luokka template <class T> class deque{ // tyypit // vektorioperaatiot // front-operaatiot on optimoitu silmälläpitäen ensimmäisen ja viimeisen alkion lisäystä ja poistoa. indeksoinnin suhteen lähes yhtä tehokas kuin vektori. vektorin lailla tehoton lisättäessä ja poistettaessa alkioita rakenteen keskeltä. Stack (<stack>) Pinorakenne stack on yleensä toteutettu adaptoimalla joko vektori tai deque-rakenne, kuten template <class T> class stack{ protected: deque<t> c; value_type& top() { return c.back(); void push( const value_type& x ) { c.push_back( x ); void pop() { c.pop_back(); Queue (<queue>) Jonorakenne on toteutettu pinorakenteen tavoin adaptoimalla, kuten template <class T> class queue{ protected: deque<t> c; value_type& front() { return c.front(); value_type& back() { return c.back(); void push( const value_type& x ) { c.push_back( x ); void pop() { c.pop_front(); Map (<map>) Assosiatiiviseen rakenteeseen map talletetaan avain-arvopareja. Siksi siinä on uusia typpimäärittelyjä ja muutamat entiset määrittely poikkeavat edellä esitetystä, mm. template <class Key, class T, class Cmp> class map{ typedef Key key_type; typedef T mapped_type; typedef pair<const Key, T> value_type; typedef Cmp key_compare; Tässä mallipohjan parametri Cmp on avainten vertailussa käytettävän olion tyyppi. Vertailtaessa kutsutaan ko. objektin funktiokutsumetodia bool operator()( const Key& k1, const Key& k2). Usein vertailuobjektiksi soveltuu standardikirjaston tiedostossa <functional> suurinpiirtein seuraavasti määritellyn mallipohjan template<class T> class less{ bool operator()( const T& t1, const T& t2 ) { return t1 < t2; mukaan instantioitu tyyppi less<key>. Avaimet ja arvot talletetaan pareina template <class T1, class T2> class pair { typedef T1 first_type; typedef T2 second_type; T1 first; T2 second; pair(); pair( const T1& x, const T2& y ); Indeksointi tapahtuu avaimen perusteella template <class Key, class T, class Cmp> class map{ mapped_type& operator[]( const key_type& k ); Mikäli avainta ei löydy, talletetaan rakenteeseen uusi alkio ja palautetaan referenssi tähän. Indeksointioperaattorin lisäksi map-rakenteesta voidaan etsiä avaimia mm. metodeilla template <class Key, class T, class Cmp> class map{ iterator find( const key_type& k ); size_type count( const key_type& k );
iterator lower_bound( const key_type& k ); iterator upper_bound( const key_type& k ); Funktio find( k ) palauttaa iteraattorin pariin, jonka ensimmäisenä jäsenenä on avain k. Mikäli tätä avainta ei löydy, palautetaan iteraattori end(). count( k ) laskee niiden elementtien lukumäärän, joiden avaimena on k. lower_bound( k ) palauttaa iteraattorin ensimmäiseen pariin, jonka avaimena on k. upper_bound( k ) palauttaa iteraattorin ensimmäiseen pariin, jonka avain on suurempi kuin k. Rakenteessa map voi kukin avain esiintyä vain yhden kerran. Tämän variaatio multimap sallii saman avaimen useamman kertaisen talletuksen. Set (<set>) Joukko set eroaa rakenteesta map ainoastaan siinä, että siihen talletetaan vain avaimia, joihin ei liity mitään arvoja: template <class Key, class Cmp> class set{ // Kuten map, paitsi että typedef Key value_type; typedef Cmp value_compare; // ei indeksointioperaattoria [] Myös tästä kontista on variaatio multiset, johon saman avaimen voi tallettaa useamman kerran. käyttäen. Merkkijonoille on määritelty sijoitusoperaatiot basic_string& operator=( const basic_string& ); basic_string& operator=( const Ch* p ); basic_string& operator=( Ch c ); basic_string& assign( const basic_string& ); basic_string& assign( const Ch* s, size_type n ); basic_string& assign( const Ch* s ); Merkkijonoja voidaan verrata keskenään ja C:n merkkijonojen kanssa mm. metodeilla int compare( const basic_string& ); int compare( const Ch* s );.. Merkkijonojoihin voidaan lisätä ja niistä voidaan poistaa sekä merkkejä että merkkijonoja. Näiden lisäksi operaattori + on ylikuormattu liittämään merkkijonoja tosiinsa. Merkkijonoista voidaan etsiä merkkejä ja alimerkkijonoja. Merkkijonot (<string>) Merkkijonojen tallennukseen on kontti // tyypit kuten muissakin konteissa Parametri Ch ilmoittaa merkkien esitykseen käytettävän tyypin. Normaali merkkijono on toteutettu määrittelyllä typedef basic_string<char> string; Merkkijono voidaan alustaa merkkitaulukoilla ja C:n merkkijonoilla muodostimia basic_string( const Ch* p, size_type n ); basic_string( const Ch* p );