Ohjelmointi++ - 9.3.9 inline- metodit ja tavalliset metodit

9.3.9 inline- metodit ja tavalliset metodit

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:

olioalk\aikacla5.cpp - metodit 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:

1.: Kirjoitetaan metodi luokan sisälle. Tässä monisteessa käytetään jatkossa tätä tapaa lähinnä siitä syystä, että ohjelmalistaukset tulevat näin hieman lyhyemmiksi.
2.: Kirjoitetaan metodi luokan ulkopuolella ja kirjoitetaan metodin toteutuksen eteen inline.

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:

olioalk\inline.cpp - esimerkki optimoinnista

	#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!