Olemme kaikissa edeltävissä olioesimerkeissä kirjoittaneet metodien toteutuksen myös luokan esittelyn sisään. Javassa näin tehdään aina, mutta C++:ssa oikeastaan varsin harvoin. Tyypillisempi tapa kirjoittaa on sellainen, missä ensin esitellään luokka ilman metodien toteutusta ja sitten metodit esitellään luokan ulkopuolella:
#include <iostream.h> #include <iomanip.h> class cAika { int h,m; public: cAika(int ih=0, int im=0); void aseta(int ih,int im=0); void lisaa(int lisa_min); void tulosta() const; }; void cAika::aseta(int ih,int im) { h = ih; m = im; lisaa(0); } cAika::cAika(int ih, int im) { aseta(ih,im); } void cAika::lisaa(int lisa_min) { int yht_min = h * 60 + m + lisa_min; h = yht_min / 60; m = yht_min % 60; } void cAika::tulosta() const { cout << setfill('0') << setw(2) << h << ":" << setw(2) << m << endl; } int main(void) { cAika a1, a2(13), a3(14,175); a1.tulosta(); a2.tulosta(); a3.tulosta(); a1.aseta(12,15); a2.aseta(16,-15); a1.tulosta(); a2.tulosta(); return 0; }
Jos metodin toteutus on luokan ulkopuolella, pitää metodin nimen eteen liittää tieto siitä, minkä luokan metodista on kyse. Esimerkiksi:
void cAika::lisaa(int lisa_min)
Nyt metodit ovat todellisia kutsuttavia aliohjelmia. Tähän saakka metodit ovat olleet inline- funktioita, eli niihin ei ole tehty aliohjelmakutsua, vaan niiden koodi on sijoitettu kutsun tilalle. Etuna on nopeampi suoritus kun aliohjelmaan siirtyminen ja paluu jäävät pois, mutta haittana suurempi ohjelman koko, erityisesti jos kutsuja on paljon ja metodit ovat suuria.
Jos nopeussyistä jälkeenpäin jokin luokan ulkopuolelle kirjoitettu metodi haluttaisiinkin takaisin inline- metodiksi, voidaan tämä tehdä myös inline- avainsanalla:
inline void cAika::aseta(int ih,int im) { h = ih; m = im; lisaa(0); }
Siis inline- metodeja voidaan tehdä kahdella eri tavalla:
Sopivalla inline- määreen käytöllä mahdollinen olio- ohjelmoinnin byrokratiasta aiheutuva hitaus voidaan poistaa. Tosin inline kannattaa laittaa vain usein kutsuttavien lyhyiden metodien eteen.
Esimerkiksi seuraavasta ohjelmasta:
#include <iostream.h> inline void ynnaa_yksi(int &ri) { ri = ri + 1; } inline void ynnaa_kaksi(int &ri) { ynnaa_yksi(ri); ynnaa_yksi(ri); } int main (void) { int i = 10; ynnaa_kaksi(i); cout << i << endl; return 0; }
riveistä
int i = 10; ynnaa_kaksi(i);
hyvä kääntäjä kääntää koodin:
mov eax,10 // Suoraan kääntäjä ei välttämättä uskalla laittaa mov eax,12 inc eax // koska se ei voi tietää tarvitaanko inc lauseen ominaisuutta inc eax // Oikein hyvä kääntäjä ehkä laittaisikin mov eax,12
joka on täsmälleen sama koodi, joka generoituu lauseista
i = 10; ++i; ++i;
Jos inline- määreet jätettäisiin ynnaa- aliohjelmista pois, olisi ynnaa_kaksi kutsu yli 30 kertaa hitaampi!